Finish missing tests; remove redundant v1 tests

spec/v1/cloud-functions.spec.ts

@@ -42,7 +42,7 @@ describe("makeCloudFunction", () => {
     legacyEventType: "providers/provider/eventTypes/event",
   };
 
-  it("should call the onInit callback", async () => {
+  it("calls init function", async () => {
     const test: Event = {
       context: {
         eventId: "00000",

spec/v1/providers/analytics.spec.ts

@@ -109,16 +109,13 @@ describe("Analytics Functions", () => {
           },
         };
 
-        let hello;
-        functions.onInit(() => hello = "world");
         await expect(cloudFunction(event.data, event.context)).to.eventually.deep.equal({
           params: {},
           user: {
             userId: "hi!",
             userProperties: {},
           },
         });
-        expect(hello).equals("world");
       });
 
       it("should remove xValues", () => {

spec/v1/providers/auth.spec.ts

@@ -339,30 +339,4 @@ describe("Auth Functions", () => {
       expect(cf.run).to.not.throw(Error);
     });
   });
-
-  describe("onInit", () => {
-    beforeEach(() => {
-      functions.onInit(() => {});
-      process.env.GCLOUD_PROJECT = "project";
-    });
-
-    after(() => {
-      functions.onInit(null);
-      delete process.env.GCLOUD_PROJECT;
-    })
-
-    it("initailizes before onCreate", async () => {
-      let hello;
-      functions.onInit(() => hello = "world");
-      await auth.user().onCreate(() => null)(event.data, event.context);
-      expect(hello).equals("world");
-    });
-
-    it("initailizes before onDelete", async () => {
-      let hello;
-      functions.onInit(() => hello = "world");
-      await auth.user().onDelete(() => null)(event.data, event.context);
-      expect(hello).equals("world");
-    });
-  });
 });

spec/v1/providers/database.spec.ts

@@ -116,7 +116,7 @@ describe("Database Functions", () => {
         );
       });
 
-      it("should return a handler that emits events with a proper DataSnapshot", async () => {
+      it("should return a handler that emits events with a proper DataSnapshot", () => {
         const event = {
           data: {
             data: null,
@@ -133,11 +133,7 @@ describe("Database Functions", () => {
           expect(change.after.val()).to.deep.equal({ foo: "bar" });
         });
 
-        let hello;
-        functions.onInit(() => (hello = "world"));
-        expect(hello).is.undefined;
-        await handler(event.data, event.context);
-        expect(hello).equals("world");
+        return handler(event.data, event.context);
       });
 
       it("Should have params of the correct type", () => {
@@ -181,7 +177,7 @@ describe("Database Functions", () => {
         );
       });
 
-      it("should return a handler that emits events with a proper DataSnapshot", async () => {
+      it("should return a handler that emits events with a proper DataSnapshot", () => {
         const event = {
           data: {
             data: null,
@@ -199,11 +195,7 @@ describe("Database Functions", () => {
           expect(data.val()).to.deep.equal({ foo: "bar" });
         });
 
-        let hello;
-        functions.onInit(() => (hello = "world"));
-        expect(hello).to.be.undefined;
-        await handler(event.data, event.context);
-        expect(hello).equals("world");
+        return handler(event.data, event.context);
       });
 
       it("Should have params of the correct type", () => {
@@ -247,7 +239,7 @@ describe("Database Functions", () => {
         );
       });
 
-      it("should return a handler that emits events with a proper DataSnapshot", async () => {
+      it("should return a handler that emits events with a proper DataSnapshot", () => {
         const event = {
           data: {
             data: null,
@@ -265,11 +257,7 @@ describe("Database Functions", () => {
           expect(change.after.val()).to.deep.equal({ foo: "bar" });
         });
 
-        let hello;
-        functions.onInit(() => (hello = "world"));
-        expect(hello).is.undefined;
-        await handler(event.data, event.context);
-        expect(hello).equals("world");
+        return handler(event.data, event.context);
       });
 
       it("Should have params of the correct type", () => {
@@ -313,7 +301,7 @@ describe("Database Functions", () => {
         );
       });
 
-      it("should return a handler that emits events with a proper DataSnapshot", async () => {
+      it("should return a handler that emits events with a proper DataSnapshot", () => {
         const event = {
           data: {
             data: { foo: "bar" },
@@ -331,11 +319,7 @@ describe("Database Functions", () => {
           expect(data.val()).to.deep.equal({ foo: "bar" });
         });
 
-        let hello;
-        functions.onInit(() => (hello = "world"));
-        expect(hello).is.undefined;
-        await handler(event.data, event.context);
-        expect(hello).equals("world");
+        return handler(event.data, event.context);
       });
 
       it("Should have params of the correct type", () => {

spec/v1/providers/firestore.spec.ts

@@ -234,7 +234,7 @@ describe("Firestore Functions", () => {
       delete process.env.GCLOUD_PROJECT;
     });
 
-    it('constructs appropriate fields and getters for event.data on "document.write" events', async () => {
+    it('constructs appropriate fields and getters for event.data on "document.write" events', () => {
       const testFunction = firestore.document("path").onWrite((change) => {
         expect(change.before.data()).to.deep.equal({
           key1: false,
@@ -246,30 +246,20 @@ describe("Firestore Functions", () => {
         return true; // otherwise will get warning about returning undefined
       });
       const event = constructEvent(createOldValue(), createValue());
-
-      let hello;
-      functions.onInit(() => (hello = "world"));
-      expect(hello).is.undefined;
-      await testFunction(event.data, event.context);
-      expect(hello).equals("world");
+      return testFunction(event.data, event.context);
     }).timeout(5000);
 
-    it('constructs appropriate fields and getters for event.data on "document.create" events', async () => {
+    it('constructs appropriate fields and getters for event.data on "document.create" events', () => {
       const testFunction = firestore.document("path").onCreate((data) => {
         expect(data.data()).to.deep.equal({ key1: true, key2: 123 });
         expect(data.get("key1")).to.equal(true);
         return true; // otherwise will get warning about returning undefined
       });
       const event = constructEvent({}, createValue());
-
-      let hello;
-      functions.onInit(() => (hello = "world"));
-      expect(hello).is.undefined;
-      await testFunction(event.data, event.context);
-      expect(hello).equals("world");
+      return testFunction(event.data, event.context);
     }).timeout(5000);
 
-    it('constructs appropriate fields and getters for event.data on "document.update" events', async () => {
+    it('constructs appropriate fields and getters for event.data on "document.update" events', () => {
       const testFunction = firestore.document("path").onUpdate((change) => {
         expect(change.before.data()).to.deep.equal({
           key1: false,
@@ -281,27 +271,17 @@ describe("Firestore Functions", () => {
         return true; // otherwise will get warning about returning undefined
       });
       const event = constructEvent(createOldValue(), createValue());
-
-      let hello;
-      functions.onInit(() => (hello = "world"));
-      expect(hello).is.undefined;
-      await testFunction(event.data, event.context);
-      expect(hello).equals("world");
+      return testFunction(event.data, event.context);
     }).timeout(5000);
 
-    it('constructs appropriate fields and getters for event.data on "document.delete" events', async () => {
+    it('constructs appropriate fields and getters for event.data on "document.delete" events', () => {
       const testFunction = firestore.document("path").onDelete((data) => {
         expect(data.data()).to.deep.equal({ key1: false, key2: 111 });
         expect(data.get("key1")).to.equal(false);
         return true; // otherwise will get warning about returning undefined
       });
       const event = constructEvent(createOldValue(), {});
-
-      let hello;
-      functions.onInit(() => (hello = "world"));
-      expect(hello).is.undefined;
-      await testFunction(event.data, event.context);
-      expect(hello).equals("world");
+      return testFunction(event.data, event.context);
     }).timeout(5000);
   });
 

spec/v1/providers/https.spec.ts

@@ -72,11 +72,13 @@ describe("CloudHttpsBuilder", () => {
       expect(fn.__endpoint.httpsTrigger.invoker).to.deep.equal(["private"]);
     });
 
-    it("should call initializer", async () => {
+    it("calls init function", async () => {
       let hello;
       onInit(() => (hello = "world"));
       expect(hello).to.be.undefined;
-      const fn = functions.https.onRequest(() => null);
+      const fn = functions.https.onRequest((_req, res) => {
+        res.send(200);
+      });
       const req = new MockRequest(
         {
           data: { foo: "bar" },
@@ -86,9 +88,7 @@ describe("CloudHttpsBuilder", () => {
         }
       );
       req.method = "POST";
-      // We don't really have test infrastructure to fake requests. Luckily we
-      // don't touch much of the request in boilerplate, just trace context.
-      await fn({headers: []} as any, null as any);
+      await runHandler(fn, req as any);
       expect(hello).to.equal("world");
     });
   });

spec/v1/providers/pubsub.spec.ts

@@ -123,7 +123,7 @@ describe("Pubsub Functions", () => {
         expect(() => pubsub.topic("bad/topic/format")).to.throw(Error);
       });
 
-      it("should properly handle a new-style event", async () => {
+      it("should properly handle a new-style event", () => {
         const raw = new Buffer('{"hello":"world"}', "utf8").toString("base64");
         const event: Event = {
           data: {
@@ -151,15 +151,11 @@ describe("Pubsub Functions", () => {
           };
         });
 
-        let hello;
-        functions.onInit(() => (hello = "world"));
-        expect(hello).is.undefined;
-        await expect(result(event.data, event.context)).to.eventually.deep.equal({
+        return expect(result(event.data, event.context)).to.eventually.deep.equal({
           raw,
           json: { hello: "world" },
           attributes: { foo: "bar" },
         });
-        expect(hello).equals("world");
       });
     });
 

spec/v2/providers/alerts/appDistribution.spec.ts

@@ -93,7 +93,7 @@ describe("appDistribution", () => {
       expect(res).to.equal("input");
     });
 
-    it("should call the initializer", async () => {
+    it("calls init function", async () => {
       const func = appDistribution.onNewTesterIosDevicePublished(APPID, (event) => event);
 
       let hello;
@@ -184,7 +184,7 @@ describe("appDistribution", () => {
       expect(res).to.equal("input");
     });
 
-    it("should call the initializer", async () => {
+    it("calls init function", async () => {
       const func = appDistribution.onInAppFeedbackPublished(APPID, (event) => event);
 
       let hello;

spec/v2/providers/alerts/billing.spec.ts

@@ -43,7 +43,7 @@ describe("billing", () => {
       });
     });
 
-    it("should call the initializer", async () => {
+    it("calls init function", async () => {
       const func = billing.onPlanAutomatedUpdatePublished((event) => event);
 
       let hello;
@@ -88,7 +88,7 @@ describe("billing", () => {
       });
     });
 
-    it("should call the initializer", async () => {
+    it("calls init function", async () => {
       const func = billing.onPlanAutomatedUpdatePublished((event) => event);
 
       let hello;
@@ -141,7 +141,7 @@ describe("billing", () => {
       expect(res).to.equal("input");
     });
 
-    it("should call the initializer", async () => {
+    it("calls init function", async () => {
       const func = billing.onOperation(ALERT_TYPE, (event) => event, undefined);
 
       let hello;

spec/v2/providers/alerts/crashlytics.spec.ts

@@ -106,7 +106,7 @@ describe("crashlytics", () => {
         });
       });
 
-      it("should call initializer", async () => {
+      it("calls init function", async () => {
         const func = crashlytics[method](APPID, myHandler);
 
         let hello;

spec/v2/providers/alerts/performance.spec.ts

@@ -3,6 +3,7 @@ import * as alerts from "../../../../src/v2/providers/alerts";
 import * as performance from "../../../../src/v2/providers/alerts/performance";
 import { FULL_OPTIONS } from "../fixtures";
 import { FULL_ENDPOINT, MINIMAL_V2_ENDPOINT } from "../../../fixtures";
+import { CloudEvent, onInit } from "../../../../src/v2/core";
 
 const APPID = "123456789";
 const myHandler = () => 42;
@@ -45,6 +46,23 @@ describe("performance", () => {
           retry: false,
         },
       });
+
+      it("calls init function", async () => {
+        const event: CloudEvent<string> = {
+          specversion: "1.0",
+          id: "id",
+          source: "source",
+          type: "type",
+          time: "now",
+          data: "data",
+        };
+
+        let hello: string;
+        onInit(() => (hello = "world"));
+        expect(hello).to.be.undefined;
+        await performance.onThresholdAlertPublished(() => null)(event);
+        expect(hello).to.equal("world");
+      });
     });
 
     it("should create a function with appid in opts", () => {