@noeldemartin/solid-utils 0.5.0 → 0.6.0-next.70fba2db4562da63a3ae210c80936d148acfc0de

package/src/models/SolidDocument.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+
+import SolidDocument from '@noeldemartin/solid-utils/models/SolidDocument';
+import { turtleToQuadsSync } from '@noeldemartin/solid-utils/helpers';
+
+describe('SolidDocument', () => {
+
+    it('Identifies storage documents', () => {
+        const hasStorageHeader = (link: string) => {
+            const document = new SolidDocument('', [], new Headers({ Link: link }));
+
+            return document.isStorage();
+        };
+
+        /* eslint-disable max-len */
+        expect(hasStorageHeader('')).toBe(false);
+        expect(hasStorageHeader('<http://www.w3.org/ns/pim/space#Storage>; rel="type"')).toBe(true);
+        expect(hasStorageHeader('<http://www.w3.org/ns/pim/space#Storage>; rel="something-else"; rel="type"')).toBe(
+            true,
+        );
+        expect(
+            hasStorageHeader(
+                '<http://www.w3.org/ns/pim/space#Storage>; rel="something-else", <http://example.com>; rel="type"',
+            ),
+        ).toBe(false);
+        /* eslint-enable max-len */
+    });
+
+    it('Parses last modified from header', () => {
+        const document = new SolidDocument('', [], new Headers({ 'Last-Modified': 'Fri, 03 Sept 2021 16:09:12 GMT' }));
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+    it('Parses last modified from document purl:modified', () => {
+        const document = new SolidDocument(
+            'https://pod.example.org/my-document',
+            turtleToQuadsSync(
+                `
+                <./fallback>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-09-03T16:23:25.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+
+                <>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-09-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+            `,
+                { baseIRI: 'https://pod.example.org/my-document' },
+            ),
+            new Headers({ 'Last-Modified': 'invalid date' }),
+        );
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+    it('Parses last modified from any purl date', () => {
+        const document = new SolidDocument(
+            'https://pod.example.org/my-document',
+            turtleToQuadsSync(
+                `
+                <./fallback-one>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-05-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+
+                <./fallback-two>
+                    <http://purl.org/dc/terms/created>
+                    "2021-09-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+            `,
+                { baseIRI: 'https://pod.example.org/my-document' },
+            ),
+            new Headers({ 'Last-Modified': 'invalid date' }),
+        );
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+});

package/src/models/SolidDocument.ts

@@ -1,7 +1,7 @@
 import { arrayFilter, parseDate, stringMatch } from '@noeldemartin/utils';
-import type { Quad } from 'rdf-js';
+import type { Quad } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 import SolidStore from './SolidStore';
 
@@ -25,16 +25,13 @@ export default class SolidDocument extends SolidStore {
     }
 
     public isACPResource(): boolean {
-        return !!this.headers.get('Link')
+        return !!this.headers
+            .get('Link')
             ?.match(/<http:\/\/www\.w3\.org\/ns\/solid\/acp#AccessControlResource>;[^,]+rel="type"/);
     }
 
     public isPersonalProfile(): boolean {
-        return !!this.statement(
-            this.url,
-            expandIRI('rdf:type'),
-            expandIRI('foaf:PersonalProfileDocument'),
-        );
+        return !!this.statement(this.url, expandIRI('rdf:type'), expandIRI('foaf:PersonalProfileDocument'));
     }
 
     public isStorage(): boolean {
@@ -54,10 +51,12 @@ export default class SolidDocument extends SolidStore {
     }
 
     public getLastModified(): Date | null {
-        return parseDate(this.headers.get('last-modified'))
-            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
-            ?? this.getLatestDocumentDate()
-            ?? null;
+        return (
+            parseDate(this.headers.get('last-modified')) ??
+            parseDate(this.statement(this.url, 'purl:modified')?.object.value) ??
+            this.getLatestDocumentDate() ??
+            null
+        );
     }
 
     protected expandIRI(iri: string): string {
@@ -65,14 +64,11 @@ export default class SolidDocument extends SolidStore {
     }
 
     private getLatestDocumentDate(): Date | null {
-        const dates = [
-            ...this.statements(undefined, 'purl:modified'),
-            ...this.statements(undefined, 'purl:created'),
-        ]
-            .map(statement => parseDate(statement.object.value))
+        const dates = [...this.statements(undefined, 'purl:modified'), ...this.statements(undefined, 'purl:created')]
+            .map((statement) => parseDate(statement.object.value))
             .filter((date): date is Date => date !== null);
 
-        return dates.length > 0 ? dates.reduce((a, b) => a > b ? a : b) : null;
+        return dates.length > 0 ? dates.reduce((a, b) => (a > b ? a : b)) : null;
     }
 
     private getPermissionsFromWAC(type: string): SolidDocumentPermission[] {

package/src/models/SolidStore.ts

@@ -1,9 +1,11 @@
-import type { Quad } from 'rdf-js';
+import type { BlankNode, Literal, NamedNode, Quad, Variable } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 import SolidThing from './SolidThing';
 
+export type Term = NamedNode | Literal | BlankNode | Quad | Variable;
+
 export default class SolidStore {
 
     private quads: Quad[];
@@ -24,21 +26,21 @@ export default class SolidStore {
         this.quads.push(...quads);
     }
 
-    public statements(subject?: string, predicate?: string, object?: string): Quad[] {
+    public statements(subject?: Term | string, predicate?: Term | string, object?: Term | string): Quad[] {
         return this.quads.filter(
-            statement =>
-                (!object || statement.object.value === this.expandIRI(object)) &&
-                (!subject || statement.subject.value === this.expandIRI(subject)) &&
-                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+            (statement) =>
+                (!object || this.termMatches(statement.object, object)) &&
+                (!subject || this.termMatches(statement.subject, subject)) &&
+                (!predicate || this.termMatches(statement.predicate, predicate)),
         );
     }
 
-    public statement(subject?: string, predicate?: string, object?: string): Quad | null {
+    public statement(subject?: Term | string, predicate?: Term | string, object?: Term | string): Quad | null {
         const statement = this.quads.find(
-            statement =>
-                (!object || statement.object.value === this.expandIRI(object)) &&
-                (!subject || statement.subject.value === this.expandIRI(subject)) &&
-                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+            (_statement) =>
+                (!object || this.termMatches(_statement.object, object)) &&
+                (!subject || this.termMatches(_statement.subject, subject)) &&
+                (!predicate || this.termMatches(_statement.predicate, predicate)),
         );
 
         return statement ?? null;
@@ -58,4 +60,12 @@ export default class SolidStore {
         return expandIRI(iri);
     }
 
+    protected termMatches(term: Term, value: Term | string): boolean {
+        if (typeof value === 'string') {
+            return this.expandIRI(value) === term.value;
+        }
+
+        return term.termType === term.termType && term.value === value.value;
+    }
+
 }

package/src/models/SolidThing.ts

@@ -1,6 +1,6 @@
-import type { Quad } from 'rdf-js';
+import type { Quad } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 export default class SolidThing {
 
@@ -13,15 +13,13 @@ export default class SolidThing {
     }
 
     public value(property: string): string | undefined {
-        return this.quads
-            .find(quad => quad.predicate.value === expandIRI(property))
-            ?.object.value;
+        return this.quads.find((quad) => quad.predicate.value === expandIRI(property))?.object.value;
     }
 
     public values(property: string): string[] {
         return this.quads
-            .filter(quad => quad.predicate.value === expandIRI(property))
-            .map(quad => quad.object.value);
+            .filter((quad) => quad.predicate.value === expandIRI(property))
+            .map((quad) => quad.object.value);
     }
 
 }

package/src/models/index.ts

@@ -1,3 +1,5 @@
 export { default as SolidDocument, SolidDocumentPermission } from './SolidDocument';
 export { default as SolidStore } from './SolidStore';
 export { default as SolidThing } from './SolidThing';
+
+export * from './SolidStore';

package/src/{helpers/testing.ts → testing/helpers.ts}

@@ -1,8 +1,14 @@
 import { JSError, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
-import type { JsonLD } from '@/helpers/jsonld';
-import type { Quad, Quad_Object } from 'rdf-js';
+import type { Quad, Quad_Object } from '@rdfjs/types';
 
-import { jsonldToQuads, quadToTurtle, quadsToTurtle, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+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> = {
@@ -19,10 +25,9 @@ class ExpectedQuadAssertionError extends JSError {
 
 function assertExpectedQuadsExist(expectedQuads: Quad[], actualQuads: Quad[]): void {
     for (const expectedQuad of expectedQuads) {
-        const matchingQuad = actualQuads.find(actualQuad => quadEquals(expectedQuad, actualQuad));
+        const matchingQuad = actualQuads.find((actualQuad) => quadEquals(expectedQuad, actualQuad));
 
-        if (!matchingQuad)
-            throw new ExpectedQuadAssertionError(expectedQuad);
+        if (!matchingQuad) throw new ExpectedQuadAssertionError(expectedQuad);
 
         arrayRemove(actualQuads, matchingQuad);
     }
@@ -34,10 +39,7 @@ function containsPatterns(value: string): boolean {
 
 function createPatternRegexp(expected: string): RegExp {
     const patternAliases = [];
-    const patternMatches = stringMatchAll<4, 1 | 2>(
-        expected,
-        /\[\[((.*?)\]\[)?([^\]]+)\]\]/g,
-    );
+    const patternMatches = stringMatchAll<4, 1 | 2>(expected, /\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
     const patterns: string[] = [];
     let expectedRegExp = expected;
 
@@ -65,12 +67,10 @@ function quadValueEquals(expected: string, actual: string): boolean {
 }
 
 function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
-    if (expected.termType !== actual.termType)
-        return false;
+    if (expected.termType !== actual.termType) return false;
 
     if (expected.termType === 'Literal' && actual.termType === 'Literal') {
-        if (expected.datatype.value !== actual.datatype.value)
-            return false;
+        if (expected.datatype.value !== actual.datatype.value) return false;
 
         if (!containsPatterns(expected.value))
             return expected.datatype.value === 'http://www.w3.org/2001/XMLSchema#dateTime'
@@ -82,9 +82,11 @@ function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {
 }
 
 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);
+    return (
+        quadObjectEquals(expected.object, actual.object) &&
+        quadValueEquals(expected.subject.value, actual.subject.value) &&
+        quadValueEquals(expected.predicate.value, actual.predicate.value)
+    );
 }
 
 function resetPatterns(): void {
@@ -119,8 +121,7 @@ export async function jsonldEquals(expected: JsonLD, actual: JsonLD): Promise<Eq
     try {
         assertExpectedQuadsExist(expectedQuads, actualQuads);
     } catch (error) {
-        if (!(error instanceof ExpectedQuadAssertionError))
-            throw error;
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
         return result(false, error.message);
     }
@@ -137,8 +138,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
     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.`);
+        if (!(operation in actualOperations)) return result(false, `Couldn't find expected ${operation} operation.`);
 
         const expectedQuads = pull(expectedOperations, operation);
         const actualQuads = pull(actualOperations, operation);
@@ -149,8 +149,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
         try {
             assertExpectedQuadsExist(expectedQuads, actualQuads);
         } catch (error) {
-            if (!(error instanceof ExpectedQuadAssertionError))
-                throw error;
+            if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
             return result(
                 false,
@@ -160,8 +159,7 @@ export function sparqlEquals(expected: string, actual: string): EqualityResult {
     }
 
     const unexpectedOperation = Object.keys(actualOperations)[0] ?? null;
-    if (unexpectedOperation)
-        return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
+    if (unexpectedOperation) return result(false, `Did not expect to find ${unexpectedOperation} triples.`);
 
     return result(true, 'sparql matches');
 }
@@ -180,8 +178,7 @@ export function turtleEquals(expected: string, actual: string): EqualityResult {
     try {
         assertExpectedQuadsExist(expectedQuads, actualQuads);
     } catch (error) {
-        if (!(error instanceof ExpectedQuadAssertionError))
-            throw error;
+        if (!(error instanceof ExpectedQuadAssertionError)) throw error;
 
         return result(false, error.message);
     }

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);
+    });
+
+});