From a211cf0b889192f0f82c239afaf94118cd58fd75 Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 20:11:00 -0500 Subject: [PATCH 1/6] test: print server log lines only for failing tests The logger writes each JSON line straight to process.stdout or process.stderr, so a test run printed about 4,900 of them, 1.05 MB of a 1.17 MB CI log. A vitest setup file routes those lines through console, which vitest files under each test, and silent: "passed-only" prints them only when that test fails. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 4 ++ .../helpers/route-log-lines-to-console.ts | 48 +++++++++++++++++++ vitest.config.ts | 5 ++ 3 files changed, 57 insertions(+) create mode 100644 src/__tests__/helpers/route-log-lines-to-console.ts diff --git a/AGENTS.md b/AGENTS.md index a942f2355..3cd9058d6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -900,6 +900,10 @@ Two naming layers — MCP (JSON wire format) and TypeScript (internal): `src/__tests__/runs-as-root.ts`. CI runs it as a normal user. To run these tests from a root shell, such as a cloud session, use `npm run test:as-nobody`; it takes the same arguments as `vitest run`. +- Vitest prints a test's console output, the server's log lines included, + only when that test fails (`silent: "passed-only"`, with the log lines + routed to the console by `src/__tests__/helpers/route-log-lines-to-console.ts`). + To see a passing test's output, run its file with `--silent=false`. - Tests read as a behavioral spec: one focused `it()` per behavior, named so a failure identifies the regressed behavior without reading the body, and matching what is asserted. For every guard or invariant, diff --git a/src/__tests__/helpers/route-log-lines-to-console.ts b/src/__tests__/helpers/route-log-lines-to-console.ts new file mode 100644 index 000000000..891a4633e --- /dev/null +++ b/src/__tests__/helpers/route-log-lines-to-console.ts @@ -0,0 +1,48 @@ +/** + * Vitest setup file that keeps server log lines out of passing tests' output. + * - The logger writes each JSON line straight to process.stdout or + * process.stderr, which vitest prints for every test. + * - This wrapper sends those lines through console instead, so vitest files + * each under its test and `silent: "passed-only"` prints it only when that + * test fails. + * - A test that spies on process.stdout.write replaces the wrapper while its + * spy is active, so it still captures every line it asserts on. + */ + +/** Every line the logger emits, including its console warnings, opens with its timestamp field. */ +const LOG_LINE_START = '{"timestamp":' + +type WriteCallback = (error?: Error | null) => void + +const routeLogLinesToConsole = ( + stream: NodeJS.WriteStream, + logToConsole: (line: string) => void, +): void => { + const writeToStream = stream.write.bind(stream) + + stream.write = ( + chunk: Uint8Array | string, + encodingOrCallback?: BufferEncoding | WriteCallback, + callback?: WriteCallback, + ): boolean => { + // The logger passes neither an encoding nor a callback, so a write that carries one is never a log line. + const isLogLine = + typeof chunk === "string" && + chunk.startsWith(LOG_LINE_START) && + !encodingOrCallback && + !callback + + if (isLogLine) { + logToConsole(chunk.trimEnd()) + return true + } + if (typeof encodingOrCallback === "function") return writeToStream(chunk, encodingOrCallback) + return writeToStream(chunk, encodingOrCallback, callback) + } +} + +// console is the destination here: vitest captures it per test, which process.stdout is not. +// eslint-disable-next-line no-console +routeLogLinesToConsole(process.stdout, (line) => console.log(line)) +// eslint-disable-next-line no-console +routeLogLinesToConsole(process.stderr, (line) => console.error(line)) diff --git a/vitest.config.ts b/vitest.config.ts index 73542a0ad..9ba0a2459 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -13,5 +13,10 @@ export default defineConfig({ // Tests that assert on real log lines must not inherit a developer's // LOG_LEVEL or LOG_DIR, which would hide those lines or write to a real log folder. env: { LOG_LEVEL: "info", LOG_DIR: "none" }, + // The server logs thousands of lines across the suite. Its setup file + // routes them into each test's console capture, which this setting + // prints only for a failing test, so a run's output shows its failures. + setupFiles: ["src/__tests__/helpers/route-log-lines-to-console.ts"], + silent: "passed-only", }, }) From d1794177568b3fd9eabcd27b658b305ee24883dc Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:08:03 -0500 Subject: [PATCH 2/6] test: pin the logger's console write shape that the log routing relies on The setup file recognizes a log line as one string that opens with the timestamp field, written with no encoding or callback. A logger test now fails if either changes, so a logger edit cannot silently print every log line again. Also completes the setup file's garbled sentence. Co-Authored-By: Claude Opus 5.5 --- .../helpers/route-log-lines-to-console.ts | 4 ++-- src/__tests__/logger.test.ts | 22 +++++++++++++++++++ 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/src/__tests__/helpers/route-log-lines-to-console.ts b/src/__tests__/helpers/route-log-lines-to-console.ts index 891a4633e..062d41988 100644 --- a/src/__tests__/helpers/route-log-lines-to-console.ts +++ b/src/__tests__/helpers/route-log-lines-to-console.ts @@ -3,8 +3,8 @@ * - The logger writes each JSON line straight to process.stdout or * process.stderr, which vitest prints for every test. * - This wrapper sends those lines through console instead, so vitest files - * each under its test and `silent: "passed-only"` prints it only when that - * test fails. + * each line under the test that wrote it, and `silent: "passed-only"` prints + * the line only when that test fails. * - A test that spies on process.stdout.write replaces the wrapper while its * spy is active, so it still captures every line it asserts on. */ diff --git a/src/__tests__/logger.test.ts b/src/__tests__/logger.test.ts index 7344bad56..e72fdcb93 100644 --- a/src/__tests__/logger.test.ts +++ b/src/__tests__/logger.test.ts @@ -1523,3 +1523,25 @@ describe("logger child lazy props", () => { ]) }) }) + +// The test setup file that routes log lines to vitest's console capture +// (helpers/route-log-lines-to-console.ts) recognizes a line by these two +// facts, so a change to either would print every log line again unnoticed. +describe("console write shape", () => { + it("writes each line as one string that opens with its timestamp field, with no encoding or callback", () => { + const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true) + const stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true) + onTestFinished(() => { + stdoutSpy.mockRestore() + stderrSpy.mockRestore() + }) + + logger.info("shape probe info") + logger.error("shape probe error") + + expect(stdoutSpy).toHaveBeenCalledTimes(1) + expect(stdoutSpy).toHaveBeenCalledWith(expect.stringMatching(/^\{"timestamp":/)) + expect(stderrSpy).toHaveBeenCalledTimes(1) + expect(stderrSpy).toHaveBeenCalledWith(expect.stringMatching(/^\{"timestamp":/)) + }) +}) From 2283c2589f9c60925dbd831fd55a8bb959bf0e5e Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:28:08 -0500 Subject: [PATCH 3/6] style: clarify the log-line routing setup file and its config comment MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - The helper returns the replacement write and the call site assigns it, so the function no longer mutates the stream it is given; the original write is named originalWrite. - Comments name src/logger.ts instead of "the server", state why the line is trimmed and why write is called in two shapes, say that vitest's console never writes to process.stdout, and point to the test that pins the logger's write shape. - The vitest config comment names `silent: "passed-only"` directly, and the AGENTS.md bullet gives the exact npm test command. Ship-Check: code-quality · claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 4 +-- .../helpers/route-log-lines-to-console.ts | 36 +++++++++++-------- vitest.config.ts | 6 ++-- 3 files changed, 27 insertions(+), 19 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 3cd9058d6..ebe4931c9 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -900,10 +900,10 @@ Two naming layers — MCP (JSON wire format) and TypeScript (internal): `src/__tests__/runs-as-root.ts`. CI runs it as a normal user. To run these tests from a root shell, such as a cloud session, use `npm run test:as-nobody`; it takes the same arguments as `vitest run`. -- Vitest prints a test's console output, the server's log lines included, +- Vitest prints a test's console output, `src/logger.ts`'s lines included, only when that test fails (`silent: "passed-only"`, with the log lines routed to the console by `src/__tests__/helpers/route-log-lines-to-console.ts`). - To see a passing test's output, run its file with `--silent=false`. + To see a passing test's output, run `npm test -- --silent=false`. - Tests read as a behavioral spec: one focused `it()` per behavior, named so a failure identifies the regressed behavior without reading the body, and matching what is asserted. For every guard or invariant, diff --git a/src/__tests__/helpers/route-log-lines-to-console.ts b/src/__tests__/helpers/route-log-lines-to-console.ts index 062d41988..34b6e82be 100644 --- a/src/__tests__/helpers/route-log-lines-to-console.ts +++ b/src/__tests__/helpers/route-log-lines-to-console.ts @@ -1,31 +1,34 @@ /** - * Vitest setup file that keeps server log lines out of passing tests' output. + * Vitest setup file that keeps src/logger.ts's lines out of passing tests' output. * - The logger writes each JSON line straight to process.stdout or * process.stderr, which vitest prints for every test. * - This wrapper sends those lines through console instead, so vitest files * each line under the test that wrote it, and `silent: "passed-only"` prints * the line only when that test fails. - * - A test that spies on process.stdout.write replaces the wrapper while its - * spy is active, so it still captures every line it asserts on. + * - A test that spies on process.stdout.write puts its spy in front of the + * wrapper, so the spy still sees every line it asserts on. + * - Under vitest's default isolation, each test file runs in its own process, + * so the wrappers last until that process exits and need no restore. */ -/** Every line the logger emits, including its console warnings, opens with its timestamp field. */ +/** Every line src/logger.ts writes opens with its timestamp field. */ const LOG_LINE_START = '{"timestamp":' type WriteCallback = (error?: Error | null) => void -const routeLogLinesToConsole = ( +const createLogLineRoutingWrite = ( stream: NodeJS.WriteStream, logToConsole: (line: string) => void, -): void => { - const writeToStream = stream.write.bind(stream) +) => { + const originalWrite = stream.write.bind(stream) - stream.write = ( + return ( chunk: Uint8Array | string, encodingOrCallback?: BufferEncoding | WriteCallback, callback?: WriteCallback, ): boolean => { - // The logger passes neither an encoding nor a callback, so a write that carries one is never a log line. + // src/logger.ts passes neither an encoding nor a callback, so a write that + // carries one is never a log line. logger.test.ts pins this write shape. const isLogLine = typeof chunk === "string" && chunk.startsWith(LOG_LINE_START) && @@ -33,16 +36,21 @@ const routeLogLinesToConsole = ( !callback if (isLogLine) { + // The logger's line ends in a newline, and console adds its own. logToConsole(chunk.trimEnd()) return true } - if (typeof encodingOrCallback === "function") return writeToStream(chunk, encodingOrCallback) - return writeToStream(chunk, encodingOrCallback, callback) + + // The callback sits second or third in write's overloads, so each position + // needs its own call to type-check. Node handles both calls the same way. + if (typeof encodingOrCallback === "function") return originalWrite(chunk, encodingOrCallback) + return originalWrite(chunk, encodingOrCallback, callback) } } -// console is the destination here: vitest captures it per test, which process.stdout is not. +// vitest captures console per test, unlike process.stdout, and its console never +// writes to process.stdout, so a routed line cannot loop back through the wrapper. // eslint-disable-next-line no-console -routeLogLinesToConsole(process.stdout, (line) => console.log(line)) +process.stdout.write = createLogLineRoutingWrite(process.stdout, (line) => console.log(line)) // eslint-disable-next-line no-console -routeLogLinesToConsole(process.stderr, (line) => console.error(line)) +process.stderr.write = createLogLineRoutingWrite(process.stderr, (line) => console.error(line)) diff --git a/vitest.config.ts b/vitest.config.ts index 9ba0a2459..6b5f6fd07 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -13,9 +13,9 @@ export default defineConfig({ // Tests that assert on real log lines must not inherit a developer's // LOG_LEVEL or LOG_DIR, which would hide those lines or write to a real log folder. env: { LOG_LEVEL: "info", LOG_DIR: "none" }, - // The server logs thousands of lines across the suite. Its setup file - // routes them into each test's console capture, which this setting - // prints only for a failing test, so a run's output shows its failures. + // src/logger.ts writes thousands of lines across the suite, which would bury + // a run's failures. The setup file sends each line through console, and + // `silent: "passed-only"` prints a test's console output only when it fails. setupFiles: ["src/__tests__/helpers/route-log-lines-to-console.ts"], silent: "passed-only", }, From 5e189221bb8f5682aae7f41437098d0f222b97ce Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:35:35 -0500 Subject: [PATCH 4/6] test: cover the log-line routing setup file's routing and pass-through MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The setup file's write wrapper now has its own tests: a log line goes to the console without its newline and never to the stream, and text that is not a log line, a log line as bytes, and a log line with an encoding or a callback all reach the stream with their arguments in place and return the stream's result. The factory is exported for these tests and takes any object with a write method. The logger write-shape test's comment now states the rule the setup file applies instead of counting facts the test name lists differently. Ship-Check: test-audit · claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../helpers/route-log-lines-to-console.ts | 4 +- src/__tests__/logger.test.ts | 6 +- .../route-log-lines-to-console.test.ts | 85 +++++++++++++++++++ 3 files changed, 90 insertions(+), 5 deletions(-) create mode 100644 src/__tests__/route-log-lines-to-console.test.ts diff --git a/src/__tests__/helpers/route-log-lines-to-console.ts b/src/__tests__/helpers/route-log-lines-to-console.ts index 34b6e82be..7236b2909 100644 --- a/src/__tests__/helpers/route-log-lines-to-console.ts +++ b/src/__tests__/helpers/route-log-lines-to-console.ts @@ -16,8 +16,8 @@ const LOG_LINE_START = '{"timestamp":' type WriteCallback = (error?: Error | null) => void -const createLogLineRoutingWrite = ( - stream: NodeJS.WriteStream, +export const createLogLineRoutingWrite = ( + stream: Pick, logToConsole: (line: string) => void, ) => { const originalWrite = stream.write.bind(stream) diff --git a/src/__tests__/logger.test.ts b/src/__tests__/logger.test.ts index e72fdcb93..03b9d7db7 100644 --- a/src/__tests__/logger.test.ts +++ b/src/__tests__/logger.test.ts @@ -1524,9 +1524,9 @@ describe("logger child lazy props", () => { }) }) -// The test setup file that routes log lines to vitest's console capture -// (helpers/route-log-lines-to-console.ts) recognizes a line by these two -// facts, so a change to either would print every log line again unnoticed. +// The test setup file helpers/route-log-lines-to-console.ts sends a write to +// the console only when it has this shape. A write of any other shape goes to +// the stream, so passing tests would print every log line again. describe("console write shape", () => { it("writes each line as one string that opens with its timestamp field, with no encoding or callback", () => { const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true) diff --git a/src/__tests__/route-log-lines-to-console.test.ts b/src/__tests__/route-log-lines-to-console.test.ts new file mode 100644 index 000000000..4ff87e317 --- /dev/null +++ b/src/__tests__/route-log-lines-to-console.test.ts @@ -0,0 +1,85 @@ +import { describe, expect, it, vi } from "vitest" + +import { createLogLineRoutingWrite } from "./helpers/route-log-lines-to-console.js" + +type WriteCallback = (error?: Error | null) => void + +/** A line in the shape src/logger.ts writes, trailing newline included. */ +const LOG_LINE = '{"timestamp":"2026-11-12T21:00:00.000-05:00","level":"info","message":"probe"}\n' + +const writeCallback: WriteCallback = () => undefined + +const createRoutingWrite = () => { + // The stub returns false, which a real stream returns when the caller should + // wait, so a wrapper that returns true instead of the stream's result fails. + const streamWrite = vi.fn<(...writeArgs: unknown[]) => boolean>(() => false) + const logToConsole = vi.fn<(line: string) => void>() + const routingWrite = createLogLineRoutingWrite({ write: streamWrite }, logToConsole) + + return { streamWrite, logToConsole, routingWrite } +} + +describe("createLogLineRoutingWrite", () => { + it("sends a log line to the console without its trailing newline and never to the stream", () => { + const { streamWrite, logToConsole, routingWrite } = createRoutingWrite() + + expect(routingWrite(LOG_LINE)).toBe(true) + expect(logToConsole).toHaveBeenCalledTimes(1) + expect(logToConsole).toHaveBeenCalledWith( + '{"timestamp":"2026-11-12T21:00:00.000-05:00","level":"info","message":"probe"}', + ) + expect(streamWrite).not.toHaveBeenCalled() + }) + + type PassThroughCase = { + label: string + chunk: Uint8Array | string + encodingOrCallback?: BufferEncoding | WriteCallback + callback?: WriteCallback + expectedStreamArgs: ReadonlyArray + } + + const passThroughCases: ReadonlyArray = [ + { + label: "text that does not open with a timestamp field", + chunk: "plain output\n", + expectedStreamArgs: ["plain output\n", undefined, undefined], + }, + { + label: "a log line written as bytes", + chunk: Buffer.from(LOG_LINE), + expectedStreamArgs: [Buffer.from(LOG_LINE), undefined, undefined], + }, + { + label: "a log line with an encoding", + chunk: LOG_LINE, + encodingOrCallback: "utf8", + expectedStreamArgs: [LOG_LINE, "utf8", undefined], + }, + { + label: "a log line with a callback in second place", + chunk: LOG_LINE, + encodingOrCallback: writeCallback, + expectedStreamArgs: [LOG_LINE, writeCallback], + }, + { + label: "a log line with an encoding and a callback", + chunk: LOG_LINE, + encodingOrCallback: "utf8", + callback: writeCallback, + expectedStreamArgs: [LOG_LINE, "utf8", writeCallback], + }, + ] + + it.each(passThroughCases)( + "passes $label to the stream and returns the stream's result", + ({ chunk, encodingOrCallback, callback, expectedStreamArgs }) => { + const { streamWrite, logToConsole, routingWrite } = createRoutingWrite() + + expect(routingWrite(chunk, encodingOrCallback, callback)).toBe(false) + expect(streamWrite).toHaveBeenCalledTimes(1) + expect(streamWrite).toHaveBeenCalledWith(...expectedStreamArgs) + expect(logToConsole).not.toHaveBeenCalled() + }, + ) +}) From f84455b4b25f29983f492219a612567d7fda05a6 Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:40:44 -0500 Subject: [PATCH 5/6] style: give the log-line routing factory an explicit return type MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit AGENTS.md asks for explicit return types on exports, and the factory became an export when its tests were added. Ship-Check: triage · claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../helpers/route-log-lines-to-console.ts | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/__tests__/helpers/route-log-lines-to-console.ts b/src/__tests__/helpers/route-log-lines-to-console.ts index 7236b2909..f3eb1185d 100644 --- a/src/__tests__/helpers/route-log-lines-to-console.ts +++ b/src/__tests__/helpers/route-log-lines-to-console.ts @@ -16,17 +16,19 @@ const LOG_LINE_START = '{"timestamp":' type WriteCallback = (error?: Error | null) => void +type StreamWrite = ( + chunk: Uint8Array | string, + encodingOrCallback?: BufferEncoding | WriteCallback, + callback?: WriteCallback, +) => boolean + export const createLogLineRoutingWrite = ( stream: Pick, logToConsole: (line: string) => void, -) => { +): StreamWrite => { const originalWrite = stream.write.bind(stream) - return ( - chunk: Uint8Array | string, - encodingOrCallback?: BufferEncoding | WriteCallback, - callback?: WriteCallback, - ): boolean => { + return (chunk, encodingOrCallback, callback) => { // src/logger.ts passes neither an encoding nor a callback, so a write that // carries one is never a log line. logger.test.ts pins this write shape. const isLogLine = From 3d479a18839d82a0388947197b8b813d7c598c56 Mon Sep 17 00:00:00 2001 From: aliasunder <32620895+aliasunder@users.noreply.github.com> Date: Thu, 12 Nov 2026 21:52:16 -0500 Subject: [PATCH 6/6] test: check the routing the setup file installs on the real streams MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A test spies on console.log and console.error and writes a log line to process.stdout and process.stderr, so dropping or miswiring the setup file's two installation lines fails the suite. Ship-Check: pr-monitor · claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../route-log-lines-to-console.test.ts | 30 ++++++++++++++++--- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/src/__tests__/route-log-lines-to-console.test.ts b/src/__tests__/route-log-lines-to-console.test.ts index 4ff87e317..0b2da5faf 100644 --- a/src/__tests__/route-log-lines-to-console.test.ts +++ b/src/__tests__/route-log-lines-to-console.test.ts @@ -1,4 +1,4 @@ -import { describe, expect, it, vi } from "vitest" +import { describe, expect, it, onTestFinished, vi } from "vitest" import { createLogLineRoutingWrite } from "./helpers/route-log-lines-to-console.js" @@ -7,6 +7,10 @@ type WriteCallback = (error?: Error | null) => void /** A line in the shape src/logger.ts writes, trailing newline included. */ const LOG_LINE = '{"timestamp":"2026-11-12T21:00:00.000-05:00","level":"info","message":"probe"}\n' +/** LOG_LINE as the console receives it. */ +const ROUTED_LOG_LINE = + '{"timestamp":"2026-11-12T21:00:00.000-05:00","level":"info","message":"probe"}' + const writeCallback: WriteCallback = () => undefined const createRoutingWrite = () => { @@ -25,9 +29,7 @@ describe("createLogLineRoutingWrite", () => { expect(routingWrite(LOG_LINE)).toBe(true) expect(logToConsole).toHaveBeenCalledTimes(1) - expect(logToConsole).toHaveBeenCalledWith( - '{"timestamp":"2026-11-12T21:00:00.000-05:00","level":"info","message":"probe"}', - ) + expect(logToConsole).toHaveBeenCalledWith(ROUTED_LOG_LINE) expect(streamWrite).not.toHaveBeenCalled() }) @@ -83,3 +85,23 @@ describe("createLogLineRoutingWrite", () => { }, ) }) + +describe("the routing the setup file installs", () => { + const installedRoutingCases = [ + { label: "process.stdout to console.log", stream: process.stdout, consoleMethod: "log" }, + { label: "process.stderr to console.error", stream: process.stderr, consoleMethod: "error" }, + ] as const + + it.each(installedRoutingCases)( + "sends a log line written to $label", + ({ stream, consoleMethod }) => { + const consoleSpy = vi.spyOn(console, consoleMethod).mockImplementation(() => undefined) + onTestFinished(() => consoleSpy.mockRestore()) + + stream.write(LOG_LINE) + + expect(consoleSpy).toHaveBeenCalledTimes(1) + expect(consoleSpy).toHaveBeenCalledWith(ROUTED_LOG_LINE) + }, + ) +})