-
Notifications
You must be signed in to change notification settings - Fork 62
/
SparqlParser-test.js
86 lines (70 loc) · 2.99 KB
/
SparqlParser-test.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
var SparqlParser = require('../sparql').Parser;
var fs = require('fs'),
expect = require('chai').expect;
var queriesPath = __dirname + '/../queries/';
var parsedQueriesPath = __dirname + '/../test/parsedQueries/';
describe('A SPARQL parser', function () {
var parser = new SparqlParser();
// Ensure the same blank node identifiers are used in every test
beforeEach(function () { parser._resetBlanks(); });
var queries = fs.readdirSync(queriesPath);
queries = queries.map(function (q) { return q.replace(/\.sparql$/, ''); });
queries.sort();
queries.forEach(function (query) {
var parsedQueryFile = parsedQueriesPath + query + '.json';
if (!fs.existsSync(parsedQueryFile)) return;
it('should correctly parse query "' + query + '"', function () {
var parsedQuery = parseJSON(fs.readFileSync(parsedQueryFile, 'utf8'));
query = fs.readFileSync(queriesPath + query + '.sparql', 'utf8');
expect(parser.parse(query)).to.deep.equal(parsedQuery);
});
});
it('should throw an error on an invalid query', function () {
var query = 'invalid', error = null;
try { parser.parse(query); }
catch (e) { error = e; }
expect(error).to.exist;
expect(error).to.be.an.instanceof(Error);
expect(error.message).to.include('Parse error on line 1');
});
describe('with pre-defined prefixes', function () {
var prefixes = { a: 'abc#', b: 'def#' };
var parser = new SparqlParser(prefixes);
it('should use those prefixes', function () {
var query = 'SELECT * { a:a b:b "" }';
expect(parser.parse(query).where[0].triples[0])
.to.deep.equal({subject: 'abc#a', predicate: 'def#b', object: '""'});
});
it('should allow temporarily overriding prefixes', function () {
var query = 'PREFIX a: <xyz#> SELECT * { a:a b:b "" }';
expect(parser.parse(query).where[0].triples[0])
.to.deep.equal({subject: 'xyz#a', predicate: 'def#b', object: '""'});
expect(parser.parse('SELECT * { a:a b:b "" }').where[0].triples[0])
.to.deep.equal({subject: 'abc#a', predicate: 'def#b', object: '""'});
});
it('should not change the original prefixes', function () {
expect(prefixes).to.deep.equal({ a: 'abc#', b: 'def#' });
});
it('should not take over changes to the original prefixes', function () {
prefixes.a = 'xyz#';
expect(parser.parse('SELECT * { a:a b:b "" }').where[0].triples[0])
.to.deep.equal({subject: 'abc#a', predicate: 'def#b', object: '""'});
});
});
});
// Parses a JSON object, restoring `undefined` values
function parseJSON(string) {
var object = JSON.parse(string);
return /"\{undefined\}"/.test(string) ? restoreUndefined(object) : object;
}
// Recursively replace values of "{undefined}" by `undefined`
function restoreUndefined(object) {
for (var key in object) {
var item = object[key];
if (typeof item === 'object')
object[key] = restoreUndefined(item);
else if (item === '{undefined}')
object[key] = undefined;
}
return object;
}