@noeldemartin/solid-utils 0.6.0-next.8a6a0b585adc7a1c329fb0fed5c420bb72cdccda → 0.6.0-next.956cbec11a55691bab3170059fa908865d683e20

package/src/helpers/identifiers.ts

@@ -9,11 +9,9 @@ export interface SubjectParts {
 }
 
 function getContainerPath(parts: UrlParts): string | null {
-    if (!parts.path || !parts.path.startsWith('/'))
-        return null;
+    if (!parts.path || !parts.path.startsWith('/')) return null;
 
-    if (parts.path.match(/^\/[^/]*$/))
-        return '/';
+    if (parts.path.match(/^\/[^/]*$/)) return '/';
 
     return `/${arr(parts.path.split('/')).filter().slice(0, -1).join('/')}/`.replace('//', '/');
 }
@@ -27,30 +25,29 @@ function getContainerUrl(parts: UrlParts): string | null {
 }
 
 function __mintJsonLDIdentifiers(jsonld: JsonLD): void {
-    if (!('@type' in jsonld) || '@value' in jsonld)
-        return;
+    if (!('@type' in jsonld) || '@value' in jsonld) return;
 
     jsonld['@id'] = jsonld['@id'] ?? uuid();
 
     for (const propertyValue of Object.values(jsonld)) {
-        if (isObject(propertyValue))
-            __mintJsonLDIdentifiers(propertyValue);
+        if (isObject(propertyValue)) __mintJsonLDIdentifiers(propertyValue);
 
-        if (isArray(propertyValue))
-            propertyValue.forEach(value => isObject(value) && __mintJsonLDIdentifiers(value));
+        if (isArray(propertyValue)) propertyValue.forEach((value) => isObject(value) && __mintJsonLDIdentifiers(value));
     }
 }
 
 export function mintJsonLDIdentifiers(jsonld: JsonLD): JsonLDResource {
-    return tap(objectDeepClone(jsonld) as JsonLDResource, clone => __mintJsonLDIdentifiers(clone));
+    return tap(objectDeepClone(jsonld) as JsonLDResource, (clone) => __mintJsonLDIdentifiers(clone));
 }
 
 export function parseResourceSubject(subject: string): SubjectParts {
     const parts = urlParse(subject);
 
-    return !parts ? {} : objectWithoutEmpty({
-        containerUrl: getContainerUrl(parts),
-        documentName: parts.path ? parts.path.split('/').pop() : null,
-        resourceHash: parts.fragment,
-    });
+    return !parts
+        ? {}
+        : objectWithoutEmpty({
+            containerUrl: getContainerUrl(parts),
+            documentName: parts.path ? parts.path.split('/').pop() : null,
+            resourceHash: parts.fragment,
+        });
 }

package/src/helpers/io.ts

@@ -1,4 +1,4 @@
-import * as jsonld from 'jsonld';
+import jsonld from 'jsonld';
 import md5 from 'md5';
 import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
 import { BlankNode as N3BlankNode, Quad as N3Quad, Parser, Writer } from 'n3';

package/src/helpers/jsonld.ts

@@ -1,4 +1,4 @@
-import * as jsonld from 'jsonld';
+import jsonld from 'jsonld';
 import type { JsonLdDocument } from 'jsonld';
 
 export type JsonLD = Partial<{

package/src/helpers/vocabs.ts

@@ -23,22 +23,19 @@ export function defineIRIPrefix(name: string, value: string): void {
 }
 
 export function expandIRI(iri: string, options: Partial<ExpandIRIOptions> = {}): string {
-    if (iri.startsWith('http'))
-        return iri;
+    if (iri.startsWith('http')) return iri;
 
     const [prefix, name] = iri.split(':');
 
     if (prefix && name) {
         const expandedPrefix = knownPrefixes[prefix] ?? options.extraContext?.[prefix] ?? null;
 
-        if (!expandedPrefix)
-            throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
+        if (!expandedPrefix) throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
 
         return expandedPrefix + name;
     }
 
-    if (!options.defaultPrefix)
-        throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
+    if (!options.defaultPrefix) throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
 
     return options.defaultPrefix + prefix;
 }

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './errors';
 export * from './helpers';
 export * from './models';
+export * from './testing/types';

package/src/testing/chai/assertions.ts

@@ -0,0 +1,35 @@
+import { sparqlEquals, turtleEquals } from '@noeldemartin/solid-utils/testing/helpers';
+import type { EqualityResult } from '@noeldemartin/solid-utils/testing/helpers';
+
+export function defineChaiAssertions<T extends Record<string, (this: Chai.AssertionStatic, ...args: any[]) => void>>(
+    assertions: T): T {
+    return assertions;
+}
+
+export default defineChaiAssertions({
+    turtle(graph: string): void {
+        const self = this as unknown as Chai.AssertionStatic;
+        const actual = self._obj as string;
+        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 as string;
+        const assert = self.assert.bind(this);
+        const expected = query;
+        const result = sparqlEquals(expected, actual);
+
+        assert(result.success, result.message, '', result.expected, result.actual);
+    },
+    equalityResult(): void {
+        const self = this as unknown as Chai.AssertionStatic;
+        const result = self._obj as EqualityResult;
+        const assert = self.assert.bind(this);
+
+        assert(result.success, result.message, '', result.expected, result.actual);
+    },
+});

package/src/testing/chai/index.ts

@@ -0,0 +1,19 @@
+import assertions from './assertions';
+
+export type ChaiSolidAssertions = {
+    [assertion in keyof typeof assertions]: (typeof assertions)[assertion];
+};
+
+export function installChaiSolidAssertions(): void {
+    (globalThis as { chai?: Chai.ChaiStatic }).chai?.use((_chai) => {
+        return Object.entries(assertions).forEach(([name, method]) => _chai.Assertion.addMethod(name, method));
+    });
+}
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Chai {
+        interface Assertion extends ChaiSolidAssertions {}
+        interface Include extends ChaiSolidAssertions {}
+    }
+}

package/src/testing/helpers.ts

@@ -0,0 +1,187 @@
+import { JSError, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
+import type { Quad, Quad_Object } from '@rdfjs/types';
+
+import {
+    jsonldToQuads,
+    quadToTurtle,
+    quadsToTurtle,
+    sparqlToQuadsSync,
+    turtleToQuadsSync,
+} from '@noeldemartin/solid-utils/helpers/io';
+import type { JsonLD } from '@noeldemartin/solid-utils/helpers/jsonld';
+
+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 JSError {
+
+    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);
+}
+
+function createPatternRegexp(expected: string): RegExp {
+    const patternAliases = [];
+    const patternMatches = stringMatchAll<4, 1 | 2>(expected, /\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
+    const patterns: string[] = [];
+    let expectedRegExp = expected;
+
+    for (const patternMatch of patternMatches) {
+        patternMatch[2] && patternAliases.push(patternMatch[2]);
+
+        patterns.push(patternMatch[3]);
+
+        expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
+    }
+
+    expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+
+    for (const [patternIndex, pattern] of Object.entries(patterns)) {
+        expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
+    }
+
+    return new RegExp(expectedRegExp);
+}
+
+function quadValueEquals(expected: string, actual: string): boolean {
+    return containsPatterns(expected)
+        ? (patternsRegExpsIndex[expected] ??= createPatternRegexp(expected)).test(actual)
+        : expected === actual;
+}
+
+function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
+    if (expected.termType !== actual.termType) return false;
+
+    if (expected.termType === 'Literal' && actual.termType === 'Literal') {
+        if (expected.datatype.value !== actual.datatype.value) return false;
+
+        if (!containsPatterns(expected.value))
+            return expected.datatype.value === 'http://www.w3.org/2001/XMLSchema#dateTime'
+                ? new Date(expected.value).getTime() === new Date(actual.value).getTime()
+                : expected.value === actual.value;
+    }
+
+    return quadValueEquals(expected.value, actual.value);
+}
+
+function quadEquals(expected: Quad, actual: Quad): boolean {
+    return (
+        quadObjectEquals(expected.object, actual.object) &&
+        quadValueEquals(expected.subject.value, actual.subject.value) &&
+        quadValueEquals(expected.predicate.value, actual.predicate.value)
+    );
+}
+
+function resetPatterns(): void {
+    patternsRegExpsIndex = {};
+}
+
+export interface EqualityResult {
+    success: boolean;
+    message: string;
+    expected: string;
+    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 });
+    const result = (success: boolean, message: string) => ({ success, message, expected, actual });
+
+    for (const operation of Object.keys(expectedOperations)) {
+        if (!(operation in actualOperations)) return result(false, `Couldn't find expected ${operation} operation.`);
+
+        const expectedQuads = pull(expectedOperations, operation);
+        const actualQuads = pull(actualOperations, operation);
+
+        if (expectedQuads.length !== actualQuads.length)
+            return result(false, `Expected ${expectedQuads.length} ${operation} triples, found ${actualQuads.length}.`);
+
+        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)}`,
+            );
+        }
+    }
+
+    const unexpectedOperation = Object.keys(actualOperations)[0] ?? null;
+    if (unexpectedOperation) return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
+
+    return result(true, 'sparql matches');
+}
+
+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 });
+    const result = (success: boolean, message: string) => ({ success, message, expected, actual });
+
+    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, 'turtle matches');
+}

package/src/testing/hepers.test.ts

@@ -0,0 +1,329 @@
+import { describe, expect, it } from 'vitest';
+
+import { sparqlEquals, turtleEquals } from './helpers';
+
+describe('Testing helpers', () => {
+
+    it('Compares sparql', () => {
+        // Arrange
+        const expected = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+        const actual = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares sparql operations', () => {
+        // Arrange
+        const expected = `
+            INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . } ;
+            DELETE DATA { <#me> <http://xmlns.com/foaf/0.1/name> "John Doe" . }
+        `;
+        const actual = 'INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares sparql triples', () => {
+        // Arrange
+        const expected = 'INSERT DATA { <#me> a <http://xmlns.com/foaf/0.1/Person> . }';
+        const actual = 'INSERT DATA { <#me> <http://xmlns.com/foaf/0.1/name> "Amy Doe" . }';
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares expanded ordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Broth" "Noodles" ) .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+            @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient _:b0 .
+
+            _:b0
+                rdf:first "Broth" ;
+                rdf:rest _:b1 .
+
+            _:b1
+                rdf:first "Noodles" ;
+                rdf:rest rdf:nil .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares different ordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Broth" "Noodles" ) .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient ( "Noodles" "Broth" ) .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('Compares different unordered lists in Turtle', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient "Broth", "Noodles" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeIngredient "Noodles", "Broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('Compares sparql using regex patterns', () => {
+        // Arrange
+        const expected = `
+            INSERT DATA {
+                @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+                @prefix foaf: <http://xmlns.com/foaf/> .
+                @prefix purl: <http://purl.org/dc/terms/> .
+
+                <#me>
+                    foaf:name "[[.*]] Doe" ;
+                    foaf:age 42 .
+
+                <#something-[[.*]]>
+                    purl:created "[[.*]]"^^xsd:dateTime ;
+                    purl:modified "2021-01-16T[[.*]]"^^xsd:dateTime ;
+                    purl:available "2021-01-16T12:34:56Z"^^xsd:dateTime .
+            }
+        `;
+        const actual = `
+            INSERT DATA {
+                @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+                @prefix foaf: <http://xmlns.com/foaf/> .
+                @prefix purl: <http://purl.org/dc/terms/> .
+
+                <#me>
+                    foaf:name "John Doe" ;
+                    foaf:age 42 .
+
+                <#something-123456>
+                    purl:created "2021-01-16T12:12:50.123Z"^^xsd:dateTime ;
+                    purl:modified "2021-01-16T12:12:50.123Z"^^xsd:dateTime ;
+                    purl:available "2021-01-16T12:34:56.000Z"^^xsd:dateTime .
+            }
+        `;
+
+        // Act
+        const result = sparqlEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('supports aliases in regex patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#[[step-1][.*]]>, <#[[step-2][.*]]> .
+
+            <#[[step-1][.*]]>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#[[step-2][.*]]>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#ramen-step-1>, <#ramen-step-2> .
+
+            <#ramen-step-1>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#ramen-step-2>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('counts matching triples only once', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen", "Ramen" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:description "is life" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+    it('allows regex patterns to be mixed up', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#[[instruction-1][.*]]-operation-[[operation-1][.*]]> schema:object <#[[instruction-1][.*]]> .
+            <#[[instruction-1][.*]]-metadata> schema:object <#[[instruction-1][.*]]> .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen-step-1-metadata> schema:object <#ramen> .
+            <#ramen-step-1-operation-1> schema:object <#ramen> .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    it('matches built-in patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#[[foobar][%uuid%]]> schema:description "Lorem ipsum" .
+            <#[[%uuid%]]> schema:description "Dolor sit amet" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#20421db7-0c7d-419c-b27e-2c9b3cc026b3> schema:description "Lorem ipsum" .
+            <#d4b41533-dd5d-4a66-9d3f-316f80f135b2> schema:description "Dolor sit amet" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(true);
+    });
+
+    // TODO
+    it.skip('aliases match regex patterns', () => {
+        // Arrange
+        const expected = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#[[step-1][.*]]>, <#[[step-2][.*]]> .
+
+            <#[[step-1][.*]]>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#[[step-2][.*]]>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+        const actual = `
+            @prefix schema: <https://schema.org/> .
+
+            <#ramen>
+                a schema:Recipe ;
+                schema:name "Ramen" ;
+                schema:recipeInstructions <#ramen-step-1>, <#ramen-step-2> .
+
+            <#ramen-step-1>
+                a schema:HowToStep ;
+                schema:text "Boil the noodles" .
+
+            <#ramen-step-3>
+                a schema:HowToStep ;
+                schema:text "Dip them into the broth" .
+        `;
+
+        // Act
+        const result = turtleEquals(expected, actual);
+
+        // Assert
+        expect(result.success).toBe(false);
+    });
+
+});

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export * from './vitest';
+export * from './helpers';
+export * from './chai';

package/src/testing/types/index.ts

@@ -0,0 +1,2 @@
+export type { ChaiSolidAssertions } from '@noeldemartin/solid-utils/testing/chai';
+export type { VitestSolidMatchers } from '@noeldemartin/solid-utils/testing/vitest';