add v1 tests

Author: Ehesp

integration_test/functions/src/assertions/index.ts

@@ -1,3 +1,4 @@
+import { Resource } from "firebase-functions/v1";
 import { expect, assertType } from "vitest";
 
 export function expectCloudEvent(data: any) {
@@ -24,4 +25,23 @@ export function expectCloudEvent(data: any) {
   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);
+}
+
+export function expectEventContext(data: any) {
+  expect(data.eventId).toBeDefined();
+  assertType<string>(data.eventId);
+  expect(data.eventId.length).toBeGreaterThan(0);
+  expect(data.eventType).toBeDefined();
+  assertType<string>(data.eventType);
+  expect(data.eventType.length).toBeGreaterThan(0);
+  expect(data.resource).toBeDefined();
+  assertType<Resource>(data.resource);
+  expect(data.resource.service).toBeDefined();
+  expect(data.resource.name).toBeDefined();
+  expect(data.timestamp).toBeDefined();
+  assertType<string>(data.timestamp);
+  expect(data.timestamp.length).toBeGreaterThan(0);
+  expect(Date.parse(data.timestamp)).toBeGreaterThan(0);
+  expect(data.params).toBeDefined();
+  assertType<Record<string, string>>(data.params);
 }

integration_test/functions/src/index.ts

@@ -1,3 +1,11 @@
+export * from "./v1/database.v1";
+export * from "./v1/firestore.v1";
+export * from "./v1/https.v1";
+export * from "./v1/remoteConfig.v1";
+export * from "./v1/pubsub.v1";
+export * from "./v1/storage.v1";
+export * from "./v1/tasks.v1";
+
 export * from "./v2/database.v2";
 export * from "./v2/eventarc.v2";
 export * from "./v2/firestore.v2";

integration_test/functions/src/remoteConfig.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, beforeAll, expect } from "vitest";
+import { RUN_ID, waitForEvent } from "./utils";
+import { expectEventContext, expectCloudEvent } from "./assertions";
+import { remoteConfig } from "./firebase.server";
+
+describe("remoteConfig", () => {
+  describe("onConfigUpdated", () => {
+    let v1Data: any;
+    let v2Data: any;
+
+    beforeAll(async () => {
+      // Create a shared trigger that only executes once
+      let triggerPromise: Promise<void> | null = null;
+      const getTrigger = () => {
+        if (!triggerPromise) {
+          triggerPromise = (async () => {
+            const template = await remoteConfig.getTemplate();
+            template.version.description = RUN_ID;
+            await remoteConfig.validateTemplate(template);
+            await remoteConfig.publishTemplate(template);
+          })();
+        }
+        return triggerPromise;
+      };
+
+      // Wait for both events in parallel, sharing the same trigger
+      [v1Data, v2Data] = await Promise.all([
+        waitForEvent("onConfigUpdatedV1", getTrigger),
+        waitForEvent("onConfigUpdated", getTrigger),
+      ]);
+    }, 60_000);
+
+    describe("v1", () => {
+      it("should have EventContext", () => {
+        expectEventContext(v1Data);
+      });
+
+      it("should have the correct data", () => {
+        expect(v1Data.update.versionNumber).toBeDefined();
+        expect(v1Data.update.updateTime).toBeDefined();
+        expect(v1Data.update.updateUser).toBeDefined();
+        expect(v1Data.update.description).toBeDefined();
+        expect(v1Data.update.description).toBe(RUN_ID);
+        expect(v1Data.update.updateOrigin).toBeDefined();
+        expect(v1Data.update.updateOrigin).toBe("ADMIN_SDK_NODE");
+        expect(v1Data.update.updateType).toBeDefined();
+        expect(v1Data.update.updateType).toBe("INCREMENTAL_UPDATE");
+        // rollback source optional in v1
+      });
+    });
+
+    describe("v2", () => {
+      it("should be a CloudEvent", () => {
+        expectCloudEvent(v2Data);
+      });
+
+      it("should have the correct data", () => {
+        expect(v2Data.update.versionNumber).toBeDefined();
+        expect(v2Data.update.updateTime).toBeDefined();
+        expect(v2Data.update.updateUser).toBeDefined();
+        expect(v2Data.update.description).toBeDefined();
+        expect(v2Data.update.description).toBe(RUN_ID);
+        expect(v2Data.update.updateOrigin).toBeDefined();
+        expect(v2Data.update.updateOrigin).toBe("ADMIN_SDK_NODE");
+        expect(v2Data.update.updateType).toBeDefined();
+        expect(v2Data.update.updateType).toBe("INCREMENTAL_UPDATE");
+        expect(v2Data.update.rollbackSource).toBeDefined();
+      });
+    });
+  });
+});
+

integration_test/functions/src/serializers/index.ts

@@ -1,4 +1,5 @@
 import { CloudEvent } from "firebase-functions";
+import { EventContext } from "firebase-functions/v1";
 
 export function serializeCloudEvent(event: CloudEvent<unknown>): any {
   return {
@@ -9,4 +10,17 @@ export function serializeCloudEvent(event: CloudEvent<unknown>): any {
     type: event.type,
     time: event.time,
   };
+}
+
+// v1
+export function serializeEventContext(ctx: EventContext): any {
+  return {
+    auth: ctx.auth,
+    authType: ctx.authType,
+    eventId: ctx.eventId,
+    eventType: ctx.eventType,
+    params: ctx.params,
+    resource: ctx.resource,
+    timestamp: ctx.timestamp,
+  };
 }

integration_test/functions/src/serializers/storage.ts

@@ -38,3 +38,4 @@ function serializeStorageObjectData(data: StorageObjectData): any {
     updated: data.updated,
   };
 }
+

integration_test/functions/src/storage.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, beforeAll, expect, afterAll } from "vitest";
+import { RUN_ID, waitForEvent } from "./utils";
+import { storage } from "./firebase.server";
+import { config } from "./config";
+import { expectStorageObjectData } from "./assertions/storage";
+import { expectEventContext, expectCloudEvent } from "./assertions";
+
+const bucket = storage.bucket(config.storageBucket);
+const filename = `dummy-file-${RUN_ID}.txt`;
+
+async function createDummyFile() {
+  const buffer = Buffer.from("Hello, world!");
+  const file = bucket.file(filename);
+  await file.save(buffer);
+  const [metadata] = await file.getMetadata();
+  return metadata;
+}
+
+describe("storage", () => {
+  let createdFile: Awaited<ReturnType<typeof createDummyFile>>;
+  let v1UploadedData: any;
+  let v2UploadedData: any;
+  let v1MetadataData: any;
+  let v2MetadataData: any;
+  let v1DeletedData: any;
+  let v2DeletedData: any;
+
+  // Since storage triggers are bucket wide, we perform all events at the top-level
+  // in a specific order, then assert the values at the end.
+  beforeAll(async () => {
+    // Create file - triggers both v1 and v2 onObjectFinalized
+    let createFilePromise: Promise<void> | null = null;
+    const getCreateFileTrigger = () => {
+      if (!createFilePromise) {
+        createFilePromise = (async () => {
+          createdFile = await createDummyFile();
+        })();
+      }
+      return createFilePromise;
+    };
+
+    [v1UploadedData, v2UploadedData] = await Promise.all([
+      waitForEvent("onObjectFinalizedV1", getCreateFileTrigger),
+      waitForEvent("onObjectFinalized", getCreateFileTrigger),
+    ]);
+
+    // Update metadata - triggers both v1 and v2 onObjectMetadataUpdated
+    let updateMetadataPromise: Promise<void> | null = null;
+    const getUpdateMetadataTrigger = () => {
+      if (!updateMetadataPromise) {
+        updateMetadataPromise = (async () => {
+          await bucket.file(createdFile.name).setMetadata({
+            runId: RUN_ID,
+          });
+        })();
+      }
+      return updateMetadataPromise;
+    };
+
+    [v1MetadataData, v2MetadataData] = await Promise.all([
+      waitForEvent("onObjectMetadataUpdatedV1", getUpdateMetadataTrigger),
+      waitForEvent("onObjectMetadataUpdated", getUpdateMetadataTrigger),
+    ]);
+
+    // Delete file - triggers both v1 and v2 onObjectDeleted
+    let deleteFilePromise: Promise<void> | null = null;
+    const getDeleteFileTrigger = () => {
+      if (!deleteFilePromise) {
+        deleteFilePromise = (async () => {
+          await bucket.file(createdFile.name).delete();
+        })();
+      }
+      return deleteFilePromise;
+    };
+
+    [v1DeletedData, v2DeletedData] = await Promise.all([
+      waitForEvent("onObjectDeletedV1", getDeleteFileTrigger),
+      waitForEvent("onObjectDeleted", getDeleteFileTrigger),
+    ]);
+  }, 60_000);
+
+  afterAll(async () => {
+    // Just in case the file wasn't deleted by the trigger if it failed.
+    await bucket.file(createdFile.name).delete({
+      ignoreNotFound: true,
+    });
+  });
+
+  describe("onObjectDeleted", () => {
+    describe("v1", () => {
+      it("should have event context", () => {
+        expectEventContext(v1DeletedData);
+      });
+
+      it("should have the correct data", () => {
+        expect(v1DeletedData.object.bucket).toBe(config.storageBucket);
+        // Use the actual filename from the object data
+        const actualFilename = v1DeletedData.object.name || filename;
+        expectStorageObjectData(v1DeletedData.object, actualFilename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should contain a timeDeleted timestamp', () => {
+        expect(v1DeletedData.object.timeDeleted).toBeDefined();
+        expect(Date.parse(v1DeletedData.object.timeDeleted)).toBeGreaterThan(0);
+      });
+    });
+
+    describe("v2", () => {
+      it("should be a CloudEvent", () => {
+        expectCloudEvent(v2DeletedData);
+      });
+
+      it("should have the correct data", () => {
+        expect(v2DeletedData.bucket).toBe(config.storageBucket);
+        expectStorageObjectData(v2DeletedData.object, filename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should contain a timeDeleted timestamp', () => {
+        expect(v2DeletedData.object.timeDeleted).toBeDefined();
+        expect(Date.parse(v2DeletedData.object.timeDeleted)).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe("onObjectMetadataUpdated", () => {
+    describe("v1", () => {
+      it("should have event context", () => {
+        // Note: onObjectMetadataUpdated may not always have event context in v1
+        if (v1MetadataData.eventId !== undefined) {
+          expect(v1MetadataData.eventId).toBeDefined();
+          expect(v1MetadataData.eventType).toBeDefined();
+          expect(v1MetadataData.timestamp).toBeDefined();
+          expect(v1MetadataData.resource).toBeDefined();
+        }
+      });
+
+      it("should have the correct data", () => {
+        expect(v1MetadataData.object.bucket).toBe(config.storageBucket);
+        // Use the actual filename from the object data
+        const actualFilename = v1MetadataData.object.name || filename;
+        expectStorageObjectData(v1MetadataData.object, actualFilename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should have metadata', () => {
+        expect(v1MetadataData.object.metadata).toBeDefined();
+        expect(v1MetadataData.object.metadata.runId).toBe(RUN_ID);
+      });
+    });
+
+    describe("v2", () => {
+      it("should be a CloudEvent", () => {
+        expectCloudEvent(v2MetadataData);
+      });
+
+      it("should have the correct data", () => {
+        expect(v2MetadataData.bucket).toBe(config.storageBucket);
+        expectStorageObjectData(v2MetadataData.object, filename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should have metadata', () => {
+        expect(v2MetadataData.metadata).toBeDefined();
+        expect(v2MetadataData.metadata.runId).toBe(RUN_ID);
+      });
+    });
+  });
+
+  describe("onObjectFinalized", () => {
+    describe("v1", () => {
+      it("should have event context", () => {
+        expect(v1UploadedData.eventId).toBeDefined();
+        expect(v1UploadedData.eventType).toBeDefined();
+        expect(v1UploadedData.timestamp).toBeDefined();
+        expect(v1UploadedData.resource).toBeDefined();
+      });
+
+      it("should have the correct data", () => {
+        expect(v1UploadedData.object.bucket).toBe(config.storageBucket);
+        // Use the actual filename from the object data
+        const actualFilename = v1UploadedData.object.name || filename;
+        expectStorageObjectData(v1UploadedData.object, actualFilename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should not have initial metadata', () => {
+        expect(v1UploadedData.object.metadata).toBeDefined();
+        expect(v1UploadedData.object.metadata.runId).not.toBeUndefined();
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should contain a timeCreated timestamp', () => {
+        expect(v1UploadedData.object.timeCreated).toBeDefined();
+        expect(Date.parse(v1UploadedData.object.timeCreated)).toBeGreaterThan(0);
+      });
+    });
+
+    describe("v2", () => {
+      it("should be a CloudEvent", () => {
+        expectCloudEvent(v2UploadedData);
+      });
+
+      it("should have the correct data", () => {
+        expect(v2UploadedData.bucket).toBe(config.storageBucket);
+        expectStorageObjectData(v2UploadedData.object, filename);
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should not have initial metadata', () => {
+        expect(v2UploadedData.object.metadata).toBeDefined();
+        expect(v2UploadedData.object.metadata.runId).not.toBeUndefined();
+      });
+
+      // TODO: Doesn't seem to be sent by Google Cloud?
+      it.skip('should contain a timeCreated timestamp', () => {
+        expect(v2UploadedData.object.timeCreated).toBeDefined();
+        expect(Date.parse(v2UploadedData.object.timeCreated)).toBeGreaterThan(0);
+      });
+    });
+  });
+});
+