Merge pull request #48 from deven-org/develop

Develop

netlify/functions/metrics.ts

@@ -7,7 +7,7 @@ const handler: Handler = async (event: HandlerEvent) => {
   try {
     const eventSignature = event.headers["x-github-event"] || "unknown";
     const body = getEventBody(event);
-    await collectMetricsHandler({ ...body, eventSignature });
+    await collectMetricsHandler({ eventSignature, ...body });
     return {
       statusCode: 200,
       body: "success",

src/__tests__/handler.test.ts

@@ -1,32 +1,99 @@
+import * as moduleAddSignature from "../core/addSignature";
+import * as moduleCollectMetrics from "../core/collectMetrics";
+import * as moduleStoreData from "../core/storeData";
 import { handler } from "../handler";
-import mergedCompletedSuccessfully from "./fixtures/merged-completed-successful.json";
+import { logger } from "../core/logger";
+import { DataEventSignature } from "../interfaces";
+import { LogErrors, LogWarnings } from "../shared/logMessages";
 
-describe("Handler", () => {
-  beforeEach(() => {});
+jest.mock("../core/logger", () => ({
+  __esModule: true,
+  logger: {
+    start: jest.fn(),
+    config: jest.fn(),
+    info: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+    complete: jest.fn(),
+  },
+}));
 
-  afterEach(() => {});
+const spyOnAddSignature = jest.spyOn(moduleAddSignature, "addSignature");
+const spyOnCollectMetrics = jest.spyOn(moduleCollectMetrics, "collectMetrics");
+const spyOnStoreData = jest.spyOn(moduleCollectMetrics, "collectMetrics");
 
-  it.only("returns the payload enhanced with relative matrix", async () => {
-    const data = {
-      signature: "packages",
+describe("handler", () => {
+  it("calls addSignature passing the given event payload", async () => {
+    const event = {
       foo: "foo",
       bar: "bar",
+      eventSignature: "toolingUsage",
     };
-    const output = await handler(data);
+    await handler(event);
+    expect(spyOnAddSignature).toBeCalledWith({
+      bar: "bar",
+      foo: "foo",
+      eventSignature: "toolingUsage",
+    });
+  });
+  it("calls collectMetrics passing a signed event, given that the event is known", async () => {
+    const event = {
+      foo: "foo",
+      bar: "bar",
+      eventSignature: "toolingUsage",
+    };
+
+    await handler(event);
 
-    expect(output).toMatchObject({
+    expect(spyOnCollectMetrics).toBeCalledWith({
       created_at: expect.any(Number),
-      output: data,
-      dataEventSignature: "packages",
+      dataEventSignature: "deven-tooling-usage",
+      owner: "",
+      repo: "",
+      output: {},
+      payload: {
+        foo: "foo",
+        bar: "bar",
+        eventSignature: "toolingUsage",
+      },
     });
   });
 
-  it("...", async () => {
-    const output = await handler(mergedCompletedSuccessfully);
+  it("doesn't call collectMetrics if the event is unknown", async () => {
+    const event = {
+      foo: "foo",
+      bar: "bar",
+      eventSignature: "foo",
+    };
+
+    await handler(event);
+
+    expect(spyOnCollectMetrics).not.toBeCalled();
+    expect(logger.warning).toBeCalledWith(
+      LogWarnings.signingEventSignatureNotRecognized
+    );
+  });
+
+  it("calls storeData passing an enhanced data event, given that the metrics can be collects", async () => {
+    const event = {
+      foo: "foo",
+      bar: "bar",
+      eventSignature: "toolingUsage",
+    };
+
+    await handler(event);
 
-    expect(output).toMatchObject({
+    expect(spyOnStoreData).toBeCalledWith({
       created_at: expect.any(Number),
-      dataEventSignature: "merged-pr",
+      dataEventSignature: "deven-tooling-usage",
+      output: {},
+      owner: "",
+      payload: {
+        bar: "bar",
+        eventSignature: "toolingUsage",
+        foo: "foo",
+      },
+      repo: "",
     });
   });
 });

src/__tests__/setup.js

@@ -2,11 +2,11 @@ const dotenv = require("dotenv");
 
 global.console = {
   ...console,
-  //log: jest.fn(),
+  // log: jest.fn(),
   debug: jest.fn(),
   info: jest.fn(),
   warn: jest.fn(),
-  error: jest.fn(),
+  // error: jest.fn(),
 };
 
 dotenv.config({ path: ".test.env" });

src/core/addSignature.ts

@@ -1,9 +1,7 @@
-import { createDataEvent, Errors, getRejectionReason, logger } from ".";
-import { cond, T, always, pipe, clone } from "ramda";
-import { isWorkflowJobCompleted } from "./signingConditions";
-import { LogInfos } from "../shared/logMessages";
+import { createDataEvent, getRejectionReason, logger } from ".";
+import { cond, pipe, clone, T, always } from "ramda";
+import { LogInfos, LogWarnings } from "../shared/logMessages";
 import { DataEventSignature, DataEvent } from "../interfaces";
-import { isPullRequestClosed } from "../metrics/pull_requests/signatureConditions";
 import signatureConditions from "../signatureConditions";
 
 const createSignedDataEvent =
@@ -14,25 +12,29 @@ const createSignedDataEvent =
       dataEventSignature: signature,
       output: {},
       payload: data,
+      owner: "",
+      repo: "",
     });
   };
 
-const signDataEvent = cond(
-  signatureConditions.map((cond) => [
-    cond[0],
-    createSignedDataEvent(cond[1] as DataEventSignature),
-  ])
-);
+const signDataEvent = cond([
+  ...signatureConditions.map((item) => [
+    item[0],
+    createSignedDataEvent(item[1]),
+  ]),
+  [T, always(false)],
+]);
 
 export const addSignature = (data: any): Promise<DataEvent> => {
   return new Promise((res, rej) => {
     const signedDataEvent = pipe(clone, signDataEvent)(data);
+
     signedDataEvent
       ? res(signedDataEvent)
       : rej(
           getRejectionReason({
-            level: "warn",
-            message: Errors.signingEventSignatureNotRecognized,
+            level: "warning",
+            message: LogWarnings.signingEventSignatureNotRecognized,
           })
         );
   });

src/metrics/collectMetrics.ts → src/core/collectMetrics.ts

@@ -1,13 +1,14 @@
-import { getRejectionReason } from "../core";
-import { logger } from "../core/logger";
-import { cond, clone, pipe, omit } from "ramda";
+import { getRejectionReason } from ".";
+import { logger } from "./logger";
+import { cond, clone, pipe, omit, T, always } from "ramda";
 import metricsConditions from "../metricsConditions";
 
 import { LogErrors, LogInfos } from "../shared/logMessages";
 import { DataEvent, EnhancedDataEvent } from "../interfaces";
 
 const collectMetricsBySignature = cond(
-  metricsConditions.map((cond) => [cond[0], cond[1]])
+  [metricsConditions.map((cond) => [cond[0], cond[1]])],
+  [T, always(false)]
 );
 
 export const collectMetrics = async (

src/core/errorCatcher.ts

@@ -1,12 +1,7 @@
 import { logger } from "./logger";
 
-export enum Errors {
-  collectMetricsSignatureNotRecognized = "The signature of the data event is not recognized.",
-  signingEventSignatureNotRecognized = "Can't identify the signature of the data event. Skipping.",
-}
-
 export interface ErrorForCatcher {
-  level: "error" | "warn";
+  level: "error" | "warning";
   message: string;
 }
 

src/handler.ts

@@ -1,4 +1,4 @@
-import { collectMetrics } from "./metrics/collectMetrics";
+import { collectMetrics } from "./core/collectMetrics";
 import { storeData, errorCatcher } from "./core";
 import { logger } from "./core/logger";
 import { pipeWith, tap } from "ramda";

src/interfaces.ts

@@ -2,22 +2,32 @@ import {
   PullRequestClosedPayload,
   PullRequestClosedOutput,
 } from "./metrics/pull_requests/interfaces";
+import {
+  ToolingUsageOutput,
+  ToolingUsagePayload,
+} from "./metrics/tooling_usage/interfaces";
 
-import { WorkflowJobCompletedPayload } from "./metrics/workflows/interfaces";
+import {
+  WorkflowJobCompletedOutput,
+  WorkflowJobCompletedPayload,
+} from "./metrics/workflows/interfaces";
 
 export enum DataEventSignature {
   PullRequestClosed = "pull_request-completed",
   WorkflowJobCompleted = "workflow-job-completed",
+  ToolingUsage = "deven-tooling-usage",
 }
 
 interface DataEventPayloadMap {
   [DataEventSignature.PullRequestClosed]: PullRequestClosedPayload;
   [DataEventSignature.WorkflowJobCompleted]: WorkflowJobCompletedPayload;
+  [DataEventSignature.ToolingUsage]: ToolingUsagePayload;
 }
 
 interface DataEventOutputMap {
   [DataEventSignature.PullRequestClosed]: PullRequestClosedOutput;
-  [DataEventSignature.WorkflowJobCompleted]: WorkflowJobCompletedPayload;
+  [DataEventSignature.WorkflowJobCompleted]: WorkflowJobCompletedOutput;
+  [DataEventSignature.ToolingUsage]: ToolingUsageOutput;
 }
 
 export type EnhancedDataEvent = Omit<DataEvent, "payload">;

src/metrics/pull_requests/signatureConditions.ts

@@ -1,10 +1,9 @@
 import { allPass, propEq } from "ramda";
 import { DataEventSignature } from "../../interfaces";
 
-export const isPullRequestClosed = () =>
-  allPass([
-    propEq("eventSignature", "pull_request"),
-    propEq("action", "closed"),
-  ]);
+export const isPullRequestClosed = allPass([
+  propEq("eventSignature", "pull_request"),
+  propEq("action", "closed"),
+]);
 
 export default [[isPullRequestClosed, DataEventSignature.PullRequestClosed]];