[FIX] Improve test suite

Author: Fletcher91

__mocks__/solid-auth-client.js

@@ -0,0 +1,7 @@
+/**
+ * The `rdflib` fetcher module doesn't use spec compliant implementations provided by the
+ * ecosystem.. so we need to do some overrides again..
+ * @module SolidAuthClient
+ */
+
+module.exports = undefined;

jest-plugins.js

@@ -1,10 +1,3 @@
 // Write jest like rspec tests
 // https://github.com/negativetwelve/jest-plugins/tree/master/packages/jest-plugins
 global.fetch = require('jest-fetch-mock');
-
-require('jest-plugins')([
-  'jest-plugin-action',
-  'jest-plugin-context',
-  'jest-plugin-its',
-  'jest-plugin-set',
-]);

package.json

@@ -43,27 +43,29 @@
     "http-status-codes": ">= 1.x",
     "jest": "^23.6.0",
     "jest-fetch-mock": "^1.6.6",
-    "jest-plugins": "^2.9.0",
-    "jest-plugins-recommended": "^2.9.0",
     "rdflib": ">= 0.17.x",
     "rollup": "^0.66.2",
     "rollup-plugin-commonjs": "^9.1.8",
     "rollup-plugin-node-resolve": "^3.4.0",
     "rollup-plugin-sourcemaps": "^0.4.2",
     "rollup-plugin-typescript2": "^0.17.0",
-    "ts-jest": "=23.1.4",
+    "ts-jest": "^23.10.2",
     "tslint": "^5.11.0",
     "typedoc": "^0.12.0",
     "typescript": "^3.0.3"
   },
   "jest": {
     "automock": false,
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "src/utilities/DisjointSet.ts"
+    ],
     "coverageThreshold": {
       "global": {
-        "branches": 64,
-        "functions": 76,
-        "lines": 76,
-        "statements": 75
+        "branches": 65,
+        "functions": 77,
+        "lines": 79,
+        "statements": 79
       }
     },
     "setupTestFrameworkScriptFile": "./jest-plugins",

rollup.config.js

@@ -11,6 +11,7 @@ export default {
         "ml-disjoint-set",
         "node-fetch",
         "rdflib",
+        "solid-auth-client",
     ],
     input: "src/link-lib.ts",
     output: [

src/__tests__/LinkedRenderStore.spec.ts

@@ -200,7 +200,6 @@ describe("LinkedRenderStore", () => {
         store.store.addStatements(actionStatements);
 
         it("sends the described request", async () => {
-            fetch.mockResponseOnce("", {});
             const sub = jest.fn();
             store.lrs.subscribe({ callback: sub, onlySubjects: false });
 

src/processor/RequestInitGenerator.ts

@@ -1,10 +1,17 @@
+export interface RequestInitGeneratorOpts {
+    credentials: string;
+    csrfFieldName: string;
+    mode: string;
+    xRequestedWith: string;
+}
+
 export class RequestInitGenerator {
     public readonly credentials: string;
     public readonly csrfFieldName: string;
     public readonly mode: string;
     public readonly xRequestedWith: string;
 
-    constructor(opts = {
+    constructor(opts: RequestInitGeneratorOpts = {
         credentials: "include",
         csrfFieldName: "csrf-token",
         mode: "same-origin",

src/processor/__tests__/ProcessorError.spec.ts

@@ -3,22 +3,21 @@ import "jest";
 
 import { ProcessorError } from "../ProcessorError";
 
-describe("ProcessorError", () => {
-    set("msg", () => undefined);
-    set("response", () => undefined);
-    subject(() => new ProcessorError(msg, response));
+const getMessage = (msg: string, response?: Response): ProcessorError => new ProcessorError(msg, response);
 
-    its("message", () => isExpected.toEqual(""));
+const r = new Response();
 
+describe("ProcessorError", () => {
     describe("with message", () => {
-        set("msg", () => "info");
-
-        its("message", () => isExpected.toEqual("info"));
+        it("has a message", () => {
+            expect(getMessage("info", undefined)).toHaveProperty("message", "info");
+            expect(getMessage("info", undefined)).not.toHaveProperty("response", r);
+        });
     });
 
     describe("with response", () => {
-        set("response", () => "info");
-
-        its("response", () => isExpected.toEqual("info"));
+        it("has a message", () => {
+            expect(getMessage("info", r)).toHaveProperty("response", r);
+        });
     });
 });

src/processor/__tests__/RequestInitGenerator.spec.ts

@@ -1,44 +1,51 @@
 /* @globals set, generator, init */
 import "jest";
 
-import { RequestInitGenerator } from "../RequestInitGenerator";
+import { RequestInitGenerator, RequestInitGeneratorOpts } from "../RequestInitGenerator";
 
-describe("RequestInitGenerator", () => {
-    set("opts", () => undefined);
-    set("generator", () => new RequestInitGenerator(opts));
-    subject(() => generator);
-    set("method", () => undefined);
-    set("accept", () => undefined);
+const getGenerator = (opts?: Partial<RequestInitGeneratorOpts>): RequestInitGenerator =>
+    new RequestInitGenerator(opts as RequestInitGeneratorOpts);
 
+describe("RequestInitGenerator", () => {
     describe("#constructor", () => {
-        set("opts", () => ({ csrfFieldName: "custom-element ", mode: "no-cors" }));
-
-        its("mode", () => isExpected.toEqual("no-cors"));
+        it("sets the mode", () => {
+            const subject = getGenerator({ csrfFieldName: "custom-element ", mode: "no-cors" });
+            expect(subject).toHaveProperty("mode", "no-cors");
+        });
     });
 
     describe("#authenticityHeader", () => {
-        subject(() => generator.authenticityHeader());
+        it("has the correct X-Requested-With header", () => {
+            expect(getGenerator()).toHaveProperty("xRequestedWith", "XMLHttpRequest");
+        });
 
-        its("X-Requested-With", () => isExpected.toEqual("XMLHttpRequest"));
-        its("X-CSRF-Token", () => isExpected.toEqual(""));
+        it("has no X-CSRF-Token header", () => {
+            expect(getGenerator()).not.toHaveProperty("X-CSRF-Token");
+        });
     });
 
     describe("#generate", () => {
-        subject(() => generator.generate(method, accept));
-
-        its("credentials", () => isExpected.toEqual("include"));
-        its("method", () => isExpected.toEqual("GET"));
-        its("mode", () => isExpected.toEqual("same-origin"));
-
-        its("headers.Accept", () => isExpected.toEqual("text/turtle"));
-        its("headers.X-Requested-With", () => isExpected.toEqual("XMLHttpRequest"));
+        describe("with empty parameters", () => {
+            const subject = getGenerator().generate(undefined, undefined);
+
+            it("sets the credentials option", () => expect(subject).toHaveProperty("credentials", "include"));
+            it("sets the method option", () => expect(subject).toHaveProperty("method", "GET"));
+            it("sets the mode option", () => expect(subject).toHaveProperty("mode", "same-origin"));
+
+            const headers = subject.headers;
+            it("sets the Accept header", () => expect(headers).toHaveProperty("Accept", "text/turtle"));
+            it("sets the X-Requested-With header", () => {
+                expect(headers).toHaveProperty("X-Requested-With", "XMLHttpRequest");
+            });
+        });
 
         describe("with arguments", () => {
-            set("method", () => "POST");
-            set("accept", () => "application/n-quads");
+            const subject = getGenerator().generate("POST", "application/n-quads");
+
+            it("sets the method option", () => expect(subject).toHaveProperty("method", "POST"));
 
-            its("method", () => isExpected.toEqual("POST"));
-            its("headers.Accept", () => isExpected.toEqual("application/n-quads"));
+            const headers = subject.headers;
+            it("sets the Accept header", () => expect(headers).toHaveProperty("Accept", "application/n-quads"));
         });
     });
 });

src/utilities/__tests__/responses.spec.ts

@@ -92,6 +92,7 @@ describe("responses", () => {
                     "Content-Type": "text/turtle",
                 },
             });
+            // @ts-ignore
             response.headers = {
                 get: (header: string): string | undefined => {
                     if (header === "Content-Type") {