add auth,database tests

Author: Ehesp

integration_test/functions/package-lock.json

@@ -15,6 +15,7 @@
   "main": "lib/index.js",
   "dependencies": {
     "@google-cloud/pubsub": "^5.2.0",
+    "firebase": "^12.6.0",
     "firebase-admin": "^12.6.0",
     "firebase-functions": "file:firebase-functions-local.tgz"
   },

integration_test/functions/package.json

@@ -0,0 +1,33 @@
+import { expect, assertType } from "vitest";
+
+export * from "./index";
+
+export function expectAuthBlockingEvent(data: any, userId: string) {
+  // expect(data.auth).toBeDefined(); // TOOD: Not provided?
+  expect(data.authType).toBeDefined();
+  assertType<string>(data.authType);
+  expect(data.eventId).toBeDefined();
+  assertType<string>(data.eventId);
+  expect(data.eventType).toBeDefined();
+  assertType<string>(data.eventType);
+  expect(data.timestamp).toBeDefined();
+  assertType<string>(data.timestamp);
+  expect(Date.parse(data.timestamp)).toBeGreaterThan(0);
+
+  expect(data.locale).toBeDefined();
+  expect(data.ipAddress).toBeDefined();
+  assertType<string>(data.ipAddress);
+  expect(data.ipAddress.length).toBeGreaterThan(0);
+  expect(data.userAgent).toBeDefined();
+  assertType<string>(data.userAgent);
+  expect(data.userAgent.length).toBeGreaterThan(0);
+
+  expect(data.additionalUserInfo).toBeDefined();
+  expect(data.additionalUserInfo.isNewUser).toBe(true);
+  expect(data.additionalUserInfo.providerId).toBe("password");
+
+  // TODO: data.credential is null
+
+  expect(data.data).toBeDefined();
+  expect(data.data.uid).toBe(userId);
+}

integration_test/functions/src/assertions.ts

@@ -0,0 +1,37 @@
+import { expect, assertType } from "vitest";
+import { RUN_ID } from "../utils";
+
+export * from "./index";
+
+export function expectDatabaseEvent(data: any, eventName: string, refPath: string) {
+  expect(data.location).toBeDefined();
+  assertType<string>(data.location);
+  expect(data.location.length).toBeGreaterThan(0);
+  expect(data.firebaseDatabaseHost).toBeDefined();
+  assertType<string>(data.firebaseDatabaseHost);
+  expect(data.firebaseDatabaseHost.length).toBeGreaterThan(0);
+  expect(data.instance).toBeDefined();
+  assertType<string>(data.instance);
+  expect(data.instance.length).toBeGreaterThan(0);
+  expect(data.ref).toBeDefined();
+  assertType<string>(data.ref);
+  expect(data.ref).toBe(refPath);
+  expect(data.params).toBeDefined();
+  expect(data.params.runId).toBe(RUN_ID);
+}
+
+export function expectDataSnapshot(snapshot: any, refPath: string) {
+  expect(snapshot.ref).toBeDefined();
+  expect(snapshot.ref.__type).toBe("reference");
+  expect(snapshot.ref.key).toBeDefined();
+  expect(snapshot.key).toBeDefined();
+  expect(snapshot.exists).toBe(true);
+  expect(snapshot.hasChildren).toBeDefined();
+  expect(typeof snapshot.hasChildren).toBe("boolean");
+  expect(snapshot.hasChild).toBeDefined();
+  expect(typeof snapshot.hasChild).toBe("boolean");
+  expect(snapshot.numChildren).toBeDefined();
+  expect(typeof snapshot.numChildren).toBe("number");
+  expect(snapshot.json).toBeDefined();
+  expect(typeof snapshot.json).toBe("object");
+}

integration_test/functions/src/assertions/auth.ts

@@ -0,0 +1,63 @@
+import { expect, assertType } from "vitest";
+import { RUN_ID } from "../utils";
+
+export * from "./index";
+
+export function expectFirestoreAuthEvent(data: any, collection: string, document: string) {
+  expect(data.authId).toBeDefined();
+  assertType<string>(data.authId);
+  expect(data.authId.length).toBeGreaterThan(0);
+  expect(data.authType).toBeDefined();
+  assertType<string>(data.authType);
+  expect(data.authType.length).toBeGreaterThan(0);
+  expectFirestoreEvent(data, collection, document);
+}
+
+export function expectFirestoreEvent(data: any, collection: string, document: string) {
+  expect(data.location).toBeDefined();
+  assertType<string>(data.location);
+  expect(data.location.length).toBeGreaterThan(0);
+  expect(data.project).toBeDefined();
+  assertType<string>(data.project);
+  expect(data.project.length).toBeGreaterThan(0);
+  expect(data.database).toBeDefined();
+  assertType<string>(data.database);
+  expect(data.database.length).toBeGreaterThan(0);
+  expect(data.namespace).toBeDefined();
+  assertType<string>(data.namespace);
+  expect(data.namespace.length).toBeGreaterThan(0);
+  expect(data.document).toBeDefined();
+  assertType<string>(data.document);
+  expect(data.document.length).toBeGreaterThan(0);
+  expect(data.document).toBe(`integration_test/${RUN_ID}/${collection}/${document}`);
+  expect(data.params).toBeDefined();
+  expect(data.params.runId).toBe(RUN_ID);
+  expect(data.params.documentId).toBe(document);
+}
+
+export function expectQueryDocumentSnapshot(snapshot: any, collection: string, document: string) {
+  expect(snapshot.exists).toBe(true);
+  expect(snapshot.id).toBe(document);
+  expectDocumentReference(snapshot.ref, collection, document);
+  expectTimestamp(snapshot.createTime);
+  expectTimestamp(snapshot.updateTime);
+}
+
+export function expectDocumentReference(reference: any, collection: string, document: string) {
+  expect(reference._type).toBe("reference");
+  expect(reference.id).toBe(document);
+  expect(reference.path).toBe(`integration_test/${RUN_ID}/${collection}/${document}`);
+}
+
+export function expectTimestamp(timestamp: any) {
+  expect(timestamp._type).toBe("timestamp");
+  expect(Date.parse(timestamp.iso)).toBeGreaterThan(0);
+  expect(Number(timestamp.seconds)).toBeGreaterThan(0);
+  expect(Number(timestamp.nanoseconds)).toBeGreaterThan(0);
+}
+
+export function expectGeoPoint(geoPoint: any) {
+  expect(geoPoint._type).toBe("geopoint");
+  expect(Number(geoPoint.latitude)).toBeGreaterThan(0);
+  expect(Number(geoPoint.longitude)).toBeGreaterThan(0);
+}

integration_test/functions/src/assertions/database.ts

@@ -0,0 +1,22 @@
+import { expect, assertType } from "vitest";
+
+export function expectCloudEvent(data: any) {
+  expect(data.specversion).toBe("1.0");
+  expect(data.id).toBeDefined();
+  assertType<string>(data.id);
+  expect(data.id.length).toBeGreaterThan(0);
+  expect(data.source).toBeDefined();
+  assertType<string>(data.source);
+  expect(data.source.length).toBeGreaterThan(0);
+  expect(data.subject).toBeDefined();
+  assertType<string>(data.subject);
+  expect(data.subject.length).toBeGreaterThan(0);
+  expect(data.type).toBeDefined();
+  assertType<string>(data.type);
+  expect(data.type.length).toBeGreaterThan(0);
+  expect(data.time).toBeDefined();
+  assertType<string>(data.time);
+  expect(data.time.length).toBeGreaterThan(0);
+  // iso string to unix - will be NaN if not a valid date
+  expect(Date.parse(data.time)).toBeGreaterThan(0);
+}

integration_test/functions/src/assertions/firestore.ts

@@ -0,0 +1,87 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { createUserWithEmailAndPassword, signInWithEmailAndPassword, signOut } from "firebase/auth";
+import { auth, waitForEvent } from "./utils";
+import { expectAuthBlockingEvent } from "./assertions/auth";
+import { auth as authClient } from "./client";
+
+describe("auth.v2", () => {
+  describe("beforeUserCreated", () => {
+    let data: any;
+    let userId: string;
+    let email: string;
+
+    beforeAll(async () => {
+      data = await waitForEvent("beforeUserCreated", async () => {
+        email = `test-${Date.now()}@example.com`;
+        const password = "testPassword123!";
+        userId = await createUserWithEmailAndPassword(authClient, email, password).then(
+          (credential) => credential.user.uid
+        );
+      });
+    }, 60_000);
+
+    afterAll(async () => {
+      // Clean up: delete the test user
+      if (userId) {
+        try {
+          await auth.deleteUser(userId);
+        } catch (error) {
+          // Ignore errors if user was already deleted
+        }
+      }
+
+      await signOut(authClient);
+    });
+
+    it("should be an AuthBlockingEvent", () => {
+      expectAuthBlockingEvent(data, userId);
+    });
+
+    it("should have the correct event type", () => {
+      expect(data.eventType).toBe("providers/cloud.auth/eventTypes/user.beforeCreate:password");
+    });
+  });
+
+  describe("beforeUserSignedIn", () => {
+    let data: any;
+    let userId: string;
+    let email: string;
+    let password: string;
+
+    beforeAll(async () => {
+      // First create a user via REST API
+      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);
+      });
+    }, 60_000);
+
+    afterAll(async () => {
+      // Clean up: delete the test user
+      if (userId) {
+        try {
+          await auth.deleteUser(userId);
+        } catch (error) {
+          // Ignore errors if user was already deleted
+        }
+      }
+
+      await signOut(authClient);
+    });
+
+    it("should be an AuthBlockingEvent", () => {
+      expectAuthBlockingEvent(data, userId);
+    });
+
+    it("should have the correct event type", () => {
+      expect(data.eventType).toBe("providers/cloud.auth/eventTypes/user.beforeSignIn:password");
+    });
+  });
+});

integration_test/functions/src/assertions/index.ts

@@ -0,0 +1,11 @@
+import { beforeUserCreated, beforeUserSignedIn } from "firebase-functions/v2/identity";
+import { sendEvent } from "./utils";
+import { serializeAuthBlockingEvent } from "./serializers/auth";
+
+export const authBeforeUserCreatedTrigger = beforeUserCreated(async (event) => {
+  await sendEvent("beforeUserCreated", serializeAuthBlockingEvent(event));
+});
+
+export const authBeforeUserSignedInTrigger = beforeUserSignedIn(async (event) => {
+  await sendEvent("beforeUserSignedIn", serializeAuthBlockingEvent(event));
+});

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

@@ -0,0 +1,14 @@
+import { initializeApp } from "firebase/app";
+import { getAuth } from "firebase/auth";
+
+export const app = initializeApp({
+  apiKey: "AIzaSyBBt77mpu6TV0IA2tcNSyf4OltsVu_Z1Zw",
+  authDomain: "cf3-integration-tests-v2-qa.firebaseapp.com",
+  databaseURL: "https://cf3-integration-tests-v2-qa-default-rtdb.firebaseio.com",
+  projectId: "cf3-integration-tests-v2-qa",
+  storageBucket: "cf3-integration-tests-v2-qa.firebasestorage.app",
+  messagingSenderId: "576826020291",
+  appId: "1:576826020291:web:488d568c5d4109df12ed76",
+});
+
+export const auth = getAuth(app);