add storage tests

Author: Ehesp

integration_test/functions/src/assertions/storage.ts

@@ -0,0 +1,44 @@
+import { assertType, expect } from "vitest";
+import { config } from "../config";
+
+export function expectStorageObjectData(data: any, filename: string) {
+  expect(data.bucket).toBe(config.storageBucket);
+  expect(data.contentType).toBe("text/plain");
+  
+  expect(data.crc32c).toBeDefined();
+  assertType<string>(data.crc32c);
+  expect(data.crc32c.length).toBeGreaterThan(0);
+  
+  expect(data.md5Hash).toBeDefined();
+  assertType<string>(data.md5Hash);
+  expect(data.md5Hash.length).toBeGreaterThan(0);
+  
+  expect(data.etag).toBeDefined();
+  assertType<string>(data.etag);
+  expect(data.etag.length).toBeGreaterThan(0);
+
+  expect(Number.parseInt(data.generation)).toBeGreaterThan(0);
+
+  expect(data.id).toBeDefined();
+  assertType<string>(data.id);
+  expect(data.id).toContain(config.storageBucket);
+  expect(data.id).toContain(filename);
+
+  expect(data.kind).toBe("storage#object");
+
+  expect(data.mediaLink).toContain(`https://storage.googleapis.com/download/storage/v1/b/${config.storageBucket}/o/${filename}`);
+
+  expect(Number.parseInt(data.metageneration)).toBeGreaterThan(0);
+
+  expect(data.name).toBe(filename);
+
+  expect(data.selfLink).toBe(`https://www.googleapis.com/storage/v1/b/${config.storageBucket}/o/${filename}`);
+
+  expect(Number.parseInt(data.size)).toBeGreaterThan(0);
+
+  expect(data.storageClass).toBe("REGIONAL");
+
+  expect(Date.parse(data.timeCreated)).toBeGreaterThan(0);
+  expect(Date.parse(data.timeStorageClassUpdated)).toBeGreaterThan(0);
+  expect(Date.parse(data.updated)).toBeGreaterThan(0);
+}

integration_test/functions/src/firebase.server.ts

@@ -7,6 +7,7 @@ import { getAuth } from "firebase-admin/auth";
 import { getRemoteConfig } from "firebase-admin/remote-config";
 import { getFirestore } from "firebase-admin/firestore";
 import { config } from "./config";
+import { getStorage } from "firebase-admin/storage";
 
 export const app = admin.initializeApp({
   credential: applicationDefault(),
@@ -20,6 +21,7 @@ export const database = getDatabase(app);
 export const auth = getAuth(app);
 export const remoteConfig = getRemoteConfig(app);
 export const functions = getFunctions(app);
+export const storage = getStorage(app);
 
 // See https://github.com/firebase/functions-samples/blob/a6ae4cbd3cf2fff3e2b97538081140ad9befd5d8/Node/taskqueues-backup-images/functions/index.js#L111-L128
 export async function getFunctionUrl(name: string) {

integration_test/functions/src/index.ts

@@ -6,4 +6,5 @@ export * from "./v2/identity.v2";
 export * from "./v2/pubsub.v2";
 export * from "./v2/remoteConfig.v2";
 export * from "./v2/scheduler.v2";
+export * from "./v2/storage.v2";
 export * from "./v2/tasks.v2";

integration_test/functions/src/serializers/storage.ts

@@ -0,0 +1,40 @@
+import { serializeCloudEvent } from ".";
+import { StorageEvent, StorageObjectData } from "firebase-functions/v2/storage";
+
+export function serializeStorageEvent(event: StorageEvent): any {
+  return {
+    ...serializeCloudEvent(event),
+    bucket: event.bucket, // Exposed at top-level and object level
+    object: serializeStorageObjectData(event.data),
+  };
+}
+
+function serializeStorageObjectData(data: StorageObjectData): any {
+  return {
+    bucket: data.bucket,
+    cacheControl: data.cacheControl,
+    componentCount: data.componentCount,
+    contentDisposition: data.contentDisposition,
+    contentEncoding: data.contentEncoding,
+    contentLanguage: data.contentLanguage,
+    contentType: data.contentType,
+    crc32c: data.crc32c,
+    customerEncryption: data.customerEncryption,
+    etag: data.etag,
+    generation: data.generation,
+    id: data.id,
+    kind: data.kind,
+    md5Hash: data.md5Hash,
+    mediaLink: data.mediaLink,
+    metadata: data.metadata,
+    metageneration: data.metageneration,
+    name: data.name,
+    selfLink: data.selfLink,
+    size: data.size,
+    storageClass: data.storageClass,
+    timeCreated: data.timeCreated,
+    timeDeleted: data.timeDeleted,
+    timeStorageClassUpdated: data.timeStorageClassUpdated,
+    updated: data.updated,
+  };
+}

integration_test/functions/src/v2/dataconnect.v2.ts

@@ -0,0 +1,15 @@
+// import { sendEvent } from "../utils";
+// import { onMutationExecuted } from "firebase-functions/dataconnect";
+
+// export const databaseOnValueCreated = onMutationExecuted(
+//   {
+//     ref: `integration_test/{runId}/onValueCreated/{timestamp}`,
+//   },
+//   async (event) => {
+//     await sendEvent(
+//       "onValueCreated",
+//       serializeDatabaseEvent(event, serializeDataSnapshot(event.data!))
+//     );
+//   }
+// );
+

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

@@ -0,0 +1,106 @@
+import { describe, it, beforeAll, expect, afterAll } from "vitest";
+import { RUN_ID, waitForEvent } from "../utils";
+import { storage } from "../firebase.server";
+import { config } from "../config";
+import { expectCloudEvent } from "../assertions";
+import { expectStorageObjectData } from "../assertions/storage";
+
+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.v2", () => {
+  let createdFile: Awaited<ReturnType<typeof createDummyFile>>;
+  let uploadedData: any;
+  let metadataData: any;
+  let deletedData: 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 () => {
+    uploadedData = await waitForEvent("onObjectFinalized", async () => {
+      createdFile = await createDummyFile();
+    });
+
+    metadataData = await waitForEvent("onObjectMetadataUpdated", async () => {
+      await bucket.file(createdFile.name).setMetadata({
+        runId: RUN_ID,
+      });
+    });
+
+    deletedData = await waitForEvent("onObjectDeleted", async () => {
+      await bucket.file(createdFile.name).delete();
+    });
+  }, 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", () => {
+    it("should be a CloudEvent", () => {
+      expectCloudEvent(deletedData);
+    });
+
+    it("should have the correct data", () => {
+      expect(deletedData.bucket).toBe(config.storageBucket);
+      expectStorageObjectData(deletedData.object, filename);
+    });
+
+    // TODO: Doesn't seem to be sent by Google Cloud?
+    it.skip('should contain a timeDeleted timestamp', () => {
+      expect(deletedData.object.timeDeleted).toBeDefined();
+      expect(Date.parse(deletedData.object.timeDeleted)).toBeGreaterThan(0);
+    });
+  });
+
+  describe("onObjectMetadataUpdated", () => {
+    it("should be a CloudEvent", () => {
+      expectCloudEvent(metadataData);
+    });
+
+    it("should have the correct data", () => {
+      expect(metadataData.bucket).toBe(config.storageBucket);
+      expectStorageObjectData(metadataData.object, filename);
+    });
+
+    // TODO: Doesn't seem to be sent by Google Cloud?
+    it.skip('should have metadata', () => {
+      expect(metadataData.metadata).toBeDefined();
+      expect(metadataData.metadata.runId).toBe(RUN_ID);
+    });
+  });
+
+  describe("onObjectFinalized", () => {
+    it("should be a CloudEvent", () => {
+      expectCloudEvent(uploadedData);
+    });
+
+    it("should have the correct data", () => {
+      expect(uploadedData.bucket).toBe(config.storageBucket);
+      expectStorageObjectData(uploadedData.object, filename);
+    });
+
+    // TODO: Doesn't seem to be sent by Google Cloud?
+    it.skip('should not have initial metadata', () => {
+      expect(uploadedData.object.metadata).toBeDefined();
+      expect(uploadedData.object.metadata.runId).not.toBeUndefined();
+    });
+
+    // TODO: Doesn't seem to be sent by Google Cloud?
+    it.skip('should contain a timeCreated timestamp', () => {
+      expect(uploadedData.object.timeCreated).toBeDefined();
+      expect(Date.parse(uploadedData.object.timeCreated)).toBeGreaterThan(0);
+    });
+  });
+});

integration_test/functions/src/v2/storage.v2.ts

@@ -0,0 +1,19 @@
+import {
+  onObjectDeleted,
+  onObjectFinalized,
+  onObjectMetadataUpdated,
+} from "firebase-functions/v2/storage";
+import { sendEvent } from "../utils";
+import { serializeStorageEvent } from "../serializers/storage";
+
+export const storageOnObjectDeletedTrigger = onObjectDeleted(async (event) => {
+  await sendEvent("onObjectDeleted", serializeStorageEvent(event));
+});
+
+export const storageOnObjectFinalizedTrigger = onObjectFinalized(async (event) => {
+  await sendEvent("onObjectFinalized", serializeStorageEvent(event));
+});
+
+export const storageOnObjectMetadataUpdatedTrigger = onObjectMetadataUpdated(async (event) => {
+  await sendEvent("onObjectMetadataUpdated", serializeStorageEvent(event));
+});