n3 0.4.2 → 0.5.0

package/test/N3Store-test.js

@@ -1,6 +1,6 @@
 var N3Store = require('../N3').Store;
-var chai = require('chai'),
-    expect = chai.expect;
+var chai = require('chai');
+var expect = chai.expect;
 chai.should();
 chai.use(require('chai-things'));
 
@@ -30,57 +30,126 @@ describe('N3Store', function () {
       store.find().should.be.empty;
     });
 
-    it('should be able to create unnamed blank nodes', function () {
+    it('should be able to generate unnamed blank nodes', function () {
       store.createBlankNode().should.eql('_:b0');
       store.createBlankNode().should.eql('_:b1');
 
-      store.addTriple('_:b0', '_:b1', '_:b2');
+      store.addTriple('_:b0', '_:b1', '_:b2').should.be.true;
       store.createBlankNode().should.eql('_:b3');
     });
 
-    it('should be able to create named blank nodes', function () {
+    it('should be able to generate named blank nodes', function () {
       store.createBlankNode('blank').should.eql('_:blank');
       store.createBlankNode('blank').should.eql('_:blank1');
       store.createBlankNode('blank').should.eql('_:blank2');
     });
+
+    it('should be able to store triples with generated blank nodes', function () {
+      store.addTriple(store.createBlankNode('x'), 'b', 'c').should.be.true;
+      shouldIncludeAll(store.find(null, 'b'), ['_:x1', 'b', 'd']);
+    });
+  });
+
+  describe('An N3Store without a configured default graph', function () {
+    var store = new N3Store();
+
+    it('should have a dummy default graph', function () {
+      store.defaultGraph.should.eql('http://example.org/#defaultGraph');
+    });
+  });
+
+  describe('An N3Store with a configured default graph', function () {
+    var dg = 'http://example.org/#defaultGraph';
+    var store = new N3Store({ defaultGraph: dg });
+
+    it('should return that configured default graph', function () {
+      store.defaultGraph.should.eql(dg);
+    });
   });
 
   describe('An N3Store with initialized with 3 elements', function () {
     var store = new N3Store([
-      { subject: 's1', predicate: 'p1', object: 'o1'},
-      { subject: 's1', predicate: 'p1', object: 'o2'},
-      { subject: 's1', predicate: 'p1', object: 'o3'},
+      { subject: 's1', predicate: 'p1', object: 'o1' },
+      { subject: 's1', predicate: 'p1', object: 'o2' },
+      { subject: 's1', predicate: 'p1', object: 'o3' },
     ]);
 
     it('should have size 3', function () {
       store.size.should.eql(3);
     });
+
+    describe('adding a triple that already exists', function () {
+      it('should return false', function () {
+        store.addTriple('s1', 'p1', 'o1').should.be.false;
+      });
+
+      it('should not increase the size', function () {
+        store.size.should.eql(3);
+      });
+    });
+
+    describe('adding a triple that did not exist yet', function () {
+      it('should return true', function () {
+        store.addTriple('s1', 'p1', 'o4').should.be.true;
+      });
+
+      it('should increase the size', function () {
+        store.size.should.eql(4);
+      });
+    });
+
+    describe('removing an existing triple', function () {
+      it('should return true', function () {
+        store.removeTriple('s1', 'p1', 'o4').should.be.true;
+      });
+
+      it('should decrease the size', function () {
+        store.size.should.eql(3);
+      });
+    });
+
+    describe('removing a non-existing triple', function () {
+      it('should return false', function () {
+        store.removeTriple('s1', 'p1', 'o5').should.be.false;
+      });
+
+      it('should not decrease the size', function () {
+        store.size.should.eql(3);
+      });
+    });
   });
 
   describe('An N3Store with 5 elements', function () {
-    var store = new N3Store();
-    store.addTriple('s1', 'p1', 'o1');
-    store.addTriple({ subject: 's1', predicate: 'p1', object: 'o2'});
+    var store = new N3Store({ defaultGraph: 'http://example.org/#defaultGraph' });
+    store.addTriple('s1', 'p1', 'o1').should.be.true;
+    store.addTriple({ subject: 's1', predicate: 'p1', object: 'o2' }).should.be.true;
     store.addTriples([
-      { subject: 's1', predicate: 'p2', object: 'o2'},
-      { subject: 's2', predicate: 'p1', object: 'o1'},
+      { subject: 's1', predicate: 'p2', object: 'o2' },
+      { subject: 's2', predicate: 'p1', object: 'o1' },
     ]);
-    store.addTriple('s1', 'p2', 'o3', 'c4');
+    store.addTriple('s1', 'p2', 'o3', 'c4').should.be.true;
 
     it('should have size 5', function () {
       store.size.should.eql(5);
     });
 
     describe('when searched without parameters', function () {
-      it('should return all items in the default graph',
+      it('should return all items',
         shouldIncludeAll(store.find(),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4']));
     });
 
     describe('when searched with an existing subject parameter', function () {
-      it('should return all items with this subject in the default graph',
+      it('should return all items with this subject in all graphs',
         shouldIncludeAll(store.find('s1', null, null),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4']));
     });
 
     describe('when searched with a non-existing subject parameter', function () {
@@ -94,7 +163,9 @@ describe('N3Store', function () {
     describe('when searched with an existing predicate parameter', function () {
       it('should return all items with this predicate in the default graph',
         shouldIncludeAll(store.find(null, 'p1', null),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing predicate parameter', function () {
@@ -103,7 +174,9 @@ describe('N3Store', function () {
 
     describe('when searched with an existing object parameter', function () {
       it('should return all items with this object in the default graph',
-        shouldIncludeAll(store.find(null, null, 'o1'), ['s1', 'p1', 'o1'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, null, 'o1'),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing object parameter', function () {
@@ -112,7 +185,9 @@ describe('N3Store', function () {
 
     describe('when searched with existing subject and predicate parameters', function () {
       it('should return all items with this subject and predicate in the default graph',
-        shouldIncludeAll(store.find('s1', 'p1', null), ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2']));
+        shouldIncludeAll(store.find('s1', 'p1', null),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s1', 'p1', 'o2', store.defaultGraph]));
     });
 
     describe('when searched with non-existing subject and predicate parameters', function () {
@@ -121,7 +196,9 @@ describe('N3Store', function () {
 
     describe('when searched with existing subject and object parameters', function () {
       it('should return all items with this subject and object in the default graph',
-        shouldIncludeAll(store.find('s1', null, 'o2'), ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2']));
+        shouldIncludeAll(store.find('s1', null, 'o2'),
+            ['s1', 'p1', 'o2', store.defaultGraph],
+            ['s1', 'p2', 'o2', store.defaultGraph]));
     });
 
     describe('when searched with non-existing subject and object parameters', function () {
@@ -130,16 +207,18 @@ describe('N3Store', function () {
 
     describe('when searched with existing predicate and object parameters', function () {
       it('should return all items with this predicate and object in the default graph',
-        shouldIncludeAll(store.find(null, 'p1', 'o1'), ['s1', 'p1', 'o1'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, 'p1', 'o1'),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
-    describe('when searched with non-existing predicate and object parameters', function () {
-      itShouldBeEmpty(store.find(null, 'p2', 'o3'));
+    describe('when searched with non-existing predicate and object parameters in the default graph', function () {
+      itShouldBeEmpty(store.find(null, 'p2', 'o3', store.defaultGraph));
     });
 
     describe('when searched with existing subject, predicate, and object parameters', function () {
       it('should return all items with this subject, predicate, and object in the default graph',
-        shouldIncludeAll(store.find('s1', 'p1', 'o1'), ['s1', 'p1', 'o1']));
+        shouldIncludeAll(store.find('s1', 'p1', 'o1'), ['s1', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing triple', function () {
@@ -148,8 +227,11 @@ describe('N3Store', function () {
 
     describe('when searched with the default graph parameter', function () {
       it('should return all items in the default graph',
-        shouldIncludeAll(store.find(),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, null, null, store.defaultGraph),
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with an existing non-default graph parameter', function () {
@@ -276,62 +358,65 @@ describe('N3Store', function () {
     });
 
     describe('when trying to remove a triple with a non-existing subject', function () {
-      before(function () { store.removeTriple('s0', 'p1', 'o1'); });
+      before(function () { store.removeTriple('s0', 'p1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing predicate', function () {
-      before(function () { store.removeTriple('s1', 'p0', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p0', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing object', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o0'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o0').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no subjects exist', function () {
-      before(function () { store.removeTriple('o1', 'p1', 'o1'); });
+      before(function () { store.removeTriple('o1', 'p1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no predicates exist', function () {
-      before(function () { store.removeTriple('s1', 's1', 'o1'); });
+      before(function () { store.removeTriple('s1', 's1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no objects exist', function () {
-      before(function () { store.removeTriple('s1', 'p1', 's1'); });
+      before(function () { store.removeTriple('s1', 'p1', 's1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple that does not exist', function () {
-      before(function () { store.removeTriple('s1', 'p2', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p2', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove an incomplete triple', function () {
-      before(function () { store.removeTriple('s1', null, null); });
+      before(function () { store.removeTriple('s1', null, null).should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing graph', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o1', 'c0'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o1', 'c0').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when removing an existing triple', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o1').should.be.true; });
 
       it('should have size 4', function () { store.size.should.eql(4); });
 
       it('should not contain that triple anymore',
         shouldIncludeAll(function () { return store.find(); },
-                         ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4', store.defaultGraph]));
     });
 
     describe('when removing an existing triple from a non-default graph', function () {
-      before(function () { store.removeTriple('s1', 'p2', 'o3', 'c4'); });
+      before(function () { store.removeTriple('s1', 'p2', 'o3', 'c4').should.be.true; });
 
       it('should have size 3', function () { store.size.should.eql(3); });
 
@@ -341,8 +426,8 @@ describe('N3Store', function () {
     describe('when removing multiple triples', function () {
       before(function () {
         store.removeTriples([
-          { subject: 's1', predicate: 'p2', object: 'o2'},
-          { subject: 's2', predicate: 'p1', object: 'o1'},
+          { subject: 's1', predicate: 'p2', object: 'o2' },
+          { subject: 's2', predicate: 'p1', object: 'o1' },
         ]);
       });
 
@@ -350,13 +435,13 @@ describe('N3Store', function () {
 
       it('should not contain those triples anymore',
         shouldIncludeAll(function () { return store.find(); },
-                         ['s1', 'p1', 'o2']));
+                         ['s1', 'p1', 'o2', store.defaultGraph]));
     });
 
     describe('when adding and removing a triple', function () {
       before(function () {
-        store.addTriple('a', 'b', 'c');
-        store.removeTriple('a', 'b', 'c');
+        store.addTriple('a', 'b', 'c').should.be.true;
+        store.removeTriple('a', 'b', 'c').should.be.true;
       });
 
       it('should have an unchanged size', function () { store.size.should.eql(1); });
@@ -371,33 +456,43 @@ describe('N3Store', function () {
       { subject: 'http://foo.org/#s3', predicate: 'http://bar.org/p3', object: '"a"^^http://foo.org/#t1' },
       { subject: 'http://foo.org/#s1', predicate: 'http://bar.org/p1', object: 'http://foo.org/#o1', graph: 'http://graphs.org/#g1' },
     ],
-    { prefixes: { 'a': 'http://foo.org/#', 'b': 'http://bar.org/', 'g': 'http://graphs.org/#' } });
+    { prefixes: { a: 'http://foo.org/#', b: 'http://bar.org/', g: 'http://graphs.org/#' } });
 
     describe('should allow to query subjects with prefixes', function () {
       it('should return all triples with that subject',
-        shouldIncludeAll(store.find('a:s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+          shouldIncludeAll(store.find('a:s1', null, null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query subjects with prefixes', function () {
+      it('should return all triples with that subject in the default graph',
+          shouldIncludeAll(store.find('a:s1', null, null, store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
         shouldIncludeAll(store.find(null, 'b:p1', null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query objects with prefixes', function () {
       it('should return all triples with that object',
         shouldIncludeAll(store.find(null, null, 'a:o1'),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query graphs with prefixes', function () {
       it('should return all triples with that graph',
         shouldIncludeAll(store.find(null, null, null, 'http://graphs.org/#g1'),
-          ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+          ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1', store.defaultGraph]));
     });
   });
 
@@ -410,27 +505,51 @@ describe('N3Store', function () {
     ]);
 
     store.addPrefix('a', 'http://foo.org/#');
-    store.addPrefixes({ 'b': 'http://bar.org/', 'g': 'http://graphs.org/#' });
+    store.addPrefixes({ b: 'http://bar.org/', g: 'http://graphs.org/#' });
+
+    describe('should allow to query subjects with prefixes', function () {
+      it('should return all triples with that subject in the default graph',
+        shouldIncludeAll(store.find('a:s1', null, null, store.defaultGraph),
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
+    });
 
     describe('should allow to query subjects with prefixes', function () {
       it('should return all triples with that subject',
-        shouldIncludeAll(store.find('a:s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+          shouldIncludeAll(store.find('a:s1', null, null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query predicates with prefixes', function () {
+      it('should return all triples with that predicate in the default graph',
+          shouldIncludeAll(store.find(null, 'b:p1', null, store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph]));
     });
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
-        shouldIncludeAll(store.find(null, 'b:p1', null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2']));
+          shouldIncludeAll(store.find(null, 'b:p1', null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query objects with prefixes', function () {
+      it('should return all triples with that object in the default graph',
+          shouldIncludeAll(store.find(null, null, 'a:o1', store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
 
     describe('should allow to query objects with prefixes', function () {
       it('should return all triples with that object',
         shouldIncludeAll(store.find(null, null, 'a:o1'),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query graphs with prefixes', function () {
@@ -446,24 +565,24 @@ describe('N3Store', function () {
       { subject: 'http://foo.org/#s1', predicate: 'http://bar.org/p2', object: 'http://foo.org/#o1' },
       { subject: 'http://foo.org/#s2', predicate: 'http://bar.org/p1', object: 'http://foo.org/#o2' },
     ],
-    { prefixes: { 'http': 'http://www.w3.org/2006/http#' } });
+    { prefixes: { http: 'http://www.w3.org/2006/http#' } });
 
     describe('should allow to query subjects without prefixes', function () {
       it('should return all triples with that subject',
         shouldIncludeAll(store.find('http://foo.org/#s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
   });
 
   describe('An N3Store created without triples but with prefixes', function () {
-    var store = new N3Store({ prefixes: { 'http': 'http://www.w3.org/2006/http#' } });
-    store.addTriple('a', 'http://www.w3.org/2006/http#b', 'c');
+    var store = new N3Store({ prefixes: { http: 'http://www.w3.org/2006/http#' } });
+    store.addTriple('a', 'http://www.w3.org/2006/http#b', 'c').should.be.true;
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
         shouldIncludeAll(store.find(null, 'http:b', null),
-                         ['a', 'http://www.w3.org/2006/http#b', 'c']));
+                         ['a', 'http://www.w3.org/2006/http#b', 'c', store.defaultGraph]));
     });
   });
 
@@ -473,13 +592,13 @@ describe('N3Store', function () {
     // Test inspired by http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/.
     // The value `__proto__` is not supported however – fixing it introduces too much overhead.
     it('should be able to contain entities with JavaScript object property names', function () {
-      store.addTriple('toString', 'valueOf', 'toLocaleString', 'hasOwnProperty');
+      store.addTriple('toString', 'valueOf', 'toLocaleString', 'hasOwnProperty').should.be.true;
       shouldIncludeAll(store.find(null, null, null, 'hasOwnProperty'),
                        ['toString', 'valueOf', 'toLocaleString', 'hasOwnProperty'])();
     });
 
     it('should be able to contain entities named "null"', function () {
-      store.addTriple('null', 'null', 'null', 'null');
+      store.addTriple('null', 'null', 'null', 'null').should.be.true;
       shouldIncludeAll(store.find(null, null, null, 'null'), ['null', 'null', 'null', 'null'])();
     });
   });

package/test/N3StreamParser-test.js

@@ -87,7 +87,7 @@ function shouldEmitPrefixes(chunks, expectedPrefixes) {
 
 function ArrayReader(items) {
   var reader = new Readable();
-  reader._read = function () { this.push(items.shift()); };
+  reader._read = function () { this.push(items.shift() || null); };
   return reader;
 }
 

package/test/N3StreamWriter-test.js

@@ -3,7 +3,6 @@ var chai = require('chai'),
     Readable = require('stream').Readable,
     Writable = require('stream').Writable;
 chai.should();
-chai.use(require('chai-things'));
 
 describe('N3StreamWriter', function () {
   describe('The N3StreamWriter module', function () {
@@ -99,7 +98,7 @@ function shouldNotSerialize(tripleArrays, expectedMessage) {
 function ArrayReader(items) {
   var reader = new Readable({ objectMode: true });
   items = items.map(function (i) { return { subject: i[0], predicate: i[1], object: i[2] }; });
-  reader._read = function () { this.push(items.shift()); };
+  reader._read = function () { this.push(items.shift() || null); };
   return reader;
 }
 

package/test/N3Util-test.js

@@ -1,6 +1,6 @@
 var N3Util = require('../N3').Util;
-var chai = require('chai'),
-    expect = chai.expect;
+var chai = require('chai');
+var expect = chai.expect;
 chai.should();
 
 describe('N3Util', function () {
@@ -261,11 +261,11 @@ describe('N3Util', function () {
 
   describe('expandPrefixedName', function () {
     it('expands a prefixed name', function () {
-      N3Util.expandPrefixedName('ex:Test', { 'ex': 'http://ex.org/#' }).should.equal('http://ex.org/#Test');
+      N3Util.expandPrefixedName('ex:Test', { ex: 'http://ex.org/#' }).should.equal('http://ex.org/#Test');
     });
 
     it('expands a type with a prefixed name', function () {
-      N3Util.expandPrefixedName('"a"^^ex:type', { 'ex': 'http://ex.org/#' }).should.equal('"a"^^http://ex.org/#type');
+      N3Util.expandPrefixedName('"a"^^ex:type', { ex: 'http://ex.org/#' }).should.equal('"a"^^http://ex.org/#type');
     });
 
     it('expands a prefixed name with the empty prefix', function () {
@@ -273,7 +273,7 @@ describe('N3Util', function () {
     });
 
     it('does not expand a prefixed name if the prefix is unknown', function () {
-      N3Util.expandPrefixedName('a:Test', { 'b': 'http://ex.org/#' }).should.equal('a:Test');
+      N3Util.expandPrefixedName('a:Test', { b: 'http://ex.org/#' }).should.equal('a:Test');
     });
 
     it('returns the input if it is not a prefixed name', function () {
@@ -340,4 +340,70 @@ describe('N3Util', function () {
       N3Util.createLiteral(true).should.equal('"true"^^http://www.w3.org/2001/XMLSchema#boolean');
     });
   });
+
+  describe('prefix', function () {
+    var baz = N3Util.prefix('http://ex.org/baz#');
+    it('should return a function', function () {
+      expect(baz).to.be.an.instanceof(Function);
+    });
+
+    describe('the function', function () {
+      it('should expand the prefix', function () {
+        expect(baz('bar')).to.equal('http://ex.org/baz#bar');
+      });
+    });
+  });
+
+  describe('prefixes', function () {
+    describe('called without arguments', function () {
+      var prefixes = N3Util.prefixes();
+      it('should return a function', function () {
+        expect(prefixes).to.be.an.instanceof(Function);
+      });
+
+      describe('the function', function () {
+        it('should not expand non-registered prefixes', function () {
+          expect(prefixes('baz')('bar')).to.equal('bar');
+        });
+
+        it('should allow registering prefixes', function () {
+          var p = prefixes('baz', 'http://ex.org/baz#');
+          expect(p).to.exist;
+          expect(p).to.equal(prefixes('baz'));
+        });
+
+        it('should expand the newly registered prefix', function () {
+          expect(prefixes('baz')('bar')).to.equal('http://ex.org/baz#bar');
+        });
+      });
+    });
+
+    describe('called with a hash of prefixes', function () {
+      var prefixes = N3Util.prefixes({ foo: 'http://ex.org/foo#', bar: 'http://ex.org/bar#' });
+      it('should return a function', function () {
+        expect(prefixes).to.be.an.instanceof(Function);
+      });
+
+      describe('the function', function () {
+        it('should expand registered prefixes', function () {
+          expect(prefixes('foo')('bar')).to.equal('http://ex.org/foo#bar');
+          expect(prefixes('bar')('bar')).to.equal('http://ex.org/bar#bar');
+        });
+
+        it('should not expand non-registered prefixes', function () {
+          expect(prefixes('baz')('bar')).to.equal('bar');
+        });
+
+        it('should allow registering prefixes', function () {
+          var p = prefixes('baz', 'http://ex.org/baz#');
+          expect(p).to.exist;
+          expect(p).to.equal(prefixes('baz'));
+        });
+
+        it('should expand the newly registered prefix', function () {
+          expect(prefixes('baz')('bar')).to.equal('http://ex.org/baz#bar');
+        });
+      });
+    });
+  });
 });