Fix jest typescript code coverage issues

Finally, it really helps if the output doesn't refer to transpiled lines
which aren't stored on disk.

Author: Fletcher91

babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', {targets: {node: 'current'}}],
+    '@babel/preset-typescript',
+  ],
+};

package.json

@@ -36,7 +36,7 @@
   },
   "peerDependencies": {
     "@ontologies/as": ">=1.0.1",
-    "@ontologies/core": ">=2.0.0-7",
+    "@ontologies/core": ">=2.0.0-9",
     "@ontologies/ld": ">=1.0.0",
     "@ontologies/schema": ">=1.0.0",
     "@ontologies/shacl": ">=1.0.0",
@@ -47,7 +47,7 @@
   "devDependencies": {
     "@ontola/memoized-hash-factory": "^2.0.0",
     "@ontologies/as": "^1.0.1",
-    "@ontologies/core": "2.0.0-7",
+    "@ontologies/core": "2.0.0-9",
     "@ontologies/dcterms": "^1.0.0",
     "@ontologies/ld": "^1.0.0",
     "@ontologies/owl": "^1.0.0",
@@ -62,21 +62,26 @@
     "@pika/plugin-bundle-web": "^0.8.1",
     "@pika/plugin-ts-standard-pkg": "^0.8.1",
     "@rdfdev/iri": "^1.0.0",
-    "@types/jest": "^24.0.25",
+    "@types/jest": "^25.1.4",
     "@types/murmurhash-js": "^1.0.3",
     "@types/node": "^12.11.2",
     "core-js": "^3.6.3",
     "esdoc": "^1.1.0",
     "gh-pages": "^2.2.0",
     "http-status-codes": ">= 1.x",
-    "jest": "^24.9.0",
-    "jest-fetch-mock": "^2.1.2",
+    "jest": "^25.2.4",
+    "jest-fetch-mock": "^3.0.3",
     "n-quads-parser": "^2.1.0-2",
     "ts-jest": "^24.3.0",
     "tslint": "^5.20.1",
     "typedoc": "^0.16.2",
     "typescript": "^3.7.4"
   },
+  "babel": {
+    "presets": [
+      "@babel/preset-typescript"
+    ]
+  },
   "jest": {
     "automock": false,
     "coveragePathIgnorePatterns": [
@@ -91,7 +96,6 @@
         "statements": 85
       }
     },
-    "preset": "ts-jest",
     "setupFiles": [
       "core-js",
       "./jest-plugins"
@@ -103,9 +107,6 @@
       "js",
       "ts"
     ],
-    "testURL": "http://example.org/resources/5",
-    "transform": {
-      "\\.ts$": "ts-jest"
-    }
+    "testURL": "http://example.org/resources/5"
   }
 }

src/LinkedRenderStore.ts

@@ -133,7 +133,7 @@ export class LinkedRenderStore<T> implements Dispatcher {
 
     public get dispatch(): MiddlewareActionHandler {
         if (typeof this._dispatch === "undefined") {
-            throw new Error("Invariant: cannot call `dispatch` before initialization is complete");
+            throw new Error("Invariant: cannot call `dispatch` before initialization is complete, see createStore");
         }
 
         return this._dispatch;

src/__tests__/LinkedRenderStore.spec.ts

@@ -5,12 +5,49 @@ import rdfFactory, { Quad } from "@ontologies/core";
 import owl from "@ontologies/owl";
 import rdf from "@ontologies/rdf";
 import schema from "@ontologies/schema";
+import { LinkedRenderStore } from "../LinkedRenderStore";
 
 import { getBasicStore } from "../testUtilities";
 
 import { example } from "./LinkedRenderStore/fixtures";
 
 describe("LinkedRenderStore", () => {
+    describe("actions", () => {
+        it("allows overriding dispach", () => {
+            const dispatch = jest.fn();
+            const lrs = new LinkedRenderStore({
+                dispatch,
+            });
+
+            expect(lrs.dispatch).toStrictEqual(dispatch);
+        });
+
+        it ("prevents premature executions", () => {
+            const lrs = new LinkedRenderStore();
+
+            expect(lrs.exec(rdf.type)).rejects.toBeInstanceOf(Error);
+        });
+    });
+
+    describe("data fetching", () => {
+        it("allows data reload", async () => {
+            const apiGetEntity = jest.fn();
+            const iri = rdf.type;
+            // @ts-ignore
+            const store = getBasicStore({ api: { getEntity: apiGetEntity } });
+
+            await store.lrs.getEntity(iri, { reload: true });
+
+            expect(apiGetEntity).toHaveBeenCalledWith(
+                iri,
+                {
+                    clearPreviousData: true,
+                    force: true,
+                },
+            );
+        });
+    });
+
     describe("reasons correctly", () => {
         it("combines sameAs declarations", async () => {
             const store = getBasicStore();

src/__tests__/LinkedRenderStore/delta.spec.ts

@@ -1,10 +1,21 @@
 import rdfFactory, { Quadruple } from "@ontologies/core";
 
 import { getBasicStore } from "../../testUtilities";
+import { DeltaProcessor } from "../../types";
 
 import { ex, ld } from "./fixtures";
 
 describe("LinkedRenderStore", () => {
+    describe("#addDeltaProcessor", () => {
+        it ("adds the processor", () => {
+            const processor = jest.fn();
+            const { lrs } = getBasicStore();
+
+            lrs.addDeltaProcessor(processor as unknown as DeltaProcessor);
+            expect(lrs.deltaProcessors).toContain(processor);
+        });
+    });
+
     describe("#queueDelta", () => {
         const quadDelta = [
             [ex("1"), ex("p"), ex("2"), ld.add],

src/store/__tests__/deltaProcessor.spec.ts

@@ -77,6 +77,16 @@ describe("deltaProcessor", () => {
         expect((store as any).quads).toHaveLength(initialCount);
     });
 
+    it("requires explicit graph names", () => {
+        expect(() => {
+            deltaProcessor([], [], [], [], []);
+        }).toThrow("Pass a default graph explicitly");
+    });
+
+    it("ignores unknown methods", () => {
+        testDelta([ [bob, schema.children, alice, ld.ns("unknown")] ], [0, 0, 0]);
+    });
+
     describe("with an existing value", () => {
         it("add", () => {
             testDelta([ [bob, schema.children, alice, ld.add] ], [1, 0, 0]);

src/utilities/__tests__/memoizedNamespace.spec.ts

@@ -9,32 +9,44 @@ import { expandProperty } from "../memoizedNamespace";
 describe("memoizedNamespace", () => {
     describe("expandProperty", () => {
         it("returns identity when passed undefined", () => {
-            expect(expandProperty(undefined, {})).toBeUndefined();
+            expect(expandProperty(undefined)).toBeUndefined();
         });
 
         it("returns identity when passed NamedNode", () => {
             const n = rdfFactory.namedNode("http://example.com");
-            expect(expandProperty(n, {})).toEqual(n);
+            expect(expandProperty(n)).toEqual(n);
         });
 
         it("returns a NamedNode when passed a plain NN object", () => {
             const n = {
                 termType: "NamedNode",
                 value: "http://example.com/ns#1",
             };
-            expect(expandProperty(n, {})).toEqual(ex.ns("1"));
+            expect(expandProperty(n)).toEqual(ex.ns("1"));
+        });
+
+        it("returns a NamedNode when passed a plain NN object with prototype interface properties", () => {
+            const proto = { termType: "NamedNode" };
+            const n = Object.create(proto);
+            n.value = "http://example.com/ns#1";
+
+            expect(expandProperty(n)).toEqual(ex.ns("1"));
         });
 
         it("returns undefined when passed a random plain object", () => {
             const n = {
                 termType: "Whatever",
                 value: "http://example.com/ns#1",
             };
-            expect(expandProperty((n as NamedNode), {})).toBeUndefined();
+            expect(expandProperty((n as NamedNode))).toBeUndefined();
         });
 
         it("parses url strings to NamedNodes", () => {
-            expect(expandProperty("http://example.com/ns#1", {})).toEqual(ex.ns("1"));
+            expect(expandProperty("http://example.com/ns#1")).toEqual(ex.ns("1"));
+        });
+
+        it("parses n-quads formatted strings to NamedNodes", () => {
+            expect(expandProperty("<http://example.com/ns#1>")).toEqual(ex.ns("1"));
         });
 
         it("parses shorthand strings to NamedNodes", () => {

src/utilities/memoizedNamespace.ts

@@ -14,7 +14,7 @@ const CI_MATCH_SUFFIX = 1;
  * @returns The (expanded) property
  */
 export function expandProperty(prop: NamedNode | Term | string | undefined,
-                               namespaces: NamespaceMap): NamedNode | undefined {
+                               namespaces: NamespaceMap = {}): NamedNode | undefined {
     if (!prop) {
         return prop as undefined;
     }