feat: refactor reporter interface

Author: shanejonas

bin/cli.js

@@ -15,7 +15,7 @@ program
   .version(require('./get-version'))
   .usage('[options]')
   .option('-s, --schema [schema]', 'JSON string or a Path/Url pointing to an open rpc schema')
-  .option('-r, --reporter <reporter>', 'Use the specified reporter [console] [json]')
+  .option('-r, --reporter <reporter>', 'Use the specified reporter [console] [json] [empty]')
   .option('-t, --transport <transport>', 'Use the specified transport [http]')
   .option('--skip <skip>', 'Methods to skip')
   .option('--only <only>', 'Methods to only run')

package-lock.json

@@ -30,11 +30,21 @@
   },
   "devDependencies": {
     "@open-rpc/meta-schema": "^1.13.13",
+<<<<<<< HEAD
     "@types/jest": "^29.5.12",
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2",
     "typescript": "^5.4.4",
     "typescript-eslint": "^7.6.0"
+=======
+    "@playwright/test": "^1.43.0",
+    "@types/jest": "^26.0.0",
+    "@types/node": "^16.0.0",
+    "jest": "^25.1.0",
+    "ts-jest": "^25.0.0",
+    "tslint": "^6.0.0",
+    "typescript": "^3.4.3"
+>>>>>>> b357747 (feat: refactor reporter interface)
   }
 }

package.json

@@ -1,5 +1,6 @@
-import coverage from "./coverage";
+import coverage, { ExampleCall, IOptions } from "./coverage";
 import { OpenrpcDocument } from "@open-rpc/meta-schema";
+import EmptyReporter from "./reporters/emptyReporter";
 
 const mockSchema = {
   openrpc: "1.0.0",
@@ -69,28 +70,38 @@ const mockSchema = {
 describe("coverage", () => {
   describe("reporter", () => {
     it("can call the reporter", (done) => {
-      const reporter = (callResults: any[], schema: OpenrpcDocument) => {
-        done();
-      };
+      class CustomReporter {
+        onBegin() {}
+        onTestBegin() {}
+        onTestEnd() {}
+        onEnd() {
+          done();
+        }
+      }
       const transport = () => Promise.resolve();
       coverage({
-        reporter,
+        reporter: new CustomReporter(),
         transport,
         openrpcDocument: mockSchema,
         skip: [],
         only: [],
       });
     });
     it("can call the reporter with the results", (done) => {
-      const reporter = (callResults: any[], schema: OpenrpcDocument) => {
-        expect(callResults[0].result).toBe(true);
-        done();
-      };
+      class CustomReporter {
+        onBegin() {}
+        onTestBegin() {}
+        onTestEnd() {}
+        onEnd(options: IOptions, exampleCalls: ExampleCall[]) {
+          expect(exampleCalls[0].result).toBe(true);
+          done();
+        }
+      }
       const transport = async (url: string, method: string, params: any[]) => {
         return { result: true };
       };
       coverage({
-        reporter,
+        reporter: new CustomReporter(),
         transport,
         openrpcDocument: mockSchema,
         skip: [],
@@ -100,15 +111,12 @@ describe("coverage", () => {
   });
   describe("transport", () => {
     it("can call the transport", (done) => {
-      const reporter = () => {
-        // empty reporter
-      };
       const transport = () => {
         done();
         return Promise.resolve({});
       };
       coverage({
-        reporter,
+        reporter: new EmptyReporter(),
         transport,
         openrpcDocument: mockSchema,
         skip: [],

src/coverage.test.ts

@@ -6,22 +6,23 @@ import {
   ContentDescriptorObject,
   Servers,
   MethodObjectParams,
-  MethodObject
+  MethodObject,
 } from "@open-rpc/meta-schema";
 const jsf = require("json-schema-faker"); // tslint:disable-line
 import Ajv from "ajv";
 import { isEqual } from "lodash";
+import Reporter from "./reporters/emptyReporter";
 
 const getFakeParams = (params: any[]): any[] => {
   return params.map((p) => jsf.generate(p.schema));
 };
 
-interface IOptions {
+export interface IOptions {
   openrpcDocument: OpenrpcDocument;
   skip: string[];
   only: string[];
   transport(url: string, method: string, params: any[]): PromiseLike<any>;
-  reporter(value: any[], schema: OpenrpcDocument): any;
+  reporter: Reporter;
 }
 
 export interface ExampleCall {
@@ -34,49 +35,66 @@ export interface ExampleCall {
   resultSchema: JSONSchema;
   expectedResult?: any;
   requestError?: any;
+  title: string;
 }
 
-const paramsToObj = (params: any[], methodParams: ContentDescriptorObject[]): any => {
+const paramsToObj = (
+  params: any[],
+  methodParams: ContentDescriptorObject[]
+): any => {
   return params.reduce((acc, val, i) => {
     acc[methodParams[i].name] = val;
     return acc;
   }, {});
-}
+};
 
 export default async (options: IOptions) => {
-  const filteredMethods = (options.openrpcDocument.methods as MethodObject[])
+  const filteredMethods = options.openrpcDocument.methods
     .filter(({ name }) => !options.skip.includes(name))
-    .filter(({ name }) => options.only.length === 0 || options.only.includes(name));
+    .filter(
+      ({ name }) => options.only.length === 0 || options.only.includes(name)
+    );
 
   if (filteredMethods.length === 0) {
     throw new Error("No methods to test");
   }
 
+
   const exampleCalls: ExampleCall[] = [];
 
-  const servers: Servers = (options.openrpcDocument.servers || [{ url: "http://localhost:3333" }]);
+  const servers: Servers = options.openrpcDocument.servers || [
+    { url: "http://localhost:3333" },
+  ];
 
   servers.forEach(({ url }) => {
     filteredMethods.forEach((method) => {
       if (method.examples === undefined || method.examples.length === 0) {
         for (let i = 0; i < 10; i++) {
           const p = getFakeParams(method.params);
           // handle object or array case
-          const params = method.paramStructure === "by-name" ? paramsToObj(p, method.params as ContentDescriptorObject[]) : p;
+          const params =
+            method.paramStructure === "by-name"
+              ? paramsToObj(p, method.params as ContentDescriptorObject[])
+              : p;
           exampleCalls.push({
+            title: method.name + " > json-schema-faker params and expect result schema to match [" + i + "]",
             methodName: method.name,
             params,
             url,
-            resultSchema: (method.result as ContentDescriptorObject).schema
+            resultSchema: (method.result as ContentDescriptorObject).schema,
           });
         }
         return;
       }
 
       (method.examples as ExamplePairingObject[]).forEach((ex) => {
         const p = (ex.params as ExampleObject[]).map((e) => e.value);
-        const params = method.paramStructure === "by-name" ? paramsToObj(p, method.params as ContentDescriptorObject[]) : p;
+        const params =
+          method.paramStructure === "by-name"
+            ? paramsToObj(p, method.params as ContentDescriptorObject[])
+            : p;
         exampleCalls.push({
+          title: method.name + " > example params and expect result to match: " + ex.name,
           methodName: method.name,
           params,
           url,
@@ -87,13 +105,22 @@ export default async (options: IOptions) => {
     });
   });
 
+  options.reporter.onBegin(options, exampleCalls);
   for (const exampleCall of exampleCalls) {
+    options.reporter.onTestBegin(options, exampleCall);
     try {
-      const callResult = await options.transport(exampleCall.url, exampleCall.methodName, exampleCall.params);
+      const callResult = await options.transport(
+        exampleCall.url,
+        exampleCall.methodName,
+        exampleCall.params
+      );
       exampleCall.result = callResult.result;
 
       if (exampleCall.expectedResult) {
-        exampleCall.valid = isEqual(exampleCall.expectedResult, exampleCall.result);
+        exampleCall.valid = isEqual(
+          exampleCall.expectedResult,
+          exampleCall.result
+        );
       } else {
         const ajv = new Ajv();
         ajv.validate(exampleCall.resultSchema, exampleCall.result);
@@ -108,7 +135,8 @@ export default async (options: IOptions) => {
       exampleCall.valid = false;
       exampleCall.requestError = e;
     }
+    options.reporter.onTestEnd(options, exampleCall);
   }
 
-  return options.reporter(exampleCalls, options.openrpcDocument);
+  return options.reporter.onEnd(options, exampleCalls);
 };