chore: migrate to jest

package.json

@@ -35,13 +35,10 @@
     "@rdfjs/data-model": "^1",
     "arrayify-stream": "^1.0.0",
     "browserify": "^17.0.0",
-    "chai": "^4.0.2",
-    "chai-things": "^0.2.0",
     "colors": "^1.1.2",
     "docco": "^0.8.0",
     "eslint": "^5.14.1",
-    "mocha": "^8.0.0",
-    "nyc": "^14.1.1",
+    "jest": "^29.7.0",
     "pre-commit": "^1.2.2",
     "rdf-isomorphic": "^1.3.1",
     "rdf-test-suite": "^1.19.2",
@@ -52,8 +49,7 @@
     "build": "npm run build:node && npm run build:browser",
     "build:node": "babel src -d lib",
     "build:browser": "rm -rf browser && mkdir browser && browserify -s N3 lib/index.js | uglifyjs > browser/n3.min.js",
-    "test": "nyc npm run mocha",
-    "mocha": "mocha",
+    "test": "jest",
     "lint": "eslint src perf test spec",
     "prepare": "npm run build",
     "spec": "npm run spec-turtle && npm run spec-ntriples && npm run spec-nquads && npm run spec-trig",
@@ -79,5 +75,8 @@
   "pre-commit": [
     "lint",
     "test"
-  ]
+  ],
+  "jest": {
+    "testMatch": ["**/test/*-test.js"]
+  }
 }

test/.eslintrc

@@ -5,6 +5,7 @@
     before: true,
     after: true,
     beforeEach: true,
+    beforeAll: true,
     afterEach: true,
     expect: true,
   },

test/BlankNode-test.js

@@ -3,77 +3,83 @@ import { BlankNode, Term } from '../src/';
 describe('BlankNode', () => {
   describe('The BlankNode module', () => {
     it('should be a function', () => {
-      BlankNode.should.be.a('function');
+      expect(BlankNode).toBeInstanceOf(Function);
     });
 
     it('should be a BlankNode constructor', () => {
-      new BlankNode().should.be.an.instanceof(BlankNode);
+      expect(new BlankNode()).toBeInstanceOf(BlankNode);
     });
 
     it('should be a Term constructor', () => {
-      new BlankNode().should.be.an.instanceof(Term);
+      expect(new BlankNode()).toBeInstanceOf(Term);
     });
   });
 
   describe('A BlankNode instance created from a name', () => {
     let blankNode;
-    before(() => { blankNode = new BlankNode('b1'); });
+    beforeAll(() => { blankNode = new BlankNode('b1'); });
 
     it('should be a BlankNode', () => {
-      blankNode.should.be.an.instanceof(BlankNode);
+      expect(blankNode).toBeInstanceOf(BlankNode);
     });
 
     it('should be a Term', () => {
-      blankNode.should.be.an.instanceof(Term);
+      expect(blankNode).toBeInstanceOf(Term);
     });
 
     it('should have term type "BlankNode"', () => {
-      blankNode.termType.should.equal('BlankNode');
+      expect(blankNode.termType).toBe('BlankNode');
     });
 
     it('should have the name as value', () => {
-      blankNode.should.have.property('value', 'b1');
+      expect(blankNode).toHaveProperty('value', 'b1');
     });
 
     it('should have "_:name" as id', () => {
-      blankNode.should.have.property('id', '_:b1');
+      expect(blankNode).toHaveProperty('id', '_:b1');
     });
 
     it('should equal a BlankNode instance with the same name', () => {
-      blankNode.equals(new BlankNode('b1')).should.be.true;
+      expect(blankNode.equals(new BlankNode('b1'))).toBe(true);
     });
 
     it('should equal an object with the same term type and value', () => {
-      blankNode.equals({
+      expect(blankNode.equals({
         termType: 'BlankNode',
         value: 'b1',
-      }).should.be.true;
+      })).toBe(true);
     });
 
     it('should not equal a falsy object', () => {
-      blankNode.equals(null).should.be.false;
+      expect(blankNode.equals(null)).toBe(false);
     });
 
     it('should not equal a BlankNode instance with another name', () => {
-      blankNode.equals(new BlankNode('b2')).should.be.false;
+      expect(blankNode.equals(new BlankNode('b2'))).toBe(false);
     });
 
-    it('should not equal an object with the same term type but a different value', () => {
-      blankNode.equals({
-        termType: 'BlankNode',
-        value: 'b2',
-      }).should.be.false;
-    });
-
-    it('should not equal an object with a different term type but the same value', () => {
-      blankNode.equals({
-        termType: 'NamedNode',
-        value: 'b1',
-      }).should.be.false;
-    });
+    it(
+      'should not equal an object with the same term type but a different value',
+      () => {
+        expect(blankNode.equals({
+          termType: 'BlankNode',
+          value: 'b2',
+        })).toBe(false);
+      }
+    );
+
+    it(
+      'should not equal an object with a different term type but the same value',
+      () => {
+        expect(blankNode.equals({
+          termType: 'NamedNode',
+          value: 'b1',
+        })).toBe(false);
+      }
+    );
 
     it('should provide a JSON representation', () => {
-      blankNode.toJSON().should.deep.equal({
+      expect(blankNode.toJSON()).toEqual({
         termType: 'BlankNode',
         value: 'b1',
       });

test/DefaultGraph-test.js

@@ -3,64 +3,64 @@ import { DefaultGraph, Term } from '../src/';
 describe('DefaultGraph', () => {
   describe('The DefaultGraph module', () => {
     it('should be a function', () => {
-      DefaultGraph.should.be.a('function');
+      expect(DefaultGraph).toBeInstanceOf(Function);
     });
 
     it('should be a DefaultGraph constructor', () => {
-      new DefaultGraph().should.be.an.instanceof(DefaultGraph);
+      expect(new DefaultGraph()).toBeInstanceOf(DefaultGraph);
     });
 
     it('should be a Term constructor', () => {
-      new DefaultGraph().should.be.an.instanceof(Term);
+      expect(new DefaultGraph()).toBeInstanceOf(Term);
     });
   });
 
   describe('A DefaultGraph instance', () => {
     let defaultGraph;
-    before(() => { defaultGraph = new DefaultGraph(); });
+    beforeAll(() => { defaultGraph = new DefaultGraph(); });
 
     it('should be a DefaultGraph', () => {
-      defaultGraph.should.be.an.instanceof(DefaultGraph);
+      expect(defaultGraph).toBeInstanceOf(DefaultGraph);
     });
 
     it('should be a Term', () => {
-      defaultGraph.should.be.an.instanceof(Term);
+      expect(defaultGraph).toBeInstanceOf(Term);
     });
 
     it('should have term type "DefaultGraph"', () => {
-      defaultGraph.termType.should.equal('DefaultGraph');
+      expect(defaultGraph.termType).toBe('DefaultGraph');
     });
 
     it('should have the empty string as value', () => {
-      defaultGraph.should.have.property('value', '');
+      expect(defaultGraph).toHaveProperty('value', '');
     });
 
     it('should have the empty string as id', () => {
-      defaultGraph.should.have.property('id', '');
+      expect(defaultGraph).toHaveProperty('id', '');
     });
 
     it('should equal another DefaultGraph instance', () => {
-      defaultGraph.equals(new DefaultGraph()).should.be.true;
+      expect(defaultGraph.equals(new DefaultGraph())).toBe(true);
     });
 
     it('should equal an object with the same term type', () => {
-      defaultGraph.equals({
+      expect(defaultGraph.equals({
         termType: 'DefaultGraph',
-      }).should.be.true;
+      })).toBe(true);
     });
 
     it('should not equal a falsy object', () => {
-      defaultGraph.equals(null).should.be.false;
+      expect(defaultGraph.equals(null)).toBe(false);
     });
 
     it('should not equal an object with a different term type', () => {
-      defaultGraph.equals({
+      expect(defaultGraph.equals({
         termType: 'Literal',
-      }).should.be.false;
+      })).toBe(false);
     });
 
     it('should provide a JSON representation', () => {
-      defaultGraph.toJSON().should.deep.equal({
+      expect(defaultGraph.toJSON()).toEqual({
         termType: 'DefaultGraph',
         value: '',
       });