@noeldemartin/solid-utils 0.0.0-next.f9716490938d6dbabb0920bc834315c53ccd2505 → 0.1.1-next.1f0cf6ccc237588ae655211348e94eba9ba16c8d

package/src/helpers/testing.ts

@@ -1,25 +1,54 @@
-import { pull } from '@noeldemartin/utils';
+import { Error, arrayRemove, pull } from '@noeldemartin/utils';
+import type { JsonLD } from '@/helpers/jsonld';
 import type { Quad, Quad_Object } from 'rdf-js';
 
-import { quadToTurtle, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+import { jsonldToQuads, quadToTurtle, quadsToTurtle, sparqlToQuadsSync, turtleToQuadsSync } from './io';
 
-const patternRegExps: Record<string, RegExp> = {};
+let patternsRegExpsIndex: Record<string, RegExp> = {};
+const builtInPatterns: Record<string, string> = {
+    '%uuid%': '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
+};
+
+class ExpectedQuadAssertionError extends Error {
+
+    constructor(public readonly expectedQuad: Quad) {
+        super(`Couldn't find the following triple: ${quadToTurtle(expectedQuad)}`);
+    }
+
+}
+
+function assertExpectedQuadsExist(expectedQuads: Quad[], actualQuads: Quad[]): void {
+    for (const expectedQuad of expectedQuads) {
+        const matchingQuad = actualQuads.find(actualQuad => quadEquals(expectedQuad, actualQuad));
+
+        if (!matchingQuad)
+            throw new ExpectedQuadAssertionError(expectedQuad);
+
+        arrayRemove(actualQuads, matchingQuad);
+    }
+}
 
 function containsPatterns(value: string): boolean {
-    return /\[\[([^\]]+)\]\]/.test(value);
+    return /\[\[(.*\]\[)?([^\]]+)\]\]/.test(value);
 }
 
 function quadValueEquals(expected: string, actual: string): boolean {
     if (!containsPatterns(expected))
         return expected === actual;
 
-    if (!(expected in patternRegExps)) {
-        const patternMatches = expected.matchAll(/\[\[([^\]]+)\]\]/g);
+    const patternAliases = [];
+
+    if (!(expected in patternsRegExpsIndex)) {
+        const patternMatches = expected.matchAll(/\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
         const patterns: string[] = [];
         let expectedRegExp = expected;
 
         for (const patternMatch of patternMatches) {
-            patterns.push(patternMatch[1]);
+            if (patternMatch[2]) {
+                patternAliases.push(patternMatch[2]);
+            }
+
+            patterns.push(patternMatch[3]);
 
             expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
         }
@@ -27,13 +56,13 @@ function quadValueEquals(expected: string, actual: string): boolean {
         expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 
         for (const [patternIndex, pattern] of Object.entries(patterns)) {
-            expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, pattern);
+            expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
         }
 
-        patternRegExps[expected] = new RegExp(expectedRegExp);
+        patternsRegExpsIndex[expected] = new RegExp(expectedRegExp);
     }
 
-    return patternRegExps[expected].test(actual);
+    return patternsRegExpsIndex[expected].test(actual);
 }
 
 function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
@@ -59,6 +88,10 @@ function quadEquals(expected: Quad, actual: Quad): boolean {
         && quadValueEquals(expected.predicate.value, actual.predicate.value);
 }
 
+function resetPatterns(): void {
+    patternsRegExpsIndex = {};
+}
+
 export interface EqualityResult {
     success: boolean;
     message: string;
@@ -66,8 +99,39 @@ export interface EqualityResult {
     actual: string;
 }
 
+export async function jsonldEquals(expected: JsonLD, actual: JsonLD): Promise<EqualityResult> {
+    // TODO catch parsing errors and improve message.
+    resetPatterns();
+
+    const expectedQuads = await jsonldToQuads(expected);
+    const actualQuads = await jsonldToQuads(actual);
+    const expectedTurtle = quadsToTurtle(expectedQuads);
+    const actualTurtle = quadsToTurtle(actualQuads);
+    const result = (success: boolean, message: string) => ({
+        success,
+        message,
+        expected: expectedTurtle,
+        actual: actualTurtle,
+    });
+
+    if (expectedQuads.length !== actualQuads.length)
+        return result(false, `Expected ${expectedQuads.length} triples, found ${actualQuads.length}.`);
+
+    try {
+        assertExpectedQuadsExist(expectedQuads, actualQuads);
+    } catch (error) {
+        if (!(error instanceof ExpectedQuadAssertionError))
+            throw error;
+
+        return result(false, error.message);
+    }
+
+    return result(true, 'jsonld matches');
+}
+
 export function sparqlEquals(expected: string, actual: string): EqualityResult {
     // TODO catch parsing errors and improve message.
+    resetPatterns();
 
     const expectedOperations = sparqlToQuadsSync(expected, { normalizeBlankNodes: true });
     const actualOperations = sparqlToQuadsSync(actual, { normalizeBlankNodes: true });
@@ -83,9 +147,16 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
         if (expectedQuads.length !== actualQuads.length)
             return result(false, `Expected ${expectedQuads.length} ${operation} triples, found ${actualQuads.length}.`);
 
-        for (const expectedQuad of expectedQuads) {
-            if (!actualQuads.some(actualQuad => quadEquals(expectedQuad, actualQuad)))
-                return result(false, `Couldn't find the following ${operation} triple: ${quadToTurtle(expectedQuad)}`);
+        try {
+            assertExpectedQuadsExist(expectedQuads, actualQuads);
+        } catch (error) {
+            if (!(error instanceof ExpectedQuadAssertionError))
+                throw error;
+
+            return result(
+                false,
+                `Couldn't find the following ${operation} triple: ${quadToTurtle(error.expectedQuad)}`,
+            );
         }
     }
 
@@ -98,6 +169,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
 
 export function turtleEquals(expected: string, actual: string): EqualityResult {
     // TODO catch parsing errors and improve message.
+    resetPatterns();
 
     const expectedQuads = turtleToQuadsSync(expected, { normalizeBlankNodes: true });
     const actualQuads = turtleToQuadsSync(actual, { normalizeBlankNodes: true });
@@ -106,9 +178,13 @@ export function turtleEquals(expected: string, actual: string): EqualityResult {
     if (expectedQuads.length !== actualQuads.length)
         return result(false, `Expected ${expectedQuads.length} triples, found ${actualQuads.length}.`);
 
-    for (const expectedQuad of expectedQuads) {
-        if (!actualQuads.some(actualQuad => quadEquals(expectedQuad, actualQuad)))
-            return result(false, `Couldn't find the following triple: ${quadToTurtle(expectedQuad)}`);
+    try {
+        assertExpectedQuadsExist(expectedQuads, actualQuads);
+    } catch (error) {
+        if (!(error instanceof ExpectedQuadAssertionError))
+            throw error;
+
+        return result(false, error.message);
     }
 
     return result(true, 'turtle matches');

package/src/plugins/chai/assertions.ts

@@ -1,4 +1,4 @@
-import { sparqlEquals } from '@/helpers/testing';
+import { sparqlEquals, turtleEquals } from '@/helpers/testing';
 
 type CustomAssertions = {
     [assertion in keyof typeof assertions]: typeof assertions[assertion];
@@ -17,6 +17,15 @@ declare global {
 }
 
 const assertions: Record<string, (this: Chai.AssertionStatic, ...args: any[]) => void> = {
+    turtle(graph: string): void {
+        const self = this as unknown as Chai.AssertionStatic;
+        const actual = self._obj;
+        const assert = self.assert.bind(this);
+        const expected = graph;
+        const result = turtleEquals(expected, actual);
+
+        assert(result.success, result.message, '', result.expected, result.actual);
+    },
     sparql(query: string): void {
         const self = this as unknown as Chai.AssertionStatic;
         const actual = self._obj;
@@ -24,7 +33,7 @@ const assertions: Record<string, (this: Chai.AssertionStatic, ...args: any[]) =>
         const expected = query;
         const result = sparqlEquals(expected, actual);
 
-        assert(result.success, result.message, expected, actual);
+        assert(result.success, result.message, '', result.expected, result.actual);
     },
 };
 

package/src/plugins/cypress/types.d.ts

@@ -7,6 +7,7 @@ declare global {
         // TODO generate automatically
         interface Chainer<Subject> {
             (chainer: 'be.sparql', update: string): Cypress.Chainable<Subject>;
+            (chainer: 'be.turtle', graph: string): Cypress.Chainable<Subject>;
         }
 
     }

package/src/plugins/jest/matchers.ts

@@ -1,41 +1,56 @@
-import diff from 'jest-diff';
-
 import { normalizeSparql } from '@/helpers/io';
-import { sparqlEquals } from '@/helpers/testing';
+import { jsonldEquals, sparqlEquals } from '@/helpers/testing';
+import type { EqualityResult } from '@/helpers/testing';
+
+interface FormatResultOptions {
+    context: jest.MatcherContext;
+    hint: string;
+    expected: unknown;
+    received: unknown;
+}
+
+function formatResult(result: EqualityResult, options: FormatResultOptions) {
+    const pass = result.success;
+    const utils = options.context.utils;
+    const message = pass
+        ? () => [
+            result.message,
+            utils.matcherHint(options.hint),
+            [
+                `Expected: not ${utils.printExpected(options.expected)}`,
+                `Received: ${utils.printReceived(options.received)}`,
+            ].join('\n'),
+        ].join('\n\n')
+        : () => {
+            return [
+                result.message,
+                utils.matcherHint(options.hint),
+            ].join('\n\n');
+        };
+
+    return { pass, message };
+}
 
 const matchers: jest.ExpectExtendMap = {
+    async toEqualJsonLD(received, expected) {
+        const result = await jsonldEquals(expected, received);
+
+        return formatResult(result, {
+            context: this,
+            hint: 'toEqualJsonLD',
+            expected,
+            received,
+        });
+    },
     toEqualSparql(received, expected) {
         const result = sparqlEquals(expected, received);
-        const pass = result.success;
-        const normalizedReceived = normalizeSparql(received);
-        const normalizedExpected = normalizeSparql(expected);
-        const message = pass
-            ? () => [
-                result.message,
-                this.utils.matcherHint('toEqualSparql'),
-                [
-                    `Expected: not ${this.utils.printExpected(normalizedExpected)}`,
-                    `Received: ${this.utils.printReceived(normalizedReceived)}`,
-                ].join('\n'),
-            ].join('\n\n')
-            : () => {
-                const diffString = diff(normalizedExpected, normalizedReceived, {
-                    expand: this.expand,
-                });
-
-                return [
-                    result.message,
-                    this.utils.matcherHint('toEqualJsonLD'),
-                    diffString && diffString.includes('- Expect')
-                        ? `Difference:\n\n${diffString}`
-                        : [
-                            `Expected: ${this.utils.printExpected(normalizedExpected)}`,
-                            `Received: ${this.utils.printReceived(normalizedReceived)}`,
-                        ].join('\n'),
-                ].join('\n\n');
-            };
 
-        return { pass, message };
+        return formatResult(result, {
+            context: this,
+            hint: 'toEqualSparql',
+            expected: normalizeSparql(expected),
+            received: normalizeSparql(received),
+        });
     },
 };
 

package/src/plugins/jest/types.d.ts

@@ -5,6 +5,7 @@ declare global {
         // TODO generate automatically
         interface Matchers<R> {
             toEqualSparql(sparql: string): R;
+            toEqualJsonLD(jsonld: JsonLD): Promise<R>;
         }
 
     }