@traqula/test-utils 0.0.23 → 0.0.25

package/README.md

@@ -1,5 +1,7 @@
 # Traqula Test utils
 
+[![npm version](https://badge.fury.io/js/@traqula%2Ftest-utils.svg)](https://www.npmjs.com/package/@traqula/test-utils)
+
 Traqula test utils contains some developer dependencies for testing packages and engines from the Traqula project.
 
 ## Installation

package/dist/cjs/lib/Sparql11NotesTest.js

@@ -1,278 +1,260 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Sparql11NotesTest_exports = {};
-__export(Sparql11NotesTest_exports, {
-  importSparql11NoteTests: () => importSparql11NoteTests
-});
-module.exports = __toCommonJS(Sparql11NotesTest_exports);
-var import_vitest = require("vitest");
-function importSparql11NoteTests(parser, dataFactory) {
-  function testErroneousQuery(query, _errorMsg) {
-    return ({ expect }) => {
-      let error;
-      try {
-        parser.parse(query);
-      } catch (e) {
-        error = e;
-      }
-      expect(error).not.toBeUndefined();
-      expect(error).toBeInstanceOf(Error);
-    };
-  }
-  (0, import_vitest.it)("should throw an error on an invalid query", testErroneousQuery("invalid", "Parse error on line 1"));
-  import_vitest.it.skip("should throw an error on a projection of ungrouped variable", testErroneousQuery("PREFIX : <http://www.example.org/> SELECT ?o WHERE { ?s ?p ?o } GROUP BY ?s", "Projection of ungrouped variable (?o)"));
-  (0, import_vitest.it)("should throw an error on a values class with LESS variables than value", testErroneousQuery("SELECT * WHERE { } VALUES ( ?S ) { ( true  false ) }", "Number of dataBlockValues does not match number of variables. Too much values."));
-  (0, import_vitest.it)("should throw an error on a values class with MORE variables than value", testErroneousQuery("SELECT * WHERE { } VALUES ( ?S ?O ) { ( true ) }", "Number of dataBlockValues does not match number of variables. Too few values."));
-  (0, import_vitest.it)("should NOT throw on a values class with correct amount of values", ({ expect }) => {
-    const query = "SELECT * WHERE { } VALUES ( ?S ) { ( true ) }";
-    expect(parser.parse(query)).toMatchObject({});
-  });
-  import_vitest.it.skip("should throw an error on an invalid selectscope", testErroneousQuery("SELECT (1 AS ?X ) { SELECT (2 AS ?X ) {} }", "Target id of 'AS' (?X) already used in subquery"));
-  import_vitest.it.skip("should throw an error on bind to variable in scope", testErroneousQuery("SELECT * { ?s ?p ?o BIND(?o AS ?o) }", "Target id of 'AS' (?X) already used in subquery"));
-  (0, import_vitest.it)("should parse when not ending in newline", ({ expect }) => {
-    const query = "select?s{?s?p?o}#wow, what a query";
-    expect(parser.parse(query)).toMatchObject({});
-  });
-  (0, import_vitest.it)("should preserve BGP and filter pattern order", ({ expect }) => {
-    const query = 'SELECT * { ?s ?p "1" . FILTER(true) . ?s ?p "2"  }';
-    expect(parser.parse(query)).toMatchObject({
-      where: {
-        patterns: [
-          { subType: "bgp" },
-          { subType: "filter" },
-          { subType: "bgp" }
-        ]
-      }
-    });
-  });
-  (0, import_vitest.it)("should throw an error on an aggregate function within an aggregate function", testErroneousQuery("SELECT (SUM(COUNT(?lprice)) AS ?totalPrice) { }", "An aggregate function is not allowed within an aggregate function"));
-  (0, import_vitest.describe)("with pre-defined prefixes", () => {
-    const prefixes = { a: "ex:abc#", b: "ex:def#" };
-    import_vitest.it.skip("should use those prefixes", ({ expect }) => {
-      const query = 'SELECT * { a:a b:b "" }';
-      expect(parser.parse(query, { prefixes })).toMatchObject({
-        where: [
-          {
-            triples: [
-              {
-                subject: dataFactory.namedNode("ex:abc#a"),
-                predicate: dataFactory.namedNode("ex:def#b"),
-                object: dataFactory.literal("")
-              }
-            ]
-          }
-        ]
-      });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSparql11NoteTests = importSparql11NoteTests;
+const vitest_1 = require("vitest");
+function importSparql11NoteTests(parser, DF) {
+    function testErroneousQuery(query, _errorMsg) {
+        return ({ expect }) => {
+            let error;
+            try {
+                parser.parse(query);
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).not.toBeUndefined();
+            expect(error).toBeInstanceOf(Error);
+            // Expect(error.message).toContain(errorMsg);
+        };
+    }
+    (0, vitest_1.it)('should throw an error on an invalid query', testErroneousQuery('invalid', 'Parse error on line 1'));
+    vitest_1.it.skip('should throw an error on a projection of ungrouped variable', testErroneousQuery('PREFIX : <http://www.example.org/> SELECT ?o WHERE { ?s ?p ?o } GROUP BY ?s', 'Projection of ungrouped variable (?o)'));
+    (0, vitest_1.it)('should throw an error on a values class with LESS variables than value', testErroneousQuery('SELECT * WHERE { } VALUES ( ?S ) { ( true  false ) }', 'Number of dataBlockValues does not match number of variables. Too much values.'));
+    (0, vitest_1.it)('should throw an error on a values class with MORE variables than value', testErroneousQuery('SELECT * WHERE { } VALUES ( ?S ?O ) { ( true ) }', 'Number of dataBlockValues does not match number of variables. Too few values.'));
+    (0, vitest_1.it)('should NOT throw on a values class with correct amount of values', ({ expect }) => {
+        const query = 'SELECT * WHERE { } VALUES ( ?S ) { ( true ) }';
+        expect(parser.parse(query)).toMatchObject({});
     });
-    import_vitest.it.skip("should allow temporarily overriding prefixes", ({ expect }) => {
-      const query = 'PREFIX a: <ex:xyz#> SELECT * { a:a b:b "" }';
-      expect(parser.parse(query, { prefixes })).toMatchObject({
-        where: [
-          {
-            triples: [{
-              subject: dataFactory.namedNode("ex:xyz#a"),
-              predicate: dataFactory.namedNode("ex:def#b"),
-              object: dataFactory.literal("")
-            }]
-          }
-        ]
-      });
-      const query2 = 'SELECT * { a:a b:b "" }';
-      expect(parser.parse(query2, { prefixes })).toMatchObject({
-        where: [
-          {
-            triples: [{
-              subject: dataFactory.namedNode("ex:abc#a"),
-              predicate: dataFactory.namedNode("ex:def#b"),
-              object: dataFactory.literal("")
-            }]
-          }
-        ]
-      });
+    vitest_1.it.skip('should throw an error on an invalid selectscope', testErroneousQuery('SELECT (1 AS ?X ) { SELECT (2 AS ?X ) {} }', 'Target id of \'AS\' (?X) already used in subquery'));
+    vitest_1.it.skip('should throw an error on bind to variable in scope', testErroneousQuery('SELECT * { ?s ?p ?o BIND(?o AS ?o) }', 'Target id of \'AS\' (?X) already used in subquery'));
+    (0, vitest_1.it)('should parse when not ending in newline', ({ expect }) => {
+        const query = 'select?s{?s?p?o}#wow, what a query';
+        expect(parser.parse(query)).toMatchObject({});
     });
-    (0, import_vitest.it)("should not change the original prefixes", ({ expect }) => {
-      expect(prefixes).toEqual({ a: "ex:abc#", b: "ex:def#" });
+    (0, vitest_1.it)('should preserve BGP and filter pattern order', ({ expect }) => {
+        const query = 'SELECT * { ?s ?p "1" . FILTER(true) . ?s ?p "2"  }';
+        expect(parser.parse(query)).toMatchObject({
+            where: {
+                patterns: [
+                    { subType: 'bgp' },
+                    { subType: 'filter' },
+                    { subType: 'bgp' },
+                ],
+            },
+        });
     });
-  });
-  (0, import_vitest.describe)("with pre-defined base IRI", () => {
-    const context = { baseIRI: "http://ex.org/" };
-    import_vitest.it.skip("contains the base", ({ expect }) => {
-      const query = "SELECT * { ?s ?p ?o }";
-      expect(parser.parse(query, context)).toMatchObject({
-        base: "http://ex.org/"
-      });
+    (0, vitest_1.it)('should throw an error on an aggregate function within an aggregate function', testErroneousQuery('SELECT (SUM(COUNT(?lprice)) AS ?totalPrice) { }', 'An aggregate function is not allowed within an aggregate function'));
+    (0, vitest_1.describe)('with pre-defined prefixes', () => {
+        const prefixes = { a: 'ex:abc#', b: 'ex:def#' };
+        vitest_1.it.skip('should use those prefixes', ({ expect }) => {
+            const query = 'SELECT * { a:a b:b "" }';
+            expect(parser.parse(query, { prefixes })).toMatchObject({
+                where: [
+                    {
+                        triples: [
+                            {
+                                subject: DF.namedNode('ex:abc#a'),
+                                predicate: DF.namedNode('ex:def#b'),
+                                object: DF.literal(''),
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+        vitest_1.it.skip('should allow temporarily overriding prefixes', ({ expect }) => {
+            const query = 'PREFIX a: <ex:xyz#> SELECT * { a:a b:b "" }';
+            expect(parser.parse(query, { prefixes })).toMatchObject({
+                where: [{
+                        triples: [{
+                                subject: DF.namedNode('ex:xyz#a'),
+                                predicate: DF.namedNode('ex:def#b'),
+                                object: DF.literal(''),
+                            }],
+                    },
+                ],
+            });
+            const query2 = 'SELECT * { a:a b:b "" }';
+            expect(parser.parse(query2, { prefixes })).toMatchObject({
+                where: [{
+                        triples: [{
+                                subject: DF.namedNode('ex:abc#a'),
+                                predicate: DF.namedNode('ex:def#b'),
+                                object: DF.literal(''),
+                            }],
+                    },
+                ],
+            });
+        });
+        (0, vitest_1.it)('should not change the original prefixes', ({ expect }) => {
+            expect(prefixes).toEqual({ a: 'ex:abc#', b: 'ex:def#' });
+        });
     });
-    import_vitest.it.skip("using prefixed as relative iri", ({ expect }) => {
-      const context2 = { baseIRI: "http://ex.org/apl" };
-      const query = `
+    (0, vitest_1.describe)('with pre-defined base IRI', () => {
+        const context = { baseIRI: 'http://ex.org/' };
+        vitest_1.it.skip('contains the base', ({ expect }) => {
+            const query = 'SELECT * { ?s ?p ?o }';
+            expect(parser.parse(query, context)).toMatchObject({
+                base: 'http://ex.org/',
+            });
+        });
+        vitest_1.it.skip('using prefixed as relative iri', ({ expect }) => {
+            const context = { baseIRI: 'http://ex.org/apl' };
+            const query = `
 CONSTRUCT
 FROM <data.ttl>
 WHERE { ?s ?p ?o }
 `;
-      expect(parser.parse(query, context2)).toMatchObject({
-        from: {
-          default: [
-            dataFactory.namedNode("http://ex.org/data.ttl")
-          ]
-        }
-      });
-    });
-    import_vitest.it.skip("should use the base IRI", ({ expect }) => {
-      const query = 'SELECT * { <> <#b> "" }';
-      const result = {
-        subject: dataFactory.namedNode("http://ex.org/"),
-        predicate: dataFactory.namedNode("http://ex.org/#b"),
-        object: dataFactory.literal("")
-      };
-      expect(parser.parse(query, context)).toMatchObject({
-        where: [{ triples: [result] }]
-      });
+            expect(parser.parse(query, context)).toMatchObject({
+                from: {
+                    default: [
+                        DF.namedNode('http://ex.org/data.ttl'),
+                    ],
+                },
+            });
+        });
+        vitest_1.it.skip('should use the base IRI', ({ expect }) => {
+            const query = 'SELECT * { <> <#b> "" }';
+            const result = {
+                subject: DF.namedNode('http://ex.org/'),
+                predicate: DF.namedNode('http://ex.org/#b'),
+                object: DF.literal(''),
+            };
+            expect(parser.parse(query, context)).toMatchObject({
+                where: [{ triples: [result] }],
+            });
+        });
+        vitest_1.it.skip('should work after a previous query failed', ({ expect }) => {
+            const badQuery = 'SELECT * { <> <#b> "" } invalid!';
+            expect(() => parser.parse(badQuery, context)).toThrow(Error);
+            const goodQuery = 'SELECT * { <> <#b> "" }';
+            const context = { baseIRI: 'http://ex2.org/' };
+            const result = {
+                subject: DF.namedNode('http://ex2.org/'),
+                predicate: DF.namedNode('http://ex2.org/#b'),
+                object: DF.literal(''),
+            };
+            const data = parser.parse(goodQuery, context);
+            expect(data).toMatchObject({
+                where: [{ triples: [result] }],
+            });
+        });
     });
-    import_vitest.it.skip("should work after a previous query failed", ({ expect }) => {
-      const badQuery = 'SELECT * { <> <#b> "" } invalid!';
-      expect(() => parser.parse(badQuery, context2)).toThrow(Error);
-      const goodQuery = 'SELECT * { <> <#b> "" }';
-      const context2 = { baseIRI: "http://ex2.org/" };
-      const result = {
-        subject: dataFactory.namedNode("http://ex2.org/"),
-        predicate: dataFactory.namedNode("http://ex2.org/#b"),
-        object: dataFactory.literal("")
-      };
-      const data = parser.parse(goodQuery, context2);
-      expect(data).toMatchObject({
-        where: [{ triples: [result] }]
-      });
-    });
-  });
-  import_vitest.it.skip("should throw an error on relative IRIs if no base IRI is specified", testErroneousQuery("SELECT * { <a> <b> <c> }", "Cannot resolve relative IRI a because no base IRI was set."));
-  (0, import_vitest.describe)("with group collapsing disabled", () => {
-    import_vitest.it.skip("should keep explicit pattern group", ({ expect }) => {
-      const query = "SELECT * WHERE { { ?s ?p ?o } ?a ?b ?c }";
-      const result = [
-        {
-          type: "group",
-          patterns: [
-            {
-              type: "bgp",
-              triples: [
+    vitest_1.it.skip('should throw an error on relative IRIs if no base IRI is specified', testErroneousQuery('SELECT * { <a> <b> <c> }', 'Cannot resolve relative IRI a because no base IRI was set.'));
+    (0, vitest_1.describe)('with group collapsing disabled', () => {
+        vitest_1.it.skip('should keep explicit pattern group', ({ expect }) => {
+            const query = 'SELECT * WHERE { { ?s ?p ?o } ?a ?b ?c }';
+            const result = [
                 {
-                  subject: dataFactory.variable("s"),
-                  predicate: dataFactory.variable("p"),
-                  object: dataFactory.variable("o")
-                }
-              ]
-            }
-          ]
-        },
-        {
-          type: "bgp",
-          triples: [
-            {
-              subject: dataFactory.variable("a"),
-              predicate: dataFactory.variable("b"),
-              object: dataFactory.variable("c")
-            }
-          ]
-        }
-      ];
-      expect(parser.parse(query)).toMatchObject({ where: result });
-    });
-    import_vitest.it.skip("should still collapse immediate union groups", ({ expect }) => {
-      const query = "SELECT * WHERE { { ?s ?p ?o } UNION { ?a ?b ?c } }";
-      const result = [
-        {
-          type: "union",
-          patterns: [{
-            type: "bgp",
-            triples: [{
-              subject: {
-                termType: "Variable",
-                value: "s"
-              },
-              predicate: {
-                termType: "Variable",
-                value: "p"
-              },
-              object: {
-                termType: "Variable",
-                value: "o"
-              }
-            }]
-          }, {
-            type: "bgp",
-            triples: [{
-              subject: {
-                termType: "Variable",
-                value: "a"
-              },
-              predicate: {
-                termType: "Variable",
-                value: "b"
-              },
-              object: {
-                termType: "Variable",
-                value: "c"
-              }
-            }]
-          }]
-        }
-      ];
-      expect(parser.parse(query)).toMatchObject({ where: result });
-    });
-  });
-  (0, import_vitest.describe)("for update queries", () => {
-    (0, import_vitest.it)("should throw an error on blank nodes in DELETE clause", testErroneousQuery('DELETE { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }', "Detected illegal blank node in BGP"));
-    (0, import_vitest.it)("should not throw on blank nodes in INSERT clause", ({ expect }) => {
-      const query = 'INSERT { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }';
-      expect(parser.parse(query)).toMatchObject({});
-    });
-    (0, import_vitest.it)("should throw an error on blank nodes in compact DELETE clause", testErroneousQuery("DELETE WHERE { _:a <ex:p> <ex:o> }", "Detected illegal blank node in BGP"));
-    (0, import_vitest.it)("should throw an error on variables in DELETE DATA clause", testErroneousQuery("DELETE DATA { ?a <ex:p> <ex:o> }", "Detected illegal variable in BGP"));
-    (0, import_vitest.it)("should throw an error on blank nodes in DELETE DATA clause", testErroneousQuery("DELETE DATA { _:a <ex:p> <ex:o> }", "Detected illegal blank node in BGP"));
-    (0, import_vitest.it)("should throw an error on variables in DELETE DATA clause with GRAPH", testErroneousQuery("DELETE DATA { GRAPH ?a { <ex:s> <ex:p> <ex:o> } }", "Detected illegal variable in GRAPH"));
-    (0, import_vitest.it)("should throw an error on variables in INSERT DATA clause", testErroneousQuery("INSERT DATA { ?a <ex:p> <ex:o> }", "Detected illegal variable in BGP"));
-    (0, import_vitest.it)("should not throw on reused blank nodes in one INSERT DATA clause", ({ expect }) => {
-      const query = "INSERT DATA { _:a <ex:p> <ex:o> . _:a <ex:p> <ex:o> . }";
-      expect(parser.parse(query)).toMatchObject({});
+                    type: 'group',
+                    patterns: [
+                        {
+                            type: 'bgp',
+                            triples: [
+                                {
+                                    subject: DF.variable('s'),
+                                    predicate: DF.variable('p'),
+                                    object: DF.variable('o'),
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    type: 'bgp',
+                    triples: [
+                        {
+                            subject: DF.variable('a'),
+                            predicate: DF.variable('b'),
+                            object: DF.variable('c'),
+                        },
+                    ],
+                },
+            ];
+            expect(parser.parse(query)).toMatchObject({ where: result });
+        });
+        vitest_1.it.skip('should still collapse immediate union groups', ({ expect }) => {
+            const query = 'SELECT * WHERE { { ?s ?p ?o } UNION { ?a ?b ?c } }';
+            const result = [
+                {
+                    type: 'union',
+                    patterns: [{
+                            type: 'bgp',
+                            triples: [{
+                                    subject: {
+                                        termType: 'Variable',
+                                        value: 's',
+                                    },
+                                    predicate: {
+                                        termType: 'Variable',
+                                        value: 'p',
+                                    },
+                                    object: {
+                                        termType: 'Variable',
+                                        value: 'o',
+                                    },
+                                }],
+                        }, {
+                            type: 'bgp',
+                            triples: [{
+                                    subject: {
+                                        termType: 'Variable',
+                                        value: 'a',
+                                    },
+                                    predicate: {
+                                        termType: 'Variable',
+                                        value: 'b',
+                                    },
+                                    object: {
+                                        termType: 'Variable',
+                                        value: 'c',
+                                    },
+                                }],
+                        }],
+                },
+            ];
+            expect(parser.parse(query)).toMatchObject({ where: result });
+        });
     });
-    import_vitest.it.skip("should throw an error on reused blank nodes across INSERT DATA clauses", testErroneousQuery("INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { _:a <ex:p> <ex:o> }", "Detected reuse blank node across different INSERT DATA clauses"));
-    import_vitest.it.skip("should throw an error on reused blank nodes across INSERT DATA clauses with GRAPH", testErroneousQuery("INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { GRAPH <ex:g> { _:a <ex:p> <ex:o> } }", "Detected reuse blank node across different INSERT DATA clauses"));
-    (0, import_vitest.it)("should not throw on comment between INSERT and DATA", ({ expect }) => {
-      const query = `INSERT
+    (0, vitest_1.describe)('for update queries', () => {
+        (0, vitest_1.it)('should throw an error on blank nodes in DELETE clause', testErroneousQuery('DELETE { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }', 'Detected illegal blank node in BGP'));
+        (0, vitest_1.it)('should not throw on blank nodes in INSERT clause', ({ expect }) => {
+            const query = 'INSERT { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> "Alan" . }';
+            // TODO: add proper test
+            expect(parser.parse(query)).toMatchObject({});
+        });
+        (0, vitest_1.it)('should throw an error on blank nodes in compact DELETE clause', testErroneousQuery('DELETE WHERE { _:a <ex:p> <ex:o> }', 'Detected illegal blank node in BGP'));
+        (0, vitest_1.it)('should throw an error on variables in DELETE DATA clause', testErroneousQuery('DELETE DATA { ?a <ex:p> <ex:o> }', 'Detected illegal variable in BGP'));
+        (0, vitest_1.it)('should throw an error on blank nodes in DELETE DATA clause', testErroneousQuery('DELETE DATA { _:a <ex:p> <ex:o> }', 'Detected illegal blank node in BGP'));
+        (0, vitest_1.it)('should throw an error on variables in DELETE DATA clause with GRAPH', testErroneousQuery('DELETE DATA { GRAPH ?a { <ex:s> <ex:p> <ex:o> } }', 'Detected illegal variable in GRAPH'));
+        (0, vitest_1.it)('should throw an error on variables in INSERT DATA clause', testErroneousQuery('INSERT DATA { ?a <ex:p> <ex:o> }', 'Detected illegal variable in BGP'));
+        (0, vitest_1.it)('should not throw on reused blank nodes in one INSERT DATA clause', ({ expect }) => {
+            const query = 'INSERT DATA { _:a <ex:p> <ex:o> . _:a <ex:p> <ex:o> . }';
+            // Todo: add proper test
+            expect(parser.parse(query)).toMatchObject({});
+        });
+        vitest_1.it.skip('should throw an error on reused blank nodes across INSERT DATA clauses', testErroneousQuery('INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { _:a <ex:p> <ex:o> }', 'Detected reuse blank node across different INSERT DATA clauses'));
+        vitest_1.it.skip('should throw an error on reused blank nodes across INSERT DATA clauses with GRAPH', testErroneousQuery('INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { GRAPH <ex:g> { _:a <ex:p> <ex:o> } }', 'Detected reuse blank node across different INSERT DATA clauses'));
+        (0, vitest_1.it)('should not throw on comment between INSERT and DATA', ({ expect }) => {
+            const query = `INSERT
 # Comment
 DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;
-      expect(parser.parse(query)).toMatchObject({});
-    });
-    (0, import_vitest.it)("should not throw on comment after INSERT that could be confused with DATA", ({ expect }) => {
-      const query = `INSERT # DATA
+            // TODO: add proper test
+            expect(parser.parse(query)).toMatchObject({});
+        });
+        (0, vitest_1.it)('should not throw on comment after INSERT that could be confused with DATA', ({ expect }) => {
+            const query = `INSERT # DATA
 DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;
-      expect(parser.parse(query)).toMatchObject({});
+            // TODO: add proper test
+            expect(parser.parse(query)).toMatchObject({});
+        });
+        (0, vitest_1.it)('should throw an error on commented DATA after INSERT', testErroneousQuery('INSERT # DATA { GRAPH <ex:G> { <ex:s> <ex:p> \'o1\', \'o2\', \'o3\' } }', 'Parse error'));
+    });
+    (0, vitest_1.it)('should throw an error on unicode codepoint escaping in literal with partial surrogate pair', testErroneousQuery('SELECT * WHERE { ?s <ex:p> \'\uD800\' }', 'Invalid unicode codepoint of surrogate pair without corresponding codepoint'));
+    (0, vitest_1.it)('should not throw an error on unicode codepoint escaping in literal with complete surrogate pair', ({ expect }) => {
+        const query = 'SELECT * WHERE { ?s <ex:p> \'\uD800\uDFFF\' }';
+        // TODO: add proper test
+        expect(parser.parse(query)).toMatchObject({});
     });
-    (0, import_vitest.it)("should throw an error on commented DATA after INSERT", testErroneousQuery("INSERT # DATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }", "Parse error"));
-  });
-  (0, import_vitest.it)("should throw an error on unicode codepoint escaping in literal with partial surrogate pair", testErroneousQuery("SELECT * WHERE { ?s <ex:p> '\uD800' }", "Invalid unicode codepoint of surrogate pair without corresponding codepoint"));
-  (0, import_vitest.it)("should not throw an error on unicode codepoint escaping in literal with complete surrogate pair", ({ expect }) => {
-    const query = "SELECT * WHERE { ?s <ex:p> '\u{103FF}' }";
-    expect(parser.parse(query)).toMatchObject({});
-  });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  importSparql11NoteTests
-});
+//# sourceMappingURL=Sparql11NotesTest.js.map

package/dist/cjs/lib/Sparql11NotesTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sparql11NotesTest.js","sourceRoot":"","sources":["../../../lib/Sparql11NotesTest.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BaseQuad } from '@rdfjs/types';\nimport type { DataFactory } from 'rdf-data-factory';\nimport { describe, it } from 'vitest';\nimport type { TestFunction } from 'vitest';\n\ninterface Parser {\n  parse: (query: string, context?: { prefixes?: Record<string, string>; baseIRI?: string }) => unknown;\n}\n\nexport function importSparql11NoteTests(parser: Parser, DF: DataFactory<BaseQuad>): void {\n  function testErroneousQuery(query: string, _errorMsg: string): TestFunction<object> {\n    return ({ expect }) => {\n      let error: any;\n      try {\n        parser.parse(query);\n      } catch (e) {\n        error = e;\n      }\n      expect(error).not.toBeUndefined();\n      expect(error).toBeInstanceOf(Error);\n      // Expect(error.message).toContain(errorMsg);\n    };\n  }\n\n  it('should throw an error on an invalid query', testErroneousQuery('invalid', 'Parse error on line 1'));\n\n  it.skip('should throw an error on a projection of ungrouped variable', testErroneousQuery(\n    'PREFIX : <http://www.example.org/> SELECT ?o WHERE { ?s ?p ?o } GROUP BY ?s',\n    'Projection of ungrouped variable (?o)',\n  ));\n\n  it('should throw an error on a values class with LESS variables than value', testErroneousQuery(\n    'SELECT * WHERE { } VALUES ( ?S ) { ( true  false ) }',\n    'Number of dataBlockValues does not match number of variables. Too much values.',\n  ));\n\n  it('should throw an error on a values class with MORE variables than value', testErroneousQuery(\n    'SELECT * WHERE { } VALUES ( ?S ?O ) { ( true ) }',\n    'Number of dataBlockValues does not match number of variables. Too few values.',\n  ));\n\n  it('should NOT throw on a values class with correct amount of values', ({ expect }) => {\n    const query = 'SELECT * WHERE { } VALUES ( ?S ) { ( true ) }';\n    expect(parser.parse(query)).toMatchObject({});\n  });\n\n  it.skip('should throw an error on an invalid selectscope', testErroneousQuery(\n    'SELECT (1 AS ?X ) { SELECT (2 AS ?X ) {} }',\n    'Target id of \\'AS\\' (?X) already used in subquery',\n  ));\n\n  it.skip('should throw an error on bind to variable in scope', testErroneousQuery(\n    'SELECT * { ?s ?p ?o BIND(?o AS ?o) }',\n    'Target id of \\'AS\\' (?X) already used in subquery',\n  ));\n\n  it('should parse when not ending in newline', ({ expect }) => {\n    const query = 'select?s{?s?p?o}#wow, what a query';\n    expect(parser.parse(query)).toMatchObject({});\n  });\n\n  it('should preserve BGP and filter pattern order', ({ expect }) => {\n    const query = 'SELECT * { ?s ?p \"1\" . FILTER(true) . ?s ?p \"2\"  }';\n    expect(parser.parse(query)).toMatchObject({\n      where: {\n        patterns: [\n          { subType: 'bgp' },\n          { subType: 'filter' },\n          { subType: 'bgp' },\n        ],\n      },\n    });\n  });\n\n  it('should throw an error on an aggregate function within an aggregate function', testErroneousQuery(\n    'SELECT (SUM(COUNT(?lprice)) AS ?totalPrice) { }',\n    'An aggregate function is not allowed within an aggregate function',\n  ));\n\n  describe('with pre-defined prefixes', () => {\n    const prefixes = { a: 'ex:abc#', b: 'ex:def#' };\n\n    it.skip('should use those prefixes', ({ expect }) => {\n      const query = 'SELECT * { a:a b:b \"\" }';\n      expect(parser.parse(query, { prefixes })).toMatchObject({\n        where: [\n          {\n            triples: [\n              {\n                subject: DF.namedNode('ex:abc#a'),\n                predicate: DF.namedNode('ex:def#b'),\n                object: DF.literal(''),\n              },\n            ],\n          },\n        ],\n      });\n    });\n\n    it.skip('should allow temporarily overriding prefixes', ({ expect }) => {\n      const query = 'PREFIX a: <ex:xyz#> SELECT * { a:a b:b \"\" }';\n      expect(parser.parse(query, { prefixes })).toMatchObject({\n        where: [{\n          triples: [{\n            subject: DF.namedNode('ex:xyz#a'),\n            predicate: DF.namedNode('ex:def#b'),\n            object: DF.literal(''),\n          }],\n        },\n        ],\n      });\n\n      const query2 = 'SELECT * { a:a b:b \"\" }';\n      expect(parser.parse(query2, { prefixes })).toMatchObject({\n        where: [{\n          triples: [{\n            subject: DF.namedNode('ex:abc#a'),\n            predicate: DF.namedNode('ex:def#b'),\n            object: DF.literal(''),\n          }],\n        },\n        ],\n      });\n    });\n\n    it('should not change the original prefixes', ({ expect }) => {\n      expect(prefixes).toEqual({ a: 'ex:abc#', b: 'ex:def#' });\n    });\n  });\n\n  describe('with pre-defined base IRI', () => {\n    const context = { baseIRI: 'http://ex.org/' };\n\n    it.skip('contains the base', ({ expect }) => {\n      const query = 'SELECT * { ?s ?p ?o }';\n      expect(parser.parse(query, context)).toMatchObject({\n        base: 'http://ex.org/',\n      });\n    });\n\n    it.skip('using prefixed as relative iri', ({ expect }) => {\n      const context = { baseIRI: 'http://ex.org/apl' };\n      const query = `\nCONSTRUCT\nFROM <data.ttl>\nWHERE { ?s ?p ?o }\n`;\n      expect(parser.parse(query, context)).toMatchObject({\n        from: {\n          default: [\n            DF.namedNode('http://ex.org/data.ttl'),\n          ],\n        },\n      });\n    });\n\n    it.skip('should use the base IRI', ({ expect }) => {\n      const query = 'SELECT * { <> <#b> \"\" }';\n      const result = {\n        subject: DF.namedNode('http://ex.org/'),\n        predicate: DF.namedNode('http://ex.org/#b'),\n        object: DF.literal(''),\n      };\n\n      expect(parser.parse(query, context)).toMatchObject({\n        where: [{ triples: [ result ]}],\n      });\n    });\n\n    it.skip('should work after a previous query failed', ({ expect }) => {\n      const badQuery = 'SELECT * { <> <#b> \"\" } invalid!';\n      expect(() => parser.parse(badQuery, context)).toThrow(Error);\n\n      const goodQuery = 'SELECT * { <> <#b> \"\" }';\n\n      const context = { baseIRI: 'http://ex2.org/' };\n      const result = {\n        subject: DF.namedNode('http://ex2.org/'),\n        predicate: DF.namedNode('http://ex2.org/#b'),\n        object: DF.literal(''),\n      };\n      const data = parser.parse(goodQuery, context);\n      expect(data).toMatchObject({\n        where: [{ triples: [ result ]}],\n      });\n    });\n  });\n\n  it.skip('should throw an error on relative IRIs if no base IRI is specified', testErroneousQuery(\n    'SELECT * { <a> <b> <c> }',\n    'Cannot resolve relative IRI a because no base IRI was set.',\n  ));\n\n  describe('with group collapsing disabled', () => {\n    it.skip('should keep explicit pattern group', ({ expect }) => {\n      const query = 'SELECT * WHERE { { ?s ?p ?o } ?a ?b ?c }';\n      const result = [\n        {\n          type: 'group',\n          patterns: [\n            {\n              type: 'bgp',\n              triples: [\n                {\n                  subject: DF.variable('s'),\n                  predicate: DF.variable('p'),\n                  object: DF.variable('o'),\n                },\n              ],\n            },\n          ],\n        },\n        {\n          type: 'bgp',\n          triples: [\n            {\n              subject: DF.variable('a'),\n              predicate: DF.variable('b'),\n              object: DF.variable('c'),\n            },\n          ],\n        },\n      ];\n\n      expect(parser.parse(query)).toMatchObject({ where: result });\n    });\n\n    it.skip('should still collapse immediate union groups', ({ expect }) => {\n      const query = 'SELECT * WHERE { { ?s ?p ?o } UNION { ?a ?b ?c } }';\n\n      const result = [\n        {\n          type: 'union',\n          patterns: [{\n            type: 'bgp',\n            triples: [{\n              subject: {\n                termType: 'Variable',\n                value: 's',\n              },\n              predicate: {\n                termType: 'Variable',\n                value: 'p',\n              },\n              object: {\n                termType: 'Variable',\n                value: 'o',\n              },\n            }],\n          }, {\n            type: 'bgp',\n            triples: [{\n              subject: {\n                termType: 'Variable',\n                value: 'a',\n              },\n              predicate: {\n                termType: 'Variable',\n                value: 'b',\n              },\n              object: {\n                termType: 'Variable',\n                value: 'c',\n              },\n            }],\n          }],\n        },\n      ];\n\n      expect(parser.parse(query)).toMatchObject({ where: result });\n    });\n  });\n\n  describe('for update queries', () => {\n    it('should throw an error on blank nodes in DELETE clause', testErroneousQuery(\n      'DELETE { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> \"Alan\" . }',\n      'Detected illegal blank node in BGP',\n    ));\n\n    it('should not throw on blank nodes in INSERT clause', ({ expect }) => {\n      const query = 'INSERT { ?a <ex:knows> [] . } WHERE { ?a <ex:knows> \"Alan\" . }';\n      // TODO: add proper test\n      expect(parser.parse(query)).toMatchObject({});\n    });\n\n    it('should throw an error on blank nodes in compact DELETE clause', testErroneousQuery(\n      'DELETE WHERE { _:a <ex:p> <ex:o> }',\n      'Detected illegal blank node in BGP',\n    ));\n\n    it('should throw an error on variables in DELETE DATA clause', testErroneousQuery(\n      'DELETE DATA { ?a <ex:p> <ex:o> }',\n      'Detected illegal variable in BGP',\n    ));\n\n    it('should throw an error on blank nodes in DELETE DATA clause', testErroneousQuery(\n      'DELETE DATA { _:a <ex:p> <ex:o> }',\n      'Detected illegal blank node in BGP',\n    ));\n\n    it('should throw an error on variables in DELETE DATA clause with GRAPH', testErroneousQuery(\n      'DELETE DATA { GRAPH ?a { <ex:s> <ex:p> <ex:o> } }',\n      'Detected illegal variable in GRAPH',\n    ));\n\n    it('should throw an error on variables in INSERT DATA clause', testErroneousQuery(\n      'INSERT DATA { ?a <ex:p> <ex:o> }',\n      'Detected illegal variable in BGP',\n    ));\n\n    it('should not throw on reused blank nodes in one INSERT DATA clause', ({ expect }) => {\n      const query = 'INSERT DATA { _:a <ex:p> <ex:o> . _:a <ex:p> <ex:o> . }';\n      // Todo: add proper test\n      expect(parser.parse(query)).toMatchObject({});\n    });\n\n    it.skip('should throw an error on reused blank nodes across INSERT DATA clauses', testErroneousQuery(\n      'INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { _:a <ex:p> <ex:o> }',\n      'Detected reuse blank node across different INSERT DATA clauses',\n    ));\n\n    it.skip('should throw an error on reused blank nodes across INSERT DATA clauses with GRAPH', testErroneousQuery(\n      'INSERT DATA { _:a <ex:p> <ex:o> }; INSERT DATA { GRAPH <ex:g> { _:a <ex:p> <ex:o> } }',\n      'Detected reuse blank node across different INSERT DATA clauses',\n    ));\n\n    it('should not throw on comment between INSERT and DATA', ({ expect }) => {\n      const query = `INSERT\n# Comment\nDATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;\n      // TODO: add proper test\n      expect(parser.parse(query)).toMatchObject({});\n    });\n\n    it('should not throw on comment after INSERT that could be confused with DATA', ({ expect }) => {\n      const query = `INSERT # DATA\nDATA { GRAPH <ex:G> { <ex:s> <ex:p> 'o1', 'o2', 'o3' } }`;\n      // TODO: add proper test\n      expect(parser.parse(query)).toMatchObject({});\n    });\n\n    it('should throw an error on commented DATA after INSERT', testErroneousQuery(\n      'INSERT # DATA { GRAPH <ex:G> { <ex:s> <ex:p> \\'o1\\', \\'o2\\', \\'o3\\' } }',\n      'Parse error',\n    ));\n  });\n\n  it('should throw an error on unicode codepoint escaping in literal with partial surrogate pair', testErroneousQuery(\n    'SELECT * WHERE { ?s <ex:p> \\'\\uD800\\' }',\n    'Invalid unicode codepoint of surrogate pair without corresponding codepoint',\n  ));\n\n  it(\n    'should not throw an error on unicode codepoint escaping in literal with complete surrogate pair',\n    ({ expect }) => {\n      const query = 'SELECT * WHERE { ?s <ex:p> \\'\\uD800\\uDFFF\\' }';\n      // TODO: add proper test\n      expect(parser.parse(query)).toMatchObject({});\n    },\n  );\n}\n"]}