fix: add tslint + fix linting

Author: shanejonas

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 build
 *openrpc.json
+coverage

package-lock.json

@@ -3,7 +3,8 @@
   "version": "0.0.0-development",
   "description": "Test your OpenRPC Document against an API.",
   "scripts": {
-    "test": "jest",
+    "lint": "tslint --fix -p .",
+    "test": "jest --coverage && npm run lint",
     "build": "tsc"
   },
   "bin": {
@@ -31,6 +32,7 @@
     "@types/node": "^11.13.4",
     "jest": "^24.7.1",
     "ts-jest": "^24.0.2",
+    "tslint": "^5.16.0",
     "typescript": "^3.4.3"
   }
 }

package.json

@@ -5,50 +5,71 @@ const mockSchema = {
   openrpc: "1.0.0",
   info: {
     title: "my api",
-    version: "0.0.0-development"
+    version: "0.0.0-development",
   },
   servers: [
     {
-      name: 'my api',
-      url: 'http://localhost:3333'
-    }
+      name: "my api",
+      url: "http://localhost:3333",
+    },
   ],
   methods: [
     {
-      name: 'foo',
+      name: "foo",
       params: [],
       result: {
-        name: 'fooResult',
+        name: "fooResult",
         schema: {
-          type: 'boolean'
-        }
-      }
-    }
-  ]
-} as OpenRPC
+          type: "boolean",
+        },
+      },
+    },
+  ],
+} as OpenRPC;
 
-describe('coverage', () => {
-  it('can call the reporter', (done) => {
-    const reporter = () => done()
-    const transport = () => Promise.resolve({})
-    coverage({
-      reporter,
-      transport,
-      schema: mockSchema,
-      skipMethods: []
-    })
-  })
-  it('can call the transport', (done) => {
-    const reporter = () => {}
-    const transport = () => {
-      done();
-      return Promise.resolve({});
-    }
-    coverage({
-      reporter,
-      transport,
-      schema: mockSchema,
-      skipMethods: []
-    })
-  })
-});
+describe("coverage", () => {
+  describe("reporter", () => {
+    it("can call the reporter", (done) => {
+      const reporter = (callResults: any[], schema: OpenRPC) => {
+        done();
+      };
+      const transport = () => Promise.resolve();
+      coverage({
+        reporter,
+        transport,
+        schema: mockSchema,
+        skipMethods: [],
+      });
+    });
+    it("can call the reporter with the results", (done) => {
+      const reporter = (callResults: any[], schema: OpenRPC) => {
+        expect(callResults[0].result.foo).toBe("bar");
+        done();
+      };
+      const transport = (url: string, method: string, params: any[]) => Promise.resolve({ result: { foo: "bar" } });
+      coverage({
+        reporter,
+        transport,
+        schema: mockSchema,
+        skipMethods: [],
+      });
+    });
+  });
+  describe("transport", () => {
+    it("can call the transport", (done) => {
+      const reporter = () => {
+        // empty reporter
+      };
+      const transport = () => {
+        done();
+        return Promise.resolve({});
+      };
+      coverage({
+        reporter,
+        transport,
+        schema: mockSchema,
+        skipMethods: [],
+      });
+    });
+  });
+});

src/coverage.test.ts

@@ -1,14 +1,12 @@
 import { OpenRPC } from "@open-rpc/meta-schema";
-const refParser = require('json-schema-ref-parser');
-const jsf = require('json-schema-faker');
+const jsf = require("json-schema-faker"); // tslint:disable-line
 
 const getParams = async (params: any[]) => {
   const promises = params.map((p) => {
     return jsf.generate(p.schema);
-  })
+  });
   return Promise.all(promises);
-}
-
+};
 
 interface IOptions {
   schema: OpenRPC;
@@ -27,19 +25,19 @@ export default async (options: IOptions) => {
     const urls = (options.schema.servers || []).map((u) => {
       // TODO: support server variables
       return u.url;
-    })
+    });
     return Promise.all(urls.map((url) => {
       return options.transport(url, method.name, params)
         .then((r: any) => {
           results.push({
             method: method.name,
             params,
-            ...r
-          })
+            ...r,
+          });
         });
-    }))
+    }));
   });
 
   await Promise.all(promises);
   options.reporter(results, options.schema);
-}
+};

src/coverage.ts

@@ -1,30 +1,30 @@
-import consoleReporter from './reporters/console';
-import coverage from './coverage';
-import HTTPTransport from './transports/HTTPTransport';
-import jsonReporter from './reporters/json';
-import { OpenRPC } from '@open-rpc/meta-schema';
+import consoleReporter from "./reporters/console";
+import coverage from "./coverage";
+import HTTPTransport from "./transports/HTTPTransport";
+import jsonReporter from "./reporters/json";
+import { OpenRPC } from "@open-rpc/meta-schema";
 
 const reporters = {
   console: consoleReporter,
-  json: jsonReporter
-}
+  json: jsonReporter,
+};
 
 const transports = {
-  http: HTTPTransport
-}
+  http: HTTPTransport,
+};
 
 interface IOptions {
   schema: OpenRPC;
   skipMethods?: string[];
-  reporter: 'console' | 'json';
-  transport: 'http';
+  reporter: "console" | "json";
+  transport: "http";
 }
 
 export default async (options: IOptions) => {
   return coverage({
-    reporter: reporters[options.reporter || 'console'],
+    reporter: reporters[options.reporter || "console"],
     schema: options.schema,
     skipMethods: options.skipMethods || [],
-    transport: transports[options.transport || 'http']
+    transport: transports[options.transport || "http"],
   });
-}
+};

src/index.ts

@@ -1,44 +1,53 @@
-import colors from 'colors';
+import colors from "colors";
 import Ajv, { ErrorObject, Ajv as IAjv } from "ajv";
-import { OpenRPC, MethodObject, ContentDescriptorObject } from '@open-rpc/meta-schema';
+import { OpenRPC, MethodObject, ContentDescriptorObject } from "@open-rpc/meta-schema";
 
 export default (callResults: any[], schema: OpenRPC) => {
   const ajv = new Ajv();
   const metrics = {
     errors: 0,
-    success: 0
-  }
-  
-  callResults.forEach((call) => {
+    success: 0,
+  };
+
+  callResults.forEach(async (call) => {
     if (call.error) {
       metrics.errors++;
-      console.log(colors.red.underline('JSON-RPC Request Error: '), colors.cyan(call.method));
+      console.log(colors.red.underline("JSON-RPC Request Error: "), colors.cyan(call.method));
       console.log(call.error);
       console.log(call.params);
     } else {
 
-      const methodSchema = schema.methods.find((m) => m.name === call.method);
+      const methodSchema = schema.methods.find((m: MethodObject) => m.name === call.method);
       if (!methodSchema) {
         return console.log(`Error: no result defined for ${call.method}`);
       }
+      const result = methodSchema.result as ContentDescriptorObject;
+
+      let resultSchema: any = result.schema;
+
+      if (result.oneOf) {
+        resultSchema = {
+          oneOf: result.oneOf.map((cd: ContentDescriptorObject) => cd.schema),
+        };
+      }
 
-      const isValid = ajv.validate((methodSchema.result as ContentDescriptorObject).schema, call.result);
+      ajv.validate(resultSchema, call.result);
       const errors = ajv.errors as ErrorObject[];
 
-      if (isValid) {
+      if (!errors || errors.length === 0) {
         metrics.success++;
-        console.log(colors.green('Success: '), call.method)
+        console.log(colors.green("Success: "), call.method);
       } else {
-        console.log(colors.red.underline('Result Validation Error: '), colors.cyan(call.method));
+        console.log(colors.red.underline("Result Validation Error: "), colors.cyan(call.method));
         console.log(call);
         console.log(errors);
         console.log(methodSchema);
       }
 
     }
-  })
-  console.log('==========');
-  console.log('Success: ', colors.green(metrics.success.toString()));
-  console.log('Errors: ', colors.red(metrics.errors.toString()));
-  console.log('==========');
+  });
+  console.log("==========");
+  console.log("Success: ", colors.green(metrics.success.toString()));
+  console.log("Errors: ", colors.red(metrics.errors.toString()));
+  console.log("==========");
 };

src/reporters/console.ts

@@ -2,4 +2,4 @@ import { OpenRPC } from "@open-rpc/meta-schema";
 
 export default (callResults: any[], schema: OpenRPC) => {
   console.log(JSON.stringify(callResults, undefined, 4));
-}
+};

src/reporters/json.ts

@@ -1,4 +1,4 @@
-import fetch from 'isomorphic-fetch';
+import fetch from "isomorphic-fetch";
 let id = 1;
 
 export default (url: string, method: string, params: any[]) => {
@@ -9,9 +9,9 @@ export default (url: string, method: string, params: any[]) => {
       jsonrpc: "2.0",
       id: id++,
       method,
-      params
-    })
+      params,
+    }),
   }).then((r: any) => {
     return r.json();
-  })
-};
+  });
+};