fix: refactor exampleCall name to Call

Author: shanejonas

src/coverage.test.ts

@@ -1,4 +1,4 @@
-import coverage, { ExampleCall, IOptions } from "./coverage";
+import coverage, { Call, IOptions } from "./coverage";
 import { OpenrpcDocument } from "@open-rpc/meta-schema";
 import EmptyReporter from "./reporters/emptyReporter";
 import ConsoleReporter from "./reporters/console";
@@ -131,23 +131,23 @@ describe("coverage", () => {
         only: ["foo", "bar"],
       });
       class MyCustomRule implements Rule {
-        getExampleCalls(openrpcDocument: OpenrpcDocument, method: any) {
+        getCalls(openrpcDocument: OpenrpcDocument, method: any) {
           return [];
         }
-        async validateExampleCall(exampleCall: ExampleCall) {
-          return exampleCall;
+        async validateCall(Call: Call) {
+          return Call;
         }
       }
       const myCustomRule = new MyCustomRule();
 
-      const getExampleCallsSpy = jest.spyOn(exampleRule, "getExampleCalls");
-      const getExampleCallsCustomSpy = jest.spyOn(
+      const getCallsSpy = jest.spyOn(exampleRule, "getCalls");
+      const getCallsCustomSpy = jest.spyOn(
         myCustomRule,
-        "getExampleCalls"
+        "getCalls"
       );
-      const getExampleCallsJsonSchemaFakerSpy = jest.spyOn(
+      const getCallsJsonSchemaFakerSpy = jest.spyOn(
         jsonSchemaFakerRule,
-        "getExampleCalls"
+        "getCalls"
       );
       const options = {
         reporters: [reporter],
@@ -158,9 +158,9 @@ describe("coverage", () => {
         only: [],
       };
       await coverage(options);
-      expect(getExampleCallsSpy).toHaveBeenCalled();
-      expect(getExampleCallsCustomSpy).toHaveBeenCalled();
-      expect(getExampleCallsJsonSchemaFakerSpy).toHaveBeenCalled();
+      expect(getCallsSpy).toHaveBeenCalled();
+      expect(getCallsCustomSpy).toHaveBeenCalled();
+      expect(getCallsJsonSchemaFakerSpy).toHaveBeenCalled();
     });
   });
   describe("reporter", () => {
@@ -187,8 +187,8 @@ describe("coverage", () => {
         onBegin() {}
         onTestBegin() {}
         onTestEnd() {}
-        onEnd(options: IOptions, exampleCalls: ExampleCall[]) {
-          expect(exampleCalls[0].result).toBe(true);
+        onEnd(options: IOptions, Calls: Call[]) {
+          expect(Calls[0].result).toBe(true);
           done();
         }
       }

src/coverage.ts

@@ -17,7 +17,7 @@ export interface IOptions {
   reporters: Reporter[];
 }
 
-export interface ExampleCall {
+export interface Call {
   methodName: string;
   params: any[];
   url: string;
@@ -47,75 +47,75 @@ export default async (options: IOptions) => {
     throw new Error("No methods to test");
   }
 
-  let exampleCalls: ExampleCall[] = [];
+  let calls: Call[] = [];
 
   let rules: Rule[] = [new JsonSchemaFakerRule(), new ExamplesRule()];
   if (options.rules && options.rules.length > 0) {
     rules = options.rules;
   }
 
   for (const reporter of options.reporters) {
-    reporter.onBegin(options, exampleCalls);
+    reporter.onBegin(options, calls);
   }
 
   for (const rule of rules) {
     await Promise.resolve(rule.onBegin?.(options));
   }
 
-  // getExampleCalls could be async or sync
-  const exampleCallsPromises = await Promise.all(filteredMethods.map((method) =>
+  // getCalls could be async or sync
+  const callsPromises = await Promise.all(filteredMethods.map((method) =>
     Promise.all(
       rules.map(async (rule) => {
-        const calls = await Promise.resolve(rule.getExampleCalls(options.openrpcDocument, method))
-        calls.forEach((call) => {
+        const _calls = await Promise.resolve(rule.getCalls(options.openrpcDocument, method))
+        _calls.forEach((call) => {
           // this adds the rule after the fact, it's a bit of a hack
           call.rule = rule;
         });
-        return calls;
+        return _calls;
       }
       )
     )
   ));
-  exampleCalls.push(...exampleCallsPromises.flat().flat());
+  calls.push(...callsPromises.flat().flat());
 
-  for (const exampleCall of exampleCalls) {
+  for (const call of calls) {
     for (const reporter of options.reporters) {
-      reporter.onTestBegin(options, exampleCall);
+      reporter.onTestBegin(options, call);
     }
     // lifecycle methods could be async or sync
-    await Promise.resolve(exampleCall.rule?.beforeRequest?.(options, exampleCall));
+    await Promise.resolve(call.rule?.beforeRequest?.(options, call));
 
     // transport is async but the await needs to happen later
     // so that afterRequest is run immediately after the request is made
     const callResultPromise = options.transport(
-      exampleCall.url,
-      exampleCall.methodName,
-      exampleCall.params
+      call.url,
+      call.methodName,
+      call.params
     );
-    await Promise.resolve(exampleCall.rule?.afterRequest?.(options, exampleCall));
+    await Promise.resolve(call.rule?.afterRequest?.(options, call));
     try {
       const callResult = await callResultPromise;
-      exampleCall.result = callResult.result;
-      exampleCall.error = callResult.error;
+      call.result = callResult.result;
+      call.error = callResult.error;
     } catch (e) {
-      exampleCall.valid = false;
-      exampleCall.requestError = e;
+      call.valid = false;
+      call.requestError = e;
     }
-    if (exampleCall.requestError === undefined) {
-      await Promise.resolve(exampleCall.rule?.validateExampleCall(exampleCall));
+    if (call.requestError === undefined) {
+      await Promise.resolve(call.rule?.validateCall(call));
     }
-    await Promise.resolve(exampleCall.rule?.afterResponse?.(options, exampleCall));
+    await Promise.resolve(call.rule?.afterResponse?.(options, call));
     for (const reporter of options.reporters) {
-      reporter.onTestEnd(options, exampleCall);
+      reporter.onTestEnd(options, call);
     }
   }
 
   for (const rule of rules) {
-    await Promise.resolve(rule.onEnd?.(options, exampleCalls));
+    await Promise.resolve(rule.onEnd?.(options, calls));
   }
 
   for (const reporter of options.reporters) {
-    reporter.onEnd(options, exampleCalls);
+    reporter.onEnd(options, calls);
   }
-  return exampleCalls;
+  return calls;
 };

src/reporters/console.ts

@@ -2,11 +2,11 @@ import colors from "colors";
 import {
   JSONSchemaObject,
 } from "@open-rpc/meta-schema";
-import {ExampleCall, IOptions} from "../coverage";
+import {Call, IOptions} from "../coverage";
 import _ from "lodash";
 import Reporter from "./reporter";
 
-const getExpectedString = (ex: ExampleCall) => {
+const getExpectedString = (ex: Call) => {
   let resSchemaID;
   if (ex.resultSchema === true) { resSchemaID = "true"; }
   else if (ex.resultSchema === false) { resSchemaID = "false"; }
@@ -20,26 +20,26 @@ const getExpectedString = (ex: ExampleCall) => {
 
 class ConsoleReporter implements Reporter {
 
-  onBegin(options: IOptions, exampleCalls: ExampleCall[]) {}
-  onTestBegin(options: IOptions, exampleCall: ExampleCall) {}
-  onTestEnd(options: IOptions, exampleCall: ExampleCall) {}
-  onEnd(options: IOptions, exampleCalls: ExampleCall[]) {
+  onBegin(options: IOptions, Calls: Call[]) {}
+  onTestBegin(options: IOptions, Call: Call) {}
+  onTestEnd(options: IOptions, Call: Call) {}
+  onEnd(options: IOptions, Calls: Call[]) {
     const metrics = {
       success: 0,
       error: 0
     };
-    _.chain(exampleCalls)
+    _.chain(Calls)
       .groupBy("methodName")
-      .forEach((exampleCallsForMethod, methodName) => {
-        const hasInvalid = exampleCallsForMethod.reduce((m, {valid}) => m || !valid, false);
+      .forEach((CallsForMethod, methodName) => {
+        const hasInvalid = CallsForMethod.reduce((m, {valid}) => m || !valid, false);
 
         if (hasInvalid) {
           console.log(colors.bgRed(colors.yellow(methodName + ":")));
         } else {
           console.log(colors.bgGreen(colors.black(methodName + ":")));
         }
 
-        exampleCallsForMethod.forEach((ex) => {
+        CallsForMethod.forEach((ex) => {
           if (ex.valid) {
             metrics.success++;
             const expected = getExpectedString(ex);

src/reporters/emptyReporter.ts

@@ -1,23 +1,23 @@
-import { ExampleCall, IOptions } from '../coverage';
+import { Call, IOptions } from '../coverage';
 import Reporter from './reporter';
 
 class EmptyReporter implements Reporter {
-  onBegin(options: IOptions, exampleCalls: ExampleCall[]) {
-    console.log(`Starting the run with ${exampleCalls.length} tests`);
+  onBegin(options: IOptions, Calls: Call[]) {
+    console.log(`Starting the run with ${Calls.length} tests`);
   }
 
-  onTestBegin(options: IOptions, exampleCall: ExampleCall) {
-    console.log(`started test ${exampleCall.title}`);
+  onTestBegin(options: IOptions, Call: Call) {
+    console.log(`started test ${Call.title}`);
   }
 
-  onTestEnd(options: IOptions, exampleCall: ExampleCall) {
-    console.log(`Finished test ${exampleCall.title}: ${exampleCall.valid ? "success" : "error"}`);
+  onTestEnd(options: IOptions, Call: Call) {
+    console.log(`Finished test ${Call.title}: ${Call.valid ? "success" : "error"}`);
   }
 
-  onEnd(options: IOptions, exampleCalls: ExampleCall[]) {
-    const failed = exampleCalls.filter((ec) => !ec.valid);
-    const passed = exampleCalls.filter((ec) => ec.valid);
-    console.log(`Finished the running ${exampleCalls.length} tests: ${failed.length} failed, ${passed.length} passed`);
+  onEnd(options: IOptions, Calls: Call[]) {
+    const failed = Calls.filter((ec) => !ec.valid);
+    const passed = Calls.filter((ec) => ec.valid);
+    console.log(`Finished the running ${Calls.length} tests: ${failed.length} failed, ${passed.length} passed`);
   }
 }
 

src/reporters/json.ts

@@ -1,18 +1,18 @@
-import { ExampleCall, IOptions } from '../coverage';
+import { Call, IOptions } from '../coverage';
 import Reporter from './reporter';
 
 class JsonReporter implements Reporter {
-  onBegin(options: IOptions, exampleCalls: ExampleCall[]) {}
-  onTestBegin(options: IOptions, exampleCall: ExampleCall) {}
+  onBegin(options: IOptions, Calls: Call[]) {}
+  onTestBegin(options: IOptions, Call: Call) {}
 
-  onTestEnd(options: IOptions, exampleCall: ExampleCall) {}
+  onTestEnd(options: IOptions, Call: Call) {}
 
-  onEnd(options: IOptions, exampleCalls: ExampleCall[]) {
-    const failed = exampleCalls.filter((ec) => !ec.valid);
+  onEnd(options: IOptions, Calls: Call[]) {
+    const failed = Calls.filter((ec) => !ec.valid);
 
-    const passed = exampleCalls.filter((ec) => ec.valid);
+    const passed = Calls.filter((ec) => ec.valid);
 
-    console.log(JSON.stringify(exampleCalls, undefined, 4));
+    console.log(JSON.stringify(Calls, undefined, 4));
   }
 }
 

src/reporters/reporter.ts

@@ -1,10 +1,10 @@
-import { ExampleCall, IOptions } from "../coverage";
+import { Call, IOptions } from "../coverage";
 
 interface Reporter {
-  onBegin(options: IOptions, exampleCalls: ExampleCall[]): void;
-  onTestBegin(options: IOptions, exampleCall: ExampleCall): void;
-  onTestEnd(options: IOptions, exampleCall: ExampleCall): void;
-  onEnd(options: IOptions, exampleCalls: ExampleCall[]): void;
+  onBegin(options: IOptions, Calls: Call[]): void;
+  onTestBegin(options: IOptions, Call: Call): void;
+  onTestEnd(options: IOptions, Call: Call): void;
+  onEnd(options: IOptions, Calls: Call[]): void;
 }
 
 export default Reporter;

src/rules/examples-rule.ts

@@ -1,5 +1,5 @@
 import { ContentDescriptorObject, ExampleObject, ExamplePairingObject, MethodObject, OpenrpcDocument } from "@open-rpc/meta-schema";
-import { ExampleCall, IOptions } from "../coverage";
+import { Call, IOptions } from "../coverage";
 import { isEqual } from "lodash";
 import Rule from "./rule";
 import paramsToObj from "../utils/params-to-obj";
@@ -16,22 +16,22 @@ class ExamplesRule implements Rule {
     this.skip = options?.skip;
     this.only = options?.only;
   }
-  getExampleCalls(openrpcDocument: OpenrpcDocument, method: MethodObject): ExampleCall[] {
+  getCalls(openrpcDocument: OpenrpcDocument, method: MethodObject): Call[] {
     if (this.skip && this.skip.includes(method.name)) {
       return [];
     }
     if (this.only && this.only.length > 0 && !this.only.includes(method.name)) {
       return [];
     }
-    const exampleCalls: ExampleCall[] = [];
+    const calls: Call[] = [];
     if (method.examples) {
       (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;
-        exampleCalls.push({
+        calls.push({
           title:
             method.name +
             " > example params and expect result to match: " +
@@ -44,16 +44,16 @@ class ExamplesRule implements Rule {
         });
       });
     }
-    return exampleCalls;
+    return calls;
   }
-  validateExampleCall(exampleCall: ExampleCall): ExampleCall {
-    if (exampleCall.expectedResult) {
-      exampleCall.valid = isEqual(
-        exampleCall.expectedResult,
-        exampleCall.result
+  validateCall(call: Call): Call {
+    if (call.expectedResult) {
+      call.valid = isEqual(
+        call.expectedResult,
+        call.result
       );
     }
-    return exampleCall;
+    return call;
   }
 }
 

src/rules/json-schema-faker-rule.test.ts

@@ -30,14 +30,14 @@ describe("JsonSchemaFakerRule", () => {
         },
       ],
     } as any;
-    const calls = rule.getExampleCalls(openrpcDocument, openrpcDocument.methods[0]);
+    const calls = rule.getCalls(openrpcDocument, openrpcDocument.methods[0]);
     calls[0].result = true;
-    const result = rule.validateExampleCall(calls[0]);
+    const result = rule.validateCall(calls[0]);
     expect(result.valid).toBe(true);
   });
   it("should handle errors within ajv when validating", () => {
     const rule = new JsonSchemaFakerRule();
-    const exampleCall = {
+    const Call = {
       title: 'test call',
       methodName: "foo",
       params: [],
@@ -47,7 +47,7 @@ describe("JsonSchemaFakerRule", () => {
         unevaluatedProperties: false,
       },
     };
-    const result = rule.validateExampleCall(exampleCall);
+    const result = rule.validateCall(Call);
     expect(result.valid).toBe(false);
     expect(result.reason).toMatch('unknown keyword: "unevaluatedProperties"');
   });