Test base units of modelToQuery (#455)

Author: jgonggrijp

frontend/src/semantic-search/modelToQuery-test.ts

@@ -0,0 +1,198 @@
+import { each } from 'lodash';
+
+import { startStore, endStore } from '../test-util';
+import mockOntology from '../mock-data/mock-ontology';
+
+import Model from '../core/model';
+import Collection from '../core/collection';
+import { rdf, rdfs, owl, xsd, readit } from '../common-rdf/ns';
+import Node from '../common-rdf/node';
+import Graph from '../common-rdf/graph';
+
+import modelToQuery, {
+    serializeIri,
+    serializeLiteral,
+    serializePredicate,
+    serializeExpression,
+    combineAnd,
+    combineOr,
+} from './modelToQuery';
+
+describe('semantic search query serialization', function() {
+    beforeEach(startStore);
+    beforeEach(function() {
+        this.ontology = new Graph(mockOntology);
+    });
+    afterEach(endStore);
+
+    describe('serializeIri', function() {
+        it('puts an IRI between angle brackets by default', function() {
+            expect(serializeIri(rdfs.range, {})).toBe(`<${rdfs.range}>`);
+        });
+
+        it('applies a namespace abbreviation when available', function() {
+            expect(serializeIri(rdfs.range, { r: rdfs() })).toBe('r:range');
+        });
+
+        it('ignores irrelevant namespaces', function() {
+            expect(serializeIri(rdfs.range, {
+                o: owl(),
+            })).toBe(`<${rdfs.range}>`);
+            expect(serializeIri(rdfs.range, {
+                r: rdfs(),
+                o: owl(),
+            })).toBe('r:range');
+        });
+    });
+
+    describe('serializeLiteral', function() {
+        it('serializes numbers', function() {
+            expect(serializeLiteral('123', xsd.integer, {})).toBe('123');
+            expect(serializeLiteral('12.3', xsd.decimal, {})).toBe('12.3');
+            expect(serializeLiteral('.123', xsd.double, {})).toBe('.123');
+        });
+
+        it('serializes strings', function() {
+            expect(serializeLiteral('abc', xsd.string, {})).toBe('"abc"');
+        });
+
+        it('serializes dates', function() {
+            expect(
+                serializeLiteral('2021-06-01', xsd.dateTime, {})
+            ).toBe(`"2021-06-01"^^<${xsd.dateTime}>`);
+            expect(
+                serializeLiteral('2021-06-01', xsd.dateTime, { x: xsd() })
+            ).toBe('"2021-06-01"^^x:dateTime');
+        });
+    });
+
+    describe('serializePredicate', function() {
+        beforeEach(function() {
+            this.property = this.ontology.find({'@type': rdf.Property});
+            expect(this.property).toBeDefined();
+        });
+
+        it('behaves like serializeIri for direct properties', function() {
+            const pr = this.property;
+            const id = pr.id;
+            each([{}, {r: readit()}], function(ns) {
+                expect(serializePredicate(pr, ns)).toBe(serializeIri(id, ns));
+            });
+        });
+
+        it('uses caret notation for inverse properties', function() {
+            const pr = this.property;
+            const id = pr.id;
+            const inv = new Node({ [owl.inverseOf]: pr });
+            each([{}, {r: readit()}], function(ns) {
+                expect(serializePredicate(inv, ns))
+                    .toBe(`^${serializeIri(id, ns)}`);
+            });
+        });
+    });
+
+    describe('serializeExpression', function() {
+        it('supports binary operator expressions', function() {
+            const filter = new Model({ operator: '+' });
+            const args = ['1', '2'];
+            expect(serializeExpression(filter, args).expression)
+                .toBe('(1 + 2)');
+        });
+
+        it('supports unary function calls', function() {
+            const filter = new Model({ function: 'testme' });
+            const args = ['"abc"'];
+            expect(serializeExpression(filter, args).expression)
+                .toBe('testme("abc")');
+        });
+
+        it('supports binary function calls', function() {
+            const filter = new Model({ function: 'testme' });
+            const args = ['1', '2'];
+            expect(serializeExpression(filter, args).expression)
+                .toBe('testme(1, 2)');
+        });
+    });
+
+    describe('combineAnd', function() {
+        it('joins expressions', function() {
+            expect(combineAnd({ expression: [{
+                tag: 'expression',
+                expression: '(1 < 2)',
+            }, {
+                tag: 'expression',
+                expression: '(3 < 4)',
+            }]})).toEqual({
+                tag: 'expression',
+                expression: '((1 < 2) && (3 < 4))',
+            });
+        });
+
+        it('joins patterns', function() {
+            expect(combineAnd({ pattern: [{
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\n',
+            }, {
+                tag: 'pattern',
+                pattern: '?d ?e ?f.\n',
+            }]})).toEqual({
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\n?d ?e ?f.\n',
+            });
+        });
+
+        it('joins mixtures of patterns and expressions', function() {
+            expect(combineAnd({ expression: [{
+                tag: 'expression',
+                expression: '(1 < 2)',
+            }], pattern: [{
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\n',
+            }]})).toEqual({
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\nFILTER (1 < 2)\n',
+            });
+        });
+    });
+
+    describe('combineOr', function() {
+        it('joins expressions', function() {
+            expect(combineOr({ expression: [{
+                tag: 'expression',
+                expression: '(1 < 2)',
+            }, {
+                tag: 'expression',
+                expression: '(3 < 4)',
+            }]})).toEqual({
+                tag: 'expression',
+                expression: '((1 < 2) || (3 < 4))',
+            });
+        });
+
+        it('joins patterns', function() {
+            expect(combineOr({ pattern: [{
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\n',
+            }, {
+                tag: 'pattern',
+                pattern: '?d ?e ?f.\n',
+            }]})).toEqual({
+                tag: 'pattern',
+                pattern: '{\n?a ?b ?c.\n} UNION {\n?d ?e ?f.\n}\n',
+            });
+        });
+
+        it('joins mixtures of patterns and expressions', function() {
+            expect(combineOr({ expression: [{
+                tag: 'expression',
+                expression: '(1 < 2)',
+            }], pattern: [{
+                tag: 'pattern',
+                pattern: '?a ?b ?c.\n',
+            }]})).toEqual({
+                tag: 'expression',
+                expression: '((1 < 2) || EXISTS {\n?a ?b ?c.\n})',
+            });
+        });
+    });
+});

frontend/src/semantic-search/modelToQuery.ts

@@ -50,7 +50,7 @@ export function serializeIri(iri: string, ns: nsTable): string {
     return short || `<${iri}>`;
 }
 
-function serializeLiteral(
+export function serializeLiteral(
     literal: string, datatype: string, ns: nsTable
 ): string {
     switch (datatype) {
@@ -66,7 +66,7 @@ function nextVariable(): string {
     return uniqueId('?x');
 }
 
-function serializePredicate(predicate: Node, ns: nsTable): string {
+export function serializePredicate(predicate: Node, ns: nsTable): string {
     const inverse = predicate.get(owl.inverseOf) as Node[];
     if (inverse && inverse.length) return `^${serializeIri(inverse[0].id, ns)}`;
     return serializeIri(predicate.id, ns);
@@ -84,7 +84,7 @@ function tagPattern(pattern: string): TaggedPattern {
     return { tag: 'pattern', pattern };
 }
 
-function serializeExpression(filter: Model, args: string[]): TaggedExpression {
+export function serializeExpression(filter: Model, args: string[]): TaggedExpression {
     const func = filter.get('function') || '';
     const op = filter.get('operator');
     const sep = op ? ` ${op} ` : ', ';
@@ -103,7 +103,7 @@ function joinTagged<K extends keyof Branches>(key: K) {
 const joinE = joinTagged('expression');
 const joinP = joinTagged('pattern');
 
-function combineAnd({ expression, pattern }: Branches): TaggedSyntax {
+export function combineAnd({ expression, pattern }: Branches): TaggedSyntax {
     const exp = expression ? `(${joinE(expression, ' && ')})` : '';
     const pat = pattern ? joinP(pattern, '') : '';
     if (exp) {
@@ -113,7 +113,7 @@ function combineAnd({ expression, pattern }: Branches): TaggedSyntax {
     return tagPattern(pat);
 }
 
-function combineOr({ expression, pattern }: Branches): TaggedSyntax {
+export function combineOr({ expression, pattern }: Branches): TaggedSyntax {
     if (expression) {
         const patExp = pattern ? map(pattern, patternAsExpression) : [];
         return tagExpression(`${joinE(expression.concat(patExp), ' || ')}`);