jest-rdf/lib/matchers/toBeRdfIsomorphic.js

Jest utilities for RDF(JS)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDiff = getDiff;
exports.unGroundHashes = unGroundHashes;
exports.getBnodeDiff = getBnodeDiff;
const rdf_isomorphic_1 = require("rdf-isomorphic");
const rdf_string_1 = require("rdf-string");
const rdf_terms_1 = require("rdf-terms");
function getNonBlankDiff(a1, a2) {
    return a1.filter(quad => (0, rdf_terms_1.everyTerms)(quad, term => term.termType !== 'BlankNode')
        && a2.every(q2 => !q2.equals(quad)));
}
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;
}
function unGroundHashes(graph) {
    return (0, rdf_isomorphic_1.hashTerms)((0, rdf_isomorphic_1.uniqGraph)((0, rdf_isomorphic_1.getQuadsWithBlankNodes)(graph)), (0, rdf_isomorphic_1.getGraphBlankNodes)(graph), {})[1];
}
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 = (0, rdf_isomorphic_1.uniqGraph)((0, rdf_isomorphic_1.getQuadsWithBlankNodes)(receivedQuads));
    const blankB = (0, rdf_isomorphic_1.uniqGraph)((0, rdf_isomorphic_1.getQuadsWithBlankNodes)(expectedQuads));
    const received = {};
    const expected = {};
    for (const elem of getDiff(ungroundedHashesA, ungroundedHashesB)) {
        received[elem] = blankA.filter(quad => (0, rdf_terms_1.someTerms)(quad, (term) => term.termType === 'BlankNode' && term.value === elem.slice(2)));
    }
    for (const elem of getDiff(ungroundedHashesB, ungroundedHashesA)) {
        expected[elem] = blankB.filter(quad => (0, rdf_terms_1.someTerms)(quad, (term) => term.termType === 'BlankNode' && term.value === elem.slice(2)));
    }
    return {
        received, expected
    };
}
function quadArrayToString(quadArray) {
    return '[\n' + quadArray.map((quad) => '  ' + JSON.stringify((0, rdf_string_1.quadToStringQuad)(quad))).join(',\n') + '\n]';
}
exports.default = {
    toBeRdfIsomorphic(received, actual) {
        const receivedArray = [...received];
        const actualArray = [...actual];
        if (!(0, rdf_isomorphic_1.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,
        };
    },
};
//# sourceMappingURL=toBeRdfIsomorphic.js.map