@rdfx/testing 0.0.23 → 0.0.25

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type * as RDF from "@rdfjs/types";
-import type { IQuadTerms } from "jest-rdf/lib/matchers/toBeRdfDatasetMatching.js";
 import "vitest";
+import type { IQuadTerms } from "./jestRdfMatchers.js";
 declare module "vitest" {
     interface Matchers<T = any> {
         toBeLeft(expected?: unknown): T;

package/dist/jestRdfMatchers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Code adapted from jest-rdf (https://www.npmjs.com/package/jest-rdf, MIT license) to circumvent build errors in reusing its matchers.
+ */
+import type * as RDF from "@rdfjs/types";
+export interface IQuadTerms<TQuad extends RDF.BaseQuad = RDF.Quad> {
+    graph?: TQuad["graph"];
+    object?: TQuad["object"];
+    predicate?: TQuad["predicate"];
+    subject?: TQuad["subject"];
+}
+export declare function toBeRdfDatasetContaining<TQuad extends RDF.BaseQuad = RDF.Quad>(dataset: RDF.DatasetCore<TQuad>, ...quads: TQuad[]): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toBeRdfDatasetMatching<TQuad extends RDF.BaseQuad = RDF.Quad>(dataset: RDF.DatasetCore<TQuad>, { subject, predicate, object, graph }: IQuadTerms<TQuad>, matches?: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toBeRdfDatasetOfSize<TQuad extends RDF.BaseQuad = RDF.Quad>(dataset: RDF.DatasetCore<TQuad>, expected: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toBeRdfIsomorphic<TQuad extends RDF.BaseQuad = RDF.Quad>(received: Iterable<TQuad>, actual: Iterable<TQuad>): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toEqualRdfQuad<TQuad extends RDF.BaseQuad = RDF.Quad>(received: TQuad, actual: TQuad): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toEqualRdfQuadArray<TQuad extends RDF.BaseQuad = RDF.Quad>(received: TQuad[], actual: TQuad[]): {
+    message: () => string;
+    pass: boolean;
+};
+export declare function toEqualRdfTerm(received: RDF.Term, actual: RDF.Term): {
+    message: () => string;
+    pass: false;
+} | {
+    message: () => string;
+    pass: true;
+};
+export declare function toEqualRdfTermArray(received: RDF.Term[], actual: RDF.Term[]): {
+    message: () => string;
+    pass: boolean;
+};
+//# sourceMappingURL=jestRdfMatchers.d.ts.map

package/dist/jestRdfMatchers.js

@@ -0,0 +1,216 @@
+/**
+ * Code adapted from jest-rdf (https://www.npmjs.com/package/jest-rdf, MIT license) to circumvent build errors in reusing its matchers.
+ */
+import { getGraphBlankNodes, getQuadsWithBlankNodes, hashTerms, isomorphic, uniqGraph, } from "rdf-isomorphic";
+import { quadToStringQuad, termToString } from "rdf-string";
+import { everyTerms, someTerms } from "rdf-terms";
+function fail(received, actual) {
+    return {
+        message: () => `expected ${termToString(received)} and ${termToString(actual)} to be equal`,
+        pass: false,
+    };
+}
+function getNonBlankDiff(a1, a2) {
+    return a1.filter((quad) => everyTerms(quad, (term) => term.termType !== "BlankNode") &&
+        a2.every((q2) => !q2.equals(quad)));
+}
+function quadArrayToString(quadArray) {
+    return `[ ${quadArray.map((quad) => JSON.stringify(quadToStringQuad(quad))).join(", ")} ]`;
+}
+function succeed(received, actual) {
+    return {
+        message: () => `expected ${termToString(received)} and ${termToString(actual)} not to be equal`,
+        pass: true,
+    };
+}
+function termArrayToString(termArray) {
+    return `[ ${termArray.map((term) => JSON.stringify(termToString(term))).join(", ")} ]`;
+}
+function getBnodeDiff(receivedQuads, expectedQuads) {
+    // Hash every term based on the signature of the quads if appears in.
+    const ungroundedHashesA = unGroundHashes(receivedQuads);
+    const ungroundedHashesB = unGroundHashes(expectedQuads);
+    const blankA = uniqGraph(getQuadsWithBlankNodes(receivedQuads));
+    const blankB = uniqGraph(getQuadsWithBlankNodes(expectedQuads));
+    const received = {};
+    const expected = {};
+    for (const elem of getDiff(ungroundedHashesA, ungroundedHashesB)) {
+        received[elem] = blankA.filter((quad) => someTerms(quad, (term) => term.termType === "BlankNode" && term.value === elem.slice(2)));
+    }
+    for (const elem of getDiff(ungroundedHashesB, ungroundedHashesA)) {
+        expected[elem] = blankB.filter((quad) => someTerms(quad, (term) => term.termType === "BlankNode" && term.value === elem.slice(2)));
+    }
+    return {
+        received,
+        expected,
+    };
+}
+function getDiff(hash1, hash2) {
+    const diffed = [];
+    const values = new Set(Object.values(hash2));
+    for (const key in hash1) {
+        if (!values.has(hash1[key])) {
+            diffed.push(key);
+        }
+    }
+    return diffed;
+}
+export function toBeRdfDatasetContaining(dataset, ...quads) {
+    for (const quad of quads) {
+        if (!dataset.has(quad)) {
+            return {
+                message: () => `expected dataset to have quads ${quadArrayToString(quads)}`,
+                pass: false,
+            };
+        }
+    }
+    return {
+        message: () => `expected dataset to not have quads ${quadArrayToString(quads)}`,
+        pass: true,
+    };
+}
+export function toBeRdfDatasetMatching(dataset, { subject, predicate, object, graph }, matches = 1) {
+    const times = matches === 1 ? "once" : `${matches} times`;
+    if (dataset.match(subject, predicate, object, graph).size !== matches) {
+        return {
+            message: () => `expected dataset to match ${JSON.stringify({ subject, predicate, object, graph })} ${times}`,
+            pass: false,
+        };
+    }
+    return {
+        message: () => `expected dataset to not match ${JSON.stringify({ subject, predicate, object, graph })} ${times}`,
+        pass: true,
+    };
+}
+export function toBeRdfDatasetOfSize(dataset, expected) {
+    const actual = dataset.size;
+    if (expected !== actual) {
+        return {
+            message: () => `expected dataset to have ${expected} quads, ${actual} received`,
+            pass: false,
+        };
+    }
+    return {
+        message: () => `expected dataset to not have exactly ${expected} quads`,
+        pass: true,
+    };
+}
+export function toBeRdfIsomorphic(received, actual) {
+    const receivedArray = [...received];
+    const actualArray = [...actual];
+    if (!isomorphic(receivedArray, actualArray)) {
+        const { received: receivedBnodes, expected: actualBnodes } = getBnodeDiff(receivedArray, actualArray);
+        return {
+            message: () => `expected two graphs to be isomorphic.
+
+  Expected:
+${quadArrayToString(actualArray)}
+
+  Actual:
+${quadArrayToString(receivedArray)}
+
+Missing Quads (that don't contain Blank Nodes):
+${quadArrayToString(getNonBlankDiff(actualArray, receivedArray))}
+
+Additional Quads (that don't contain Blank Nodes):
+${quadArrayToString(getNonBlankDiff(receivedArray, actualArray))}
+
+Missing Blank Node Patterns:
+${Object.entries(actualBnodes)
+                .map(([bnode, quads]) => `${bnode} : ${quadArrayToString(quads)}`)
+                .join("\n")}
+
+Additional Blank Node Patterns:
+${Object.entries(receivedBnodes)
+                .map(([bnode, quads]) => `${bnode} : ${quadArrayToString(quads)}`)
+                .join("\n")}
+`,
+            pass: false,
+        };
+    }
+    return {
+        message: () => `expected two graphs not to be isomorphic.
+
+  Expected:
+${quadArrayToString(actualArray)}
+
+  Actual:
+${quadArrayToString(receivedArray)}
+`,
+        pass: true,
+    };
+}
+export function toEqualRdfQuad(received, actual) {
+    const s = toEqualRdfTerm(received.subject, actual.subject);
+    if (!s.pass) {
+        return s;
+    }
+    const p = toEqualRdfTerm(received.predicate, actual.predicate);
+    if (!p.pass) {
+        return p;
+    }
+    const o = toEqualRdfTerm(received.object, actual.object);
+    if (!o.pass) {
+        return o;
+    }
+    const g = toEqualRdfTerm(received.graph, actual.graph);
+    if (!g.pass) {
+        return g;
+    }
+    return {
+        message: () => `expected
+  ${JSON.stringify(quadToStringQuad(received))}
+not to equal
+  ${JSON.stringify(quadToStringQuad(actual))}`,
+        pass: true,
+    };
+}
+export function toEqualRdfQuadArray(received, actual) {
+    if (received.length !== actual.length) {
+        return {
+            message: () => `expected ${quadArrayToString(received)} to equal ${quadArrayToString(actual)}`,
+            pass: false,
+        };
+    }
+    for (const [i, element] of received.entries()) {
+        const q = toEqualRdfQuad(element, actual[i]);
+        if (!q.pass) {
+            return q;
+        }
+    }
+    return {
+        message: () => `expected ${quadArrayToString(received)} not to equal ${quadArrayToString(actual)}`,
+        pass: true,
+    };
+}
+export function toEqualRdfTerm(received, actual) {
+    if (received.termType !== actual.termType) {
+        return fail(received, actual);
+    }
+    if (received.termType !== "BlankNode" && !received.equals(actual)) {
+        return fail(received, actual);
+    }
+    return succeed(received, actual);
+}
+export function toEqualRdfTermArray(received, actual) {
+    if (received.length !== actual.length) {
+        return {
+            message: () => `expected ${termArrayToString(received)} to equal ${termArrayToString(actual)}`,
+            pass: false,
+        };
+    }
+    for (const [i, element] of received.entries()) {
+        const q = toEqualRdfTerm(element, actual[i]);
+        if (!q.pass) {
+            return q;
+        }
+    }
+    return {
+        message: () => `expected ${termArrayToString(received)} not to equal ${termArrayToString(actual)}`,
+        pass: true,
+    };
+}
+function unGroundHashes(graph) {
+    return hashTerms(uniqGraph(getQuadsWithBlankNodes(graph)), getGraphBlankNodes(graph), {})[1];
+}
+//# sourceMappingURL=jestRdfMatchers.js.map

package/dist/matchers.d.ts

@@ -1,5 +1,13 @@
+import { toBeRdfDatasetContaining, toBeRdfDatasetMatching, toBeRdfDatasetOfSize, toBeRdfIsomorphic, toEqualRdfQuad, toEqualRdfQuadArray, toEqualRdfTerm, toEqualRdfTermArray } from "./jestRdfMatchers.js";
 export declare const matchers: {
-    toBeLeft: import("vitest").Matcher;
-    default: {};
+    toBeRdfDatasetContaining: typeof toBeRdfDatasetContaining;
+    toBeRdfDatasetMatching: typeof toBeRdfDatasetMatching;
+    toBeRdfDatasetOfSize: typeof toBeRdfDatasetOfSize;
+    toBeRdfIsomorphic: typeof toBeRdfIsomorphic;
+    toEqualRdfQuad: typeof toEqualRdfQuad;
+    toEqualRdfQuadArray: typeof toEqualRdfQuadArray;
+    toEqualRdfTerm: typeof toEqualRdfTerm;
+    toEqualRdfTermArray: typeof toEqualRdfTermArray;
+    toBeLeft: import("vitest").Matcher<import("vitest").MatcherState, any[]>;
 };
 //# sourceMappingURL=matchers.d.ts.map

package/dist/matchers.js

@@ -1,7 +1,14 @@
-import { default as jestRdfMatchers } from "jest-rdf/lib/matchers/index.js";
-import * as purifyMatchers from "./purifyMatchers.js";
+import { toBeRdfDatasetContaining, toBeRdfDatasetMatching, toBeRdfDatasetOfSize, toBeRdfIsomorphic, toEqualRdfQuad, toEqualRdfQuadArray, toEqualRdfTerm, toEqualRdfTermArray, } from "./jestRdfMatchers.js";
+import { toBeLeft } from "./purifyMatchers.js";
 export const matchers = {
-    ...jestRdfMatchers,
-    ...purifyMatchers,
+    toBeRdfDatasetContaining,
+    toBeRdfDatasetMatching,
+    toBeRdfDatasetOfSize,
+    toBeRdfIsomorphic,
+    toEqualRdfQuad,
+    toEqualRdfQuadArray,
+    toEqualRdfTerm,
+    toEqualRdfTermArray,
+    toBeLeft,
 };
 //# sourceMappingURL=matchers.js.map

package/package.json

@@ -1,8 +1,10 @@
 {
   "dependencies": {
     "@rdfjs/types": "~2.0.1",
-    "jest-rdf": "~2.0.0",
     "purify-ts": "~2.1.4",
+    "rdf-isomorphic": "~2.0.1",
+    "rdf-string": "~2.0.1",
+    "rdf-terms": "~2.0.0",
     "vitest": "~4.1.5"
   },
   "devDependencies": {},
@@ -27,5 +29,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.23"
+  "version": "0.0.25"
 }