fix(functions): correct httpsCallable timeout units on macOS/web

Author: mikehardy

packages/functions/__tests__/httpsCallable-timeout-native.test.ts

@@ -0,0 +1,62 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+jest.mock('@react-native-firebase/app/dist/module/common', () => {
+  const actualCommon = jest.requireActual(
+    '@react-native-firebase/app/dist/module/common',
+  ) as Record<string, unknown>;
+  return {
+    ...actualCommon,
+    isOther: false,
+    isAndroid: true,
+  };
+});
+
+import { firebase } from '../lib';
+
+function timeoutFromNativeCall(nativeMock: jest.Mock): number {
+  const call = nativeMock.mock.calls[0] as unknown[] | undefined;
+  expect(call).toBeDefined();
+  const options = call?.[4] as { timeout?: number } | undefined;
+  expect(options?.timeout).toBeDefined();
+  return options?.timeout as number;
+}
+
+describe('httpsCallable timeout units on native platforms', function () {
+  let httpsCallableNative: jest.Mock;
+
+  beforeAll(function () {
+    // @ts-ignore test-only global
+    globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
+  });
+
+  afterAll(function () {
+    // @ts-ignore test-only global
+    globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = false;
+  });
+
+  beforeEach(function () {
+    httpsCallableNative = jest
+      .fn<(...args: unknown[]) => Promise<{ data: null }>>()
+      .mockResolvedValue({ data: null });
+
+    const functions = firebase.app().functions();
+    // @ts-ignore test-only internal cache
+    functions._nativeModule = {
+      httpsCallable: (
+        _host: unknown,
+        _port: unknown,
+        _name: unknown,
+        _wrapper: unknown,
+        options: { timeout?: number },
+      ) => httpsCallableNative(_host, _port, _name, _wrapper, options),
+    };
+  });
+
+  it('converts milliseconds to seconds for httpsCallable (Android/iOS)', async function () {
+    const runner = firebase.app().functions().httpsCallable('example', { timeout: 30000 });
+    await runner();
+
+    expect(httpsCallableNative).toHaveBeenCalledTimes(1);
+    expect(timeoutFromNativeCall(httpsCallableNative)).toBe(30);
+  });
+});

packages/functions/__tests__/httpsCallable-timeout-other.test.ts

@@ -0,0 +1,62 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+jest.mock('@react-native-firebase/app/dist/module/common', () => {
+  const actualCommon = jest.requireActual(
+    '@react-native-firebase/app/dist/module/common',
+  ) as Record<string, unknown>;
+  return {
+    ...actualCommon,
+    isOther: true,
+    isAndroid: false,
+  };
+});
+
+import { firebase } from '../lib';
+
+function timeoutFromNativeCall(nativeMock: jest.Mock): number {
+  const call = nativeMock.mock.calls[0] as unknown[] | undefined;
+  expect(call).toBeDefined();
+  const options = call?.[4] as { timeout?: number } | undefined;
+  expect(options?.timeout).toBeDefined();
+  return options?.timeout as number;
+}
+
+describe('httpsCallable timeout units on other platforms', function () {
+  let httpsCallableNative: jest.Mock;
+
+  beforeAll(function () {
+    // @ts-ignore test-only global
+    globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
+  });
+
+  afterAll(function () {
+    // @ts-ignore test-only global
+    globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = false;
+  });
+
+  beforeEach(function () {
+    httpsCallableNative = jest
+      .fn<(...args: unknown[]) => Promise<{ data: null }>>()
+      .mockResolvedValue({ data: null });
+
+    const functions = firebase.app().functions();
+    // @ts-ignore test-only internal cache
+    functions._nativeModule = {
+      httpsCallable: (
+        _host: unknown,
+        _port: unknown,
+        _name: unknown,
+        _wrapper: unknown,
+        options: { timeout?: number },
+      ) => httpsCallableNative(_host, _port, _name, _wrapper, options),
+    };
+  });
+
+  it('keeps milliseconds for httpsCallable (web/macos)', async function () {
+    const runner = firebase.app().functions().httpsCallable('example', { timeout: 30000 });
+    await runner();
+
+    expect(httpsCallableNative).toHaveBeenCalledTimes(1);
+    expect(timeoutFromNativeCall(httpsCallableNative)).toBe(30000);
+  });
+});

packages/functions/e2e/functions.e2e.js

@@ -511,6 +511,18 @@ describe('functions() modular', function () {
         const response = await httpsCallable(functions, fnName)();
         response.data.should.equal('Hello from Firebase!');
       });
+
+      it('HttpsCallableOptions.timeout honors millisecond values on web/macos', async function () {
+        if (!Platform.other) {
+          return this.skip();
+        }
+        const { getApp } = modular;
+        const { getFunctions, httpsCallable, connectFunctionsEmulator } = functionsModular;
+        const functions = getFunctions(getApp(), 'us-central1');
+        connectFunctionsEmulator(functions, 'localhost', 5001);
+        const response = await httpsCallable(functions, 'helloWorldV2', { timeout: 10000 })();
+        response.data.should.equal('Hello from Firebase!');
+      });
     });
 
     describe('httpsCallableFromUrl()', function () {

packages/functions/lib/namespaced.ts

@@ -280,7 +280,10 @@ class FirebaseFunctionsModule extends FirebaseModule {
   httpsCallable(name: string, options: HttpsCallableOptions = {}) {
     if (options.timeout) {
       if (isNumber(options.timeout)) {
-        options.timeout = options.timeout / 1000;
+        // Native Android/iOS expect seconds; Firebase JS (web/macos) expects milliseconds.
+        if (!isOther) {
+          options.timeout = options.timeout / 1000;
+        }
       } else {
         throw new Error('HttpsCallableOptions.timeout expected a Number in milliseconds');
       }
@@ -337,7 +340,9 @@ class FirebaseFunctionsModule extends FirebaseModule {
   httpsCallableFromUrl(url: string, options: HttpsCallableOptions = {}) {
     if (options.timeout) {
       if (isNumber(options.timeout)) {
-        options.timeout = options.timeout / 1000;
+        if (!isOther) {
+          options.timeout = options.timeout / 1000;
+        }
       } else {
         throw new Error('HttpsCallableOptions.timeout expected a Number in milliseconds');
       }