integration test.

Author: taeold

integration_test/README.md

@@ -8,14 +8,30 @@ Run the integration test as follows:
 ./run_tests.sh <project_id> [<project_id2>]
 ```
 
-Test runs cycles of testing, once for Node.js 14 and another for Node.js 16.
+Test runs cycles of testing, once for Node.js 18 and another for Node.js 20.
 
 Test uses locally installed firebase to invoke commands for deploying function. The test also requires that you have
 gcloud CLI installed and authenticated (`gcloud auth login`).
 
 Integration test is triggered by invoking HTTP function integrationTest which in turns invokes each function trigger
 by issuing actions necessary to trigger it (e.g. write to storage bucket).
 
+### Tested v2 Triggers
+
+The integration tests now cover all v2 SDK triggers:
+- **HTTPS**: onCall (including streaming), onRequest
+- **Database**: onValueWritten, onValueCreated, onValueDeleted, onValueUpdated
+- **Firestore**: onDocumentWritten, onDocumentCreated, onDocumentDeleted, onDocumentUpdated
+- **Storage**: onObjectFinalized, onObjectDeleted, onObjectArchived, onObjectMetadataUpdated
+- **Pub/Sub**: onMessagePublished (with retry support)
+- **Scheduled**: onSchedule
+- **Tasks**: onTaskDispatched (with retry support)
+- **Remote Config**: onConfigUpdated
+- **Test Lab**: onTestMatrixCompleted
+- **Identity**: beforeUserCreated, beforeUserSignedIn
+- **Eventarc**: onCustomEventPublished
+- **Alerts**: Crashlytics, Billing, App Distribution, Performance alerts
+
 ### Debugging
 
 The status and result of each test is stored in RTDB of the project used for testing. You can also inspect Cloud Logging

integration_test/functions/src/index.ts

@@ -169,10 +169,77 @@ function v1Tests(testId: string, accessToken: string): Array<Promise<unknown>> {
 function v2Tests(testId: string, accessToken: string): Array<Promise<void>> {
   return [
     // Invoke a callable HTTPS trigger.
-    // TODO: Temporarily disable - doesn't work unless running on projects w/ permission to create public functions.
-    // callV2HttpsTrigger("v2-callabletests", { foo: "bar", testId }, accessToken),
+    callV2HttpsTrigger("v2-callabletests", { foo: "bar", testId }, accessToken),
+    // Test streaming callable function
+    callV2HttpsTrigger("v2-callabletestsstreaming", { testId, streaming: true }, accessToken),
+    // Test onRequest endpoints
+    fetch(
+      `https://${REGION}-${firebaseConfig.projectId}.cloudfunctions.net/v2-httpstests?testId=${testId}`
+    ).then((r) => r.text()),
     // Invoke a scheduled trigger.
     callV2ScheduleTrigger("v2-schedule", "us-central1", accessToken),
+    // Database triggers
+    admin.database().ref(`v2tests/${testId}/db/written`).set("world"),
+    admin.database().ref(`v2tests/${testId}/db/created`).set("created"),
+    admin
+      .database()
+      .ref(`v2tests/${testId}/db/updated`)
+      .set("original")
+      .then(() => admin.database().ref(`v2tests/${testId}/db/updated`).set("updated")),
+    admin
+      .database()
+      .ref(`v2tests/${testId}/db/toDelete`)
+      .set("willBeDeleted")
+      .then(() => admin.database().ref(`v2tests/${testId}/db/toDelete`).remove()),
+    // Storage triggers
+    admin
+      .storage()
+      .bucket()
+      .upload(`/tmp/${testId}.txt`, { destination: `v2tests/${testId}/test.txt` }),
+    // Firestore triggers
+    admin
+      .firestore()
+      .collection(`v2tests/${testId}/firestore`)
+      .doc("test")
+      .set({ value: "written" }),
+    admin
+      .firestore()
+      .collection(`v2tests/${testId}/firestore-created`)
+      .doc("test")
+      .set({ value: "created" }),
+    admin
+      .firestore()
+      .collection(`v2tests/${testId}/firestore-updated`)
+      .doc("test")
+      .set({ value: "original" })
+      .then(() =>
+        admin
+          .firestore()
+          .collection(`v2tests/${testId}/firestore-updated`)
+          .doc("test")
+          .update({ value: "updated" })
+      ),
+    admin
+      .firestore()
+      .collection(`v2tests/${testId}/firestore-to-delete`)
+      .doc("deleteMe")
+      .set({ value: "toBeDeleted" })
+      .then(() =>
+        admin
+          .firestore()
+          .collection(`v2tests/${testId}/firestore-to-delete`)
+          .doc("deleteMe")
+          .delete()
+      ),
+    // Pub/Sub triggers
+    new PubSub()
+      .topic("v2-pubsub-test-topic")
+      .publish(Buffer.from(JSON.stringify({ testId })), { testId }),
+    new PubSub()
+      .topic("v2-pubsub-test-retry-topic")
+      .publish(Buffer.from(JSON.stringify({ testRetry: true })), { testId, attempt: "1" }),
+    // Remote Config trigger
+    updateRemoteConfig(`v2-${testId}`, accessToken),
   ];
 }
 

integration_test/functions/src/v2/alerts-tests.ts

@@ -0,0 +1,107 @@
+import {
+  onAlertPublished,
+  crashlytics,
+  billing,
+  appDistribution,
+  performance,
+} from "firebase-functions/v2/alerts";
+import { expectEq, TestSuite } from "../testing";
+
+export const alertstestsCrashlytics = onAlertPublished(
+  { alertType: "crashlytics.newFatalIssue" },
+  (event) => {
+    const testId = event.appId || "unknown";
+
+    return new TestSuite("alerts crashlytics onAlertPublished")
+      .it("should have alert type", () => {
+        expectEq(event.alertType, "crashlytics.newFatalIssue");
+      })
+      .it("should have app id", () => {
+        expectEq(typeof event.appId, "string");
+      })
+      .run(testId, event);
+  }
+);
+
+export const alertstestsBilling = onAlertPublished({ alertType: "billing.planUpdate" }, (event) => {
+  const testId = event.appId || "unknown";
+
+  return new TestSuite("alerts billing onAlertPublished")
+    .it("should have alert type", () => {
+      expectEq(event.alertType, "billing.planUpdate");
+    })
+    .run(testId, event);
+});
+
+export const alertstestsAppDistribution = appDistribution.onNewTesterIosDevicePublished((event) => {
+  const testId = event.appId || "unknown";
+
+  return new TestSuite("alerts appDistribution onNewTesterIosDevicePublished")
+    .it("should have app id", () => {
+      expectEq(typeof event.appId, "string");
+    })
+    .it("should have tester name", () => {
+      expectEq(typeof event.data.testerName, "string");
+    })
+    .it("should have device model", () => {
+      expectEq(typeof event.data.testerDeviceModelName, "string");
+    })
+    .it("should have device identifier", () => {
+      expectEq(typeof event.data.testerDeviceIdentifier, "string");
+    })
+    .run(testId, event);
+});
+
+export const alertstestsPerformance = performance.onThresholdAlertPublished((event) => {
+  const testId = event.appId || "unknown";
+
+  return new TestSuite("alerts performance onThresholdAlertPublished")
+    .it("should have app id", () => {
+      expectEq(typeof event.appId, "string");
+    })
+    .it("should have metric type", () => {
+      expectEq(typeof event.data.metricType, "string");
+    })
+    .it("should have event name", () => {
+      expectEq(typeof event.data.eventName, "string");
+    })
+    .it("should have threshold value", () => {
+      expectEq(typeof event.data.thresholdValue, "number");
+    })
+    .it("should have threshold unit", () => {
+      expectEq(typeof event.data.thresholdUnit, "string");
+    })
+    .run(testId, event);
+});
+
+export const alertstestsCrashlyticsRegression = crashlytics.onRegressionAlertPublished((event) => {
+  const testId = event.appId || "unknown";
+
+  return new TestSuite("alerts crashlytics onRegressionAlertPublished")
+    .it("should have app id", () => {
+      expectEq(typeof event.appId, "string");
+    })
+    .it("should have issue data", () => {
+      expectEq(typeof event.data.issue, "object");
+    })
+    .it("should have issue id", () => {
+      expectEq(typeof event.data.issue.id, "string");
+    })
+    .it("should have issue title", () => {
+      expectEq(typeof event.data.issue.title, "string");
+    })
+    .run(testId, event);
+});
+
+export const alertstestsBillingAutomated = billing.onPlanAutomatedUpdatePublished((event) => {
+  const testId = event.appId || "unknown";
+
+  return new TestSuite("alerts billing onPlanAutomatedUpdatePublished")
+    .it("should have billing plan", () => {
+      expectEq(typeof event.data.billingPlan, "string");
+    })
+    .it("should have notification type", () => {
+      expectEq(typeof event.data.notificationType, "string");
+    })
+    .run(testId, event);
+});

integration_test/functions/src/v2/database-tests.ts

@@ -0,0 +1,65 @@
+import * as admin from "firebase-admin";
+import {
+  onValueWritten,
+  onValueCreated,
+  onValueDeleted,
+  onValueUpdated,
+} from "firebase-functions/v2/database";
+import { expectEq, TestSuite } from "../testing";
+
+export const databasetestsWritten = onValueWritten("/v2tests/{testId}/db/written", (event) => {
+  return new TestSuite("database onValueWritten")
+    .it("should have path", () => {
+      expectEq(event.params.testId, event.data.after.ref.parent?.parent?.key);
+    })
+    .it("should have data", () => {
+      expectEq(event.data.after.val(), "world");
+    })
+    .it("should have before data", () => {
+      expectEq(event.data.before.val(), null);
+    })
+    .run(event.params.testId, event.data);
+});
+
+export const databasetestsCreated = onValueCreated("/v2tests/{testId}/db/created", (event) => {
+  return new TestSuite("database onValueCreated")
+    .it("should have path", () => {
+      expectEq(event.params.testId, event.data.ref.parent?.parent?.key);
+    })
+    .it("should have data", () => {
+      expectEq(event.data.val(), "created");
+    })
+    .run(event.params.testId, event.data);
+});
+
+export const databasetestsDeleted = onValueDeleted(
+  "/v2tests/{testId}/db/deleted",
+  async (event) => {
+    // First write a value to be deleted
+    const db = admin.database();
+    await db.ref(`/v2tests/${event.params.testId}/db/toDelete`).set("willBeDeleted");
+
+    return new TestSuite("database onValueDeleted")
+      .it("should have path", () => {
+        expectEq(event.params.testId, event.data.ref.parent?.parent?.key);
+      })
+      .it("should have previous data", () => {
+        expectEq(event.data.val(), "willBeDeleted");
+      })
+      .run(event.params.testId, event.data);
+  }
+);
+
+export const databasetestsUpdated = onValueUpdated("/v2tests/{testId}/db/updated", (event) => {
+  return new TestSuite("database onValueUpdated")
+    .it("should have path", () => {
+      expectEq(event.params.testId, event.data.after.ref.parent?.parent?.key);
+    })
+    .it("should have new data", () => {
+      expectEq(event.data.after.val(), "updated");
+    })
+    .it("should have old data", () => {
+      expectEq(event.data.before.val(), "original");
+    })
+    .run(event.params.testId, event.data);
+});

integration_test/functions/src/v2/eventarc-tests.ts

@@ -0,0 +1,52 @@
+import { onCustomEventPublished } from "firebase-functions/v2/eventarc";
+import { expectEq, TestSuite } from "../testing";
+
+export const eventarctests = onCustomEventPublished("test.v2.custom.event", (event) => {
+  const testId = event.data?.testId || "unknown";
+
+  return new TestSuite("eventarc onCustomEventPublished")
+    .it("should have event type", () => {
+      expectEq(event.type, "test.v2.custom.event");
+    })
+    .it("should have event id", () => {
+      expectEq(typeof event.id, "string");
+    })
+    .it("should have event source", () => {
+      expectEq(typeof event.source, "string");
+    })
+    .it("should have event time", () => {
+      expectEq(typeof event.time, "string");
+    })
+    .it("should have event data", () => {
+      expectEq(event.data?.message, "Hello from Eventarc");
+    })
+    .it("should have custom attributes", () => {
+      expectEq(event.data?.customAttribute, "customValue");
+    })
+    .run(testId, event);
+});
+
+export const eventarctestsWithFilter = onCustomEventPublished(
+  {
+    eventType: "test.v2.filtered.event",
+    channel: "locations/us-central1/channels/firebase",
+    filters: {
+      attribute1: "value1",
+    },
+  },
+  (event) => {
+    const testId = event.data?.testId || "unknown";
+
+    return new TestSuite("eventarc onCustomEventPublished with filters")
+      .it("should have matching event type", () => {
+        expectEq(event.type, "test.v2.filtered.event");
+      })
+      .it("should have filtered attribute", () => {
+        expectEq(event.data?.attribute1, "value1");
+      })
+      .it("should have channel data", () => {
+        expectEq(typeof event.source, "string");
+      })
+      .run(testId, event);
+  }
+);