Spy on webchannel for test logging

Author: MarkDuckworth

packages/firestore/src/util/log.ts

@@ -26,7 +26,9 @@ export { LogLevel, LogLevelString };
 
 const logClient = new Logger('@firebase/firestore');
 const defaultLogHandler = logClient.logHandler;
-let logBuffer: LogBuffer | undefined;
+let logBuffer:
+  | LogBuffer<{ level: LogLevel; now: string; args: unknown[] }>
+  | undefined;
 
 // Helper methods are needed because variables can't be exported as read/write
 export function getLogLevel(): LogLevel {
@@ -59,7 +61,11 @@ export function setLogLevel(
   logClient.setLogLevel(logLevel);
 
   if (includeContext > 0) {
-    logBuffer = new LogBuffer(includeContext);
+    logBuffer = new LogBuffer<{
+      level: LogLevel;
+      now: string;
+      args: unknown[];
+    }>(includeContext);
     logClient.logHandler = bufferingLogHandler;
   } else {
     logBuffer = undefined;
@@ -107,8 +113,8 @@ function argToString(obj: unknown): string | unknown {
   }
 }
 
-class LogBuffer {
-  private _buffer: Array<{ level: LogLevel; now: string; args: unknown[] }>;
+export class LogBuffer<T> {
+  private _buffer: T[];
   private _numTruncated: number = 0;
 
   constructor(readonly bufferSize: number) {
@@ -132,12 +138,8 @@ class LogBuffer {
    * @param now
    * @param args
    */
-  add(level: LogLevel, now: string, args: unknown[]): void {
-    this._buffer.push({
-      level,
-      now,
-      args
-    });
+  add(v: T): void {
+    this._buffer.push(v);
 
     if (this._buffer.length > this.bufferSize) {
       // remove the first (oldest) element
@@ -154,18 +156,14 @@ class LogBuffer {
     return this._numTruncated;
   }
 
-  get first(): { level: LogLevel; now: string; args: unknown[] } | undefined {
+  get first(): T | undefined {
     return this._buffer[0];
   }
 
   /**
    * Iterate from oldest to newest.
    */
-  [Symbol.iterator](): Iterator<{
-    level: LogLevel;
-    now: string;
-    args: unknown[];
-  }> {
+  [Symbol.iterator](): Iterator<T> {
     let currentIndex = 0;
     // Create a snapshot of the buffer for iteration.
     // This ensures that if the buffer is modified while iterating (e.g., by adding new logs),
@@ -174,11 +172,7 @@ class LogBuffer {
     const bufferSnapshot = [...this._buffer];
 
     return {
-      next: (): IteratorResult<{
-        level: LogLevel;
-        now: string;
-        args: unknown[];
-      }> => {
+      next: (): IteratorResult<T> => {
         if (currentIndex < bufferSnapshot.length) {
           return { value: bufferSnapshot[currentIndex++], done: false };
         } else {
@@ -220,7 +214,7 @@ const bufferingLogHandler: LogHandler = (instance, logType, ...args): void => {
 
   // Buffer any messages less than the current logLevel
   if (logType < instance.logLevel) {
-    logBuffer!.add(logType, now, args);
+    logBuffer!.add({ level: logType, now, args });
     return;
   }
 

packages/firestore/test/integration/util/firebase_export.ts

@@ -24,13 +24,102 @@ import { FirebaseApp, initializeApp } from '@firebase/app';
 
 import { Firestore, initializeFirestore, setLogLevel } from '../../../src';
 import { PrivateSettings } from '../../../src/lite-api/settings';
+import { logDebug } from '../../../src/util/log';
 
 // TODO(dimond): Right now we create a new app and Firestore instance for
 // every test and never clean them up. We may need to revisit.
 let appCount = 0;
 
+const originalFetch = globalThis.fetch;
+
+/**
+ * A class that acts as a spy for a ReadableStream.
+ * It logs the content of the input stream as it's read and then pipes it through.
+ */
+class ReadableStreamSpy<Uint8Array> {
+  private inputReadableStream: ReadableStream<Uint8Array>;
+  private spyTransformStream: TransformStream<Uint8Array, Uint8Array>;
+  private spiedReadableStream: ReadableStream<Uint8Array>;
+
+  private readonly decoder = new TextDecoder();
+
+  /**
+   * Creates an instance of ReadableStreamSpy.
+   * @param inputReadableStream The ReadableStream to spy on.
+   */
+  constructor(inputReadableStream: ReadableStream<Uint8Array>) {
+    if (!(inputReadableStream instanceof ReadableStream)) {
+      throw new Error('Input must be a ReadableStream.');
+    }
+
+    this.inputReadableStream = inputReadableStream;
+
+    // Create a TransformStream that logs data
+    this.spyTransformStream = new TransformStream<Uint8Array, Uint8Array>({
+      transform: (
+        chunk: Uint8Array,
+        controller: TransformStreamDefaultController<Uint8Array>
+      ) => {
+        // @ts-ignore
+        logDebug(this.decoder.decode(chunk));
+
+        controller.enqueue(chunk); // Pass the chunk along
+      },
+      flush: (controller: TransformStreamDefaultController<Uint8Array>) => {
+        // Any cleanup or final actions if needed
+      }
+    });
+
+    // Pipe the input stream through the spy transform stream
+    this.spiedReadableStream = this.inputReadableStream.pipeThrough(
+      this.spyTransformStream
+    );
+  }
+
+  /**
+   * Gets the spied-on ReadableStream.
+   * You should read from this stream to observe the logged chunks.
+   * @returns The ReadableStream with spy functionality.
+   */
+  get readableStream(): ReadableStream<Uint8Array> {
+    return this.spiedReadableStream;
+  }
+}
+
+globalThis.fetch = async function (requestOrUrl, options) {
+  // @ts-ignore
+  const url =
+    typeof requestOrUrl === 'string' ? requestOrUrl : requestOrUrl.url;
+
+  logDebug(`FETCH FOR ${url}`);
+
+  if (
+    url.startsWith(
+      'https://firestore.googleapis.com/google.firestore.v1.Firestore/Listen/channel'
+    )
+  ) {
+    const response = await originalFetch(requestOrUrl, options);
+
+    if (response.body) {
+      const spy = new ReadableStreamSpy(response.body);
+
+      return Promise.resolve(
+        new Response(spy.readableStream, {
+          headers: response.headers,
+          status: response.status,
+          statusText: response.statusText
+        })
+      );
+    }
+
+    return Promise.resolve(response);
+  }
+
+  return originalFetch(requestOrUrl, options);
+};
+
 // enable contextual debug logging
-setLogLevel('error', 100);
+setLogLevel('error', 200);
 
 export function newTestApp(projectId: string, appName?: string): FirebaseApp {
   if (appName === undefined) {