Add more tests.

Author: taeold

packages/functions/src/callable.test.ts

@@ -37,7 +37,7 @@ import {
   AppCheckInternalComponentName
 } from '@firebase/app-check-interop-types';
 import { makeFakeApp, createTestService } from '../test/utils';
-import { httpsCallable } from './service';
+import { FunctionsService, httpsCallable } from './service';
 import { FUNCTIONS_TYPE } from './constants';
 import { FunctionsError } from './error';
 
@@ -308,21 +308,26 @@ describe('Firebase Functions > Call', () => {
 
 describe('Firebase Functions > Stream', () => {
   let app: FirebaseApp;
+  let functions: FunctionsService;
+  let mockFetch: sinon.SinonStub;
   const region = 'us-central1';
 
-  before(() => {
+  beforeEach(() => {
     const useEmulator = !!process.env.FIREBASE_FUNCTIONS_EMULATOR_ORIGIN;
     const projectId = useEmulator
       ? 'functions-integration-test'
       : TEST_PROJECT.projectId;
     const messagingSenderId = 'messaging-sender-id';
     app = makeFakeApp({ projectId, messagingSenderId });
+    functions = createTestService(app, region);
+    mockFetch = sinon.stub(functions, 'fetchImpl' as any);
   });
 
-  it('successfully streams data and resolves final result', async () => {
-    const functions = createTestService(app, region);
-    const mockFetch = sinon.stub(globalThis, 'fetch' as any);
+  afterEach(() => {
+    mockFetch.restore();
+  })
 
+  it('successfully streams data and resolves final result', async () => {
     const mockResponse = new ReadableStream({
       start(controller) {
         controller.enqueue(new TextEncoder().encode('data: {"message":"Hello"}\n'));
@@ -349,14 +354,9 @@ describe('Firebase Functions > Stream', () => {
 
     expect(messages).to.deep.equal(['Hello', 'World']);
     expect(await streamResult.data).to.equal('Final Result');
-
-    mockFetch.restore();
   });
 
   it('handles network errors', async () => {
-    const functions = createTestService(app, region);
-    const mockFetch = sinon.stub(globalThis, 'fetch' as any);
-
     mockFetch.rejects(new Error('Network error'));
 
     const func = httpsCallable<Record<string, any>, string, string>(functions, 'errTest');
@@ -371,17 +371,11 @@ describe('Firebase Functions > Stream', () => {
       errorThrown = true;
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/internal`);
     }
-
     expect(errorThrown).to.be.true;
-    expect(streamResult.data).to.be.a('promise');
-
-    mockFetch.restore();
+    expectError(streamResult.data, "internal", "Internal");
   });
 
   it('handles server-side errors', async () => {
-    const functions = createTestService(app, region);
-    const mockFetch = sinon.stub(globalThis, 'fetch' as any);
-
     const mockResponse = new ReadableStream({
       start(controller) {
         controller.enqueue(new TextEncoder().encode('data: {"error":{"status":"INVALID_ARGUMENT","message":"Invalid input"}}\n'));
@@ -396,7 +390,7 @@ describe('Firebase Functions > Stream', () => {
       statusText: 'OK',
     } as Response);
 
-    const func = httpsCallable<Record<string, any>, string, string>(functions, 'errTest');
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'stream');
     const streamResult = await func.stream({});
 
     let errorThrown = false;
@@ -412,8 +406,6 @@ describe('Firebase Functions > Stream', () => {
 
     expect(errorThrown).to.be.true;
     expectError(streamResult.data, "invalid-argument", "Invalid input")
-
-    mockFetch.restore();
   });
 
   it('includes authentication and app check tokens in request headers', async () => {
@@ -427,9 +419,23 @@ describe('Firebase Functions > Stream', () => {
     authProvider.setComponent(
       new Component('auth-internal', () => authMock, ComponentType.PRIVATE)
     );
+    const appCheckMock: FirebaseAppCheckInternal = {
+      getToken: async () => ({ token: 'app-check-token' })
+    } as unknown as FirebaseAppCheckInternal;
+    const appCheckProvider = new Provider<AppCheckInternalComponentName>(
+      'app-check-internal',
+      new ComponentContainer('test')
+    );
+    appCheckProvider.setComponent(
+      new Component(
+        'app-check-internal',
+        () => appCheckMock,
+        ComponentType.PRIVATE
+      )
+    );
 
-    const functions = createTestService(app, region, authProvider);
-    const mockFetch = sinon.stub(globalThis, 'fetch' as any);
+    const functions = createTestService(app, region, authProvider, undefined, appCheckProvider);
+    const mockFetch = sinon.stub(functions, 'fetchImpl' as any);
 
     const mockResponse = new ReadableStream({
       start(controller) {
@@ -445,15 +451,151 @@ describe('Firebase Functions > Stream', () => {
       statusText: 'OK',
     } as Response);
 
-    const func = httpsCallable<Record<string, any>, string, string>(functions, 'errTest');
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'stream');
     await func.stream({});
 
     expect(mockFetch.calledOnce).to.be.true;
     const [_, options] = mockFetch.firstCall.args;
     expect(options.headers['Authorization']).to.equal('Bearer auth-token');
     expect(options.headers['Content-Type']).to.equal('application/json');
     expect(options.headers['Accept']).to.equal('text/event-stream');
+  });
 
-    mockFetch.restore();
+  it('aborts during initial fetch', async () => {
+    const controller = new AbortController();
+
+    // Create a fetch that rejects when aborted
+    const fetchPromise = new Promise<Response>((_, reject) => {
+      controller.signal.addEventListener('abort', () => {
+        const error = new Error('The operation was aborted');
+        error.name = 'AbortError';
+        reject(error);
+      });
+    });
+    mockFetch.returns(fetchPromise);
+
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'streamTest');
+    const streamPromise = func.stream({}, { signal: controller.signal });
+
+    controller.abort();
+
+    const streamResult = await streamPromise;
+
+    // Verify fetch was called with abort signal
+    expect(mockFetch.calledOnce).to.be.true;
+    const [_, options] = mockFetch.firstCall.args;
+    expect(options.signal).to.equal(controller.signal);
+
+    // Verify stream iteration throws AbortError
+    let errorThrown = false;
+    try {
+      for await (const _ of streamResult.stream) {
+        // Should not execute
+      }
+    } catch (error) {
+      errorThrown = true;
+      expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
+    }
+    expect(errorThrown).to.be.true;
+    expectError(streamResult.data, "cancelled", "Request was cancelled")
+  });
+
+  it('aborts during streaming', async () => {
+    const controller = new AbortController();
+
+    const mockResponse = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(new TextEncoder().encode('data: {"message":"First"}\n'));
+        // Add delay to simulate network latency
+        await new Promise(resolve => setTimeout(resolve, 50));
+        controller.enqueue(new TextEncoder().encode('data: {"message":"Second"}\n'));
+        await new Promise(resolve => setTimeout(resolve, 50));
+        controller.enqueue(new TextEncoder().encode('data: {"result":"Final"}\n'));
+        controller.close();
+      }
+    });
+
+    mockFetch.resolves({
+      body: mockResponse,
+      headers: new Headers({ 'Content-Type': 'text/event-stream' }),
+      status: 200,
+      statusText: 'OK',
+    } as Response);
+
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'streamTest');
+    const streamResult = await func.stream({}, { signal: controller.signal });
+
+    const messages: string[] = [];
+    try {
+      for await (const message of streamResult.stream) {
+        messages.push(message);
+        if (messages.length === 1) {
+          // Abort after receiving first message
+          controller.abort();
+        }
+      }
+      throw new Error('Stream should have been aborted');
+    } catch (error) {
+      expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
+    }
+    expect(messages).to.deep.equal(['First']);
+    expectError(streamResult.data, "cancelled", "Request was cancelled")
+  });
+
+  it('fails immediately with pre-aborted signal', async () => {
+    mockFetch.callsFake((url: string, options: RequestInit) => {
+      if (options.signal?.aborted) {
+        const error = new Error('The operation was aborted');
+        error.name = 'AbortError';
+        return Promise.reject(error);
+      }
+      return Promise.resolve(new Response());
+    });
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'streamTest');
+    const streamResult = await func.stream({}, { signal: AbortSignal.abort() });
+
+    let errorThrown = false;
+    try {
+      for await (const _ of streamResult.stream) {
+        // Should not execute
+      }
+    } catch (error) {
+      errorThrown = true;
+      expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
+    }
+    expect(errorThrown).to.be.true;
+    expectError(streamResult.data, "cancelled", "Request was cancelled")
+  });
+
+  it('properly handles AbortSignal.timeout()', async () => {
+    const timeoutMs = 50;
+    const signal = AbortSignal.timeout(timeoutMs);
+
+    mockFetch.callsFake(async (url: string, options: RequestInit) => {
+      await new Promise((resolve, reject) => {
+        options.signal?.addEventListener('abort', () => {
+          const error = new Error('The operation was aborted');
+          error.name = 'AbortError';
+          reject(error);
+        });
+        setTimeout(resolve, timeoutMs * 3);
+      });
+
+      // If we get here, timeout didn't occur
+      return new Response();
+    });
+
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'streamTest');
+    const streamResult = await func.stream({}, { signal });
+
+    try {
+      for await (const message of streamResult.stream) {
+        // Should not execute
+      }
+      throw new Error('Stream should have timed out');
+    } catch (error) {
+      expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
+    }
+    expectError(streamResult.data, "cancelled", "Request was cancelled")
   });
 });

packages/functions/src/public-types.ts

@@ -43,7 +43,7 @@ export interface HttpsCallableStreamResult<ResponseData = unknown, StreamData =
  */
 export type HttpsCallable<RequestData = unknown, ResponseData = unknown, StreamData = unknown> = {
   (data?: RequestData | null): Promise<HttpsCallableResult<ResponseData>>;
-  stream: (data?: RequestData | null) => Promise<HttpsCallableStreamResult<ResponseData, StreamData>>;
+  stream: (data?: RequestData | null, options?: HttpsCallableStreamOptions) => Promise<HttpsCallableStreamResult<ResponseData, StreamData>>;
 };
 
 /**

packages/functions/src/service.ts

@@ -285,7 +285,6 @@ async function callAtURL(
   data: unknown,
   options: HttpsCallableOptions
 ): Promise<HttpsCallableResult> {
-  console.log(url);
   // Encode any special types, such as dates, in the input data.
   data = encode(data);
   const body = { data };