fix auth,https tests

Author: Ehesp

integration_test/functions/package-lock.json

@@ -17,7 +17,8 @@
     "@google-cloud/pubsub": "^5.2.0",
     "firebase": "^12.6.0",
     "firebase-admin": "^12.6.0",
-    "firebase-functions": "file:firebase-functions-local.tgz"
+    "firebase-functions": "file:firebase-functions-local.tgz",
+    "undici": "^7.16.0"
   },
   "devDependencies": {
     "firebase-functions-test": "^3.1.0",

integration_test/functions/package.json

@@ -23,7 +23,7 @@ export function expectAuthBlockingEvent(data: any, userId: string) {
   expect(data.userAgent.length).toBeGreaterThan(0);
 
   expect(data.additionalUserInfo).toBeDefined();
-  expect(data.additionalUserInfo.isNewUser).toBe(true);
+  assertType<boolean>(data.additionalUserInfo.isNewUser);
   expect(data.additionalUserInfo.providerId).toBe("password");
 
   // TODO: data.credential is null

integration_test/functions/src/assertions/auth.ts

@@ -49,15 +49,13 @@ describe("auth.v2", () => {
     let password: string;
 
     beforeAll(async () => {
-      // First create a user via REST API
+      // First create a user (required before sign-in)
       email = `signin-${Date.now()}@example.com`;
       password = "testPassword123!";
       userId = await createUserWithEmailAndPassword(authClient, email, password).then(
         (credential) => credential.user.uid
       );
 
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-
       data = await waitForEvent("beforeUserSignedIn", async () => {
         await signInWithEmailAndPassword(authClient, email, password);
       });

integration_test/functions/src/auth.v2.test.ts

@@ -1,5 +1,6 @@
 import { initializeApp } from "firebase/app";
 import { getAuth } from "firebase/auth";
+import { getFunctions } from "firebase/functions";
 
 export const app = initializeApp({
   apiKey: "AIzaSyBBt77mpu6TV0IA2tcNSyf4OltsVu_Z1Zw",
@@ -12,3 +13,4 @@ export const app = initializeApp({
 });
 
 export const auth = getAuth(app);
+export const functions = getFunctions(app);

integration_test/functions/src/client.ts

@@ -0,0 +1,84 @@
+import { describe, it, beforeAll, expect } from "vitest";
+import { fetch } from "undici";
+import { waitForEvent } from "./utils";
+import { httpsCallable } from "firebase/functions";
+import { functions } from "./client";
+
+describe("https.v2", () => {
+  describe("httpsOnCallTrigger", () => {
+    let data: any;
+    let callData: any;
+    let streamData: any[] = [];
+
+    beforeAll(async () => {
+      data = await waitForEvent("httpsOnCall", async () => {
+        const callable = httpsCallable(functions, "httpsOnCallTrigger");
+
+        const { stream, data: result } = await callable.stream({
+          foo: "bar",
+        });
+
+        for await (const chunk of stream) {
+          streamData.push(chunk);
+        }
+
+        // Await the final result of the callable
+        callData = await result;
+      });
+    }, 60_000);
+
+    it("should accept the correct data", () => {
+      expect(data.acceptsStreaming).toBe(true);
+      expect(data.data).toEqual({ foo: "bar" });
+    });
+
+    it("should return the correct data", () => {
+      expect(callData).toBe("onCall");
+    });
+
+    it("should stream the correct data", () => {
+      expect(streamData).toEqual(["onCallStreamed"]);
+    });
+  });
+
+  describe("httpsOnRequestTrigger", () => {
+    let data: any;
+    let status: number;
+    let body: any;
+
+    beforeAll(async () => {
+      data = await waitForEvent("httpsOnRequest", async () => {
+        console.log("Fetching...");
+        const response = await fetch(
+          "https://us-central1-cf3-integration-tests-v2-qa.cloudfunctions.net/httpsOnRequestTrigger",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ foo: "bar" }),
+          }
+        );
+
+        console.log("Response:", response);
+
+        status = response.status;
+        console.log("Status:", status);
+        body = await response.text();
+        console.log("Body:", body);
+      });
+    }, 60_000);
+
+    it("should accept the correct data", () => {
+      expect(data).toEqual({ foo: "bar" });
+    });
+
+    it("should return the correct status", () => {
+      expect(status).toBe(201);
+    });
+
+    it("should return the correct body", () => {
+      expect(body).toBe("onRequest");
+    });
+  });
+});

integration_test/functions/src/https.v2.test.ts

@@ -0,0 +1,31 @@
+import { onCall, onRequest } from "firebase-functions/v2/https";
+import { sendEvent } from "./utils";
+
+export const httpsOnCallTrigger = onCall(
+  {
+    invoker: "public",
+  },
+  async (request, response) => {
+    await sendEvent("httpsOnCall", {
+      acceptsStreaming: request.acceptsStreaming,
+      data: request.data,
+    });
+
+    if (request.acceptsStreaming) {
+      response?.sendChunk("onCallStreamed");
+    }
+
+    return "onCall";
+  }
+);
+
+export const httpsOnRequestTrigger = onRequest(
+  {
+    invoker: "public",
+  },
+  async (req, res) => {
+    await sendEvent("httpsOnRequest", req.body);
+    res.status(201).send("onRequest");
+    return;
+  }
+);

integration_test/functions/src/https.v2.ts

@@ -1,4 +1,5 @@
 export * from "./firestore.v2";
 export * from "./database.v2";
 export * from "./eventarc.v2";
-export * from "./auth.v2";
+export * from "./auth.v2";
+export * from "./https.v2";

integration_test/functions/src/index.ts

@@ -25,24 +25,39 @@ export function waitForEvent<T = unknown>(
 ): Promise<T> {
   return new Promise<T>((resolve, reject) => {
     let timer: NodeJS.Timeout | null = null;
+    let triggerCompleted = false;
+    let snapshotData: T | null = null;
+    let unsubscribe: (() => void) | null = null;
+
+    const checkAndResolve = () => {
+      if (triggerCompleted && snapshotData !== null) {
+        if (timer) clearTimeout(timer);
+        if (unsubscribe) unsubscribe();
+        resolve(snapshotData);
+      }
+    };
 
-    const unsubscribe = firestore
+    unsubscribe = firestore
       .collection(RUN_ID)
       .doc(event)
       .onSnapshot((snapshot) => {
         if (snapshot.exists) {
-          if (timer) clearTimeout(timer);
-          unsubscribe();
-          resolve(snapshot.data() as T);
+          snapshotData = snapshot.data() as T;
+          checkAndResolve();
         }
       });
 
     timer = setTimeout(() => {
-      unsubscribe();
+      if (unsubscribe) unsubscribe();
       reject(new Error(`Timeout waiting for event "${event}" after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    trigger().then().catch(reject);
+    trigger()
+      .then(() => {
+        triggerCompleted = true;
+        checkAndResolve();
+      })
+      .catch(reject);
   });
 }