refactor(tests): Switch to Jest, remove custom helpers

Author: fb55

.mocharc.json

@@ -1,7 +1,4 @@
 language: node_js
 node_js:
     - lts/*
-script:
-    - npm run lcov
-    - npm run lint
-after_success: npm run coveralls
+after_success: npm run coverage

.travis.yml

@@ -23,34 +23,38 @@
         "nth-check": "^1.0.2"
     },
     "devDependencies": {
-        "@types/expect.js": "^0.3.29",
-        "@types/mocha": "^8.0.3",
+        "@types/jest": "^26.0.14",
         "@types/node": "^14.0.5",
         "@typescript-eslint/eslint-plugin": "^4.1.0",
         "@typescript-eslint/parser": "^4.1.0",
         "cheerio-soupselect": "^0.1.1",
         "coveralls": "^3.0.2",
         "eslint": "^7.9.0",
         "eslint-config-prettier": "^6.0.0",
-        "expect.js": "^0.3.1",
         "htmlparser2": "^4.0.0",
-        "mocha": "^8.0.1",
-        "nyc": "^15.1.0",
+        "jest": "^26.4.2",
         "prettier": "^2.1.2",
-        "ts-node": "^9.0.0",
+        "ts-jest": "^26.4.0",
         "typescript": "^4.0.2"
     },
     "scripts": {
-        "test": "mocha --parallel && npm run lint",
-        "lint": "eslint .",
-        "lcov": "nyc mocha",
-        "coveralls": "(nyc report --reporter=text-lcov | coveralls)",
+        "test": "jest --coverage && npm run lint",
+        "coverage": "cat coverage/lcov.info | coveralls",
+        "lint": "eslint src",
+        "format": "prettier --write '**/*.{ts,md,json}'",
         "build": "tsc",
         "prepare": "npm run build"
     },
     "license": "BSD-2-Clause",
     "types": "index.d.ts",
     "prettier": {
         "tabWidth": 4
+    },
+    "jest": {
+        "preset": "ts-jest",
+        "testEnvironment": "node",
+        "testMatch": [
+            "<rootDir>/test/*.ts"
+        ]
     }
 }

package-lock.json

@@ -1,9 +1,3 @@
 {
-    "env": {
-        "mocha": true
-    },
-    "rules": {
-        "capitalized-comments": 0,
-        "multiline-comment-style": 0
-    }
+    "env": { "jest": true }
 }

package.json

@@ -1,7 +1,6 @@
 import * as CSSselect from "../src";
 import { parseDOM as makeDom } from "htmlparser2";
 import { trueFunc, falseFunc } from "boolbase";
-import assert from "assert";
 import type { Element } from "domhandler";
 
 const [dom] = makeDom("<div id=foo><p>foo</p></div>") as Element[];
@@ -12,174 +11,167 @@ const [xmlDom] = makeDom("<DiV id=foo><P>foo</P></DiV>", {
 describe("API", () => {
     describe("removes duplicates", () => {
         it("between identical trees", () => {
-            const matches = CSSselect.selectAll("div", [dom, dom]);
-            assert.strictEqual(matches.length, 1, "Removes duplicate matches");
+            expect(CSSselect.selectAll("div", [dom, dom])).toHaveLength(1);
         });
         it("between a superset and subset", () => {
-            const matches = CSSselect.selectAll("p", [dom, dom.children[0]]);
-            assert.strictEqual(matches.length, 1, "Removes duplicate matches");
+            expect(
+                CSSselect.selectAll("p", [dom, dom.children[0]])
+            ).toHaveLength(1);
         });
         it("betweeen a subset and superset", () => {
-            const matches = CSSselect.selectAll("p", [dom.children[0], dom]);
-            assert.strictEqual(matches.length, 1, "Removes duplicate matches");
+            expect(
+                CSSselect.selectAll("p", [dom.children[0], dom])
+            ).toHaveLength(1);
         });
     });
 
     describe("can be queried by function", () => {
         it("in `is`", () => {
-            assert(CSSselect.is(dom, (elem) => elem.attribs.id === "foo"));
+            expect(CSSselect.is(dom, (elem) => elem.attribs.id === "foo")).toBe(
+                true
+            );
         });
         // Probably more cases should be added here
     });
 
     describe("selectAll", () => {
         it("should query array elements directly when they have no parents", () => {
             const divs = [dom];
-            assert.deepEqual(CSSselect.selectAll("div", divs), divs);
+            expect(CSSselect.selectAll("div", divs)).toStrictEqual(divs);
         });
         it("should query array elements directly when they have parents", () => {
             const ps = CSSselect.selectAll("p", [dom]);
-            assert.deepEqual(CSSselect.selectAll("p", ps), ps);
+            expect(CSSselect.selectAll("p", ps)).toStrictEqual(ps);
         });
         it("should support pseudos led by a traversal (#111)", () => {
             const [dom] = makeDom(
                 '<div><div class="foo">a</div><div class="bar">b</div></div>'
             ) as Element[];
             const a = CSSselect.selectAll(".foo:has(+.bar)", dom);
-            assert.strictEqual(a.length, 1);
-            assert.strictEqual(a[0], dom.children[0]);
+            expect(a).toHaveLength(1);
+            expect(a[0]).toStrictEqual(dom.children[0]);
         });
     });
 
     describe("unsatisfiable and universally valid selectors", () => {
         it("in :not", () => {
             let func = CSSselect._compileUnsafe(":not(*)");
-            assert.strictEqual(func, falseFunc);
+            expect(func).toBe(falseFunc);
             func = CSSselect._compileUnsafe(":not(:nth-child(-1n-1))");
-            assert.strictEqual(func, trueFunc);
+            expect(func).toBe(trueFunc);
             func = CSSselect._compileUnsafe(":not(:not(:not(*)))");
-            assert.strictEqual(func, falseFunc);
+            expect(func).toBe(falseFunc);
         });
 
         it("in :has", () => {
             const matches = CSSselect.selectAll(":has(*)", [dom]);
-            assert.strictEqual(matches.length, 1);
-            assert.strictEqual(matches[0], dom);
+            expect(matches).toHaveLength(1);
+            expect(matches[0]).toBe(dom);
             const func = CSSselect._compileUnsafe(":has(:nth-child(-1n-1))");
-            assert.strictEqual(func, falseFunc);
+            expect(func).toBe(falseFunc);
         });
 
         it("should skip unsatisfiable", () => {
             const func = CSSselect._compileUnsafe("* :not(*) foo");
-            assert.strictEqual(func, falseFunc);
+            expect(func).toBe(falseFunc);
         });
 
         it("should promote universally valid", () => {
             const func = CSSselect._compileUnsafe("*, foo");
-            assert.strictEqual(func, trueFunc);
+            expect(func).toBe(trueFunc);
         });
     });
 
     describe(":matches", () => {
         it("should select multiple elements", () => {
             let matches = CSSselect.selectAll(":matches(p, div)", [dom]);
-            assert.strictEqual(matches.length, 2);
+            expect(matches).toHaveLength(2);
             matches = CSSselect.selectAll(":matches(div, :not(div))", [dom]);
-            assert.strictEqual(matches.length, 2);
+            expect(matches).toHaveLength(2);
             matches = CSSselect.selectAll(
                 ":matches(boo, baa, tag, div, foo, bar, baz)",
                 [dom]
             );
-            assert.strictEqual(matches.length, 1);
-            assert.strictEqual(matches[0], dom);
+            expect(matches).toHaveLength(1);
+            expect(matches[0]).toBe(dom);
         });
 
         it("should strip quotes", () => {
             let matches = CSSselect.selectAll(":matches('p, div')", [dom]);
-            assert.strictEqual(matches.length, 2);
+            expect(matches).toHaveLength(2);
             matches = CSSselect.selectAll(':matches("p, div")', [dom]);
-            assert.strictEqual(matches.length, 2);
+            expect(matches).toHaveLength(2);
         });
     });
 
     describe("parent selector (<)", () => {
         it("should select the right element", () => {
             const matches = CSSselect.selectAll("p < div", [dom]);
-            assert.strictEqual(matches.length, 1);
-            assert.strictEqual(matches[0], dom);
+            expect(matches).toHaveLength(1);
+            expect(matches[0]).toBe(dom);
         });
         it("should not select nodes without children", () => {
             const matches = CSSselect.selectAll("p < div", [dom]);
-            assert.deepStrictEqual(
-                matches,
-                CSSselect.selectAll("* < *", [dom])
-            );
+            expect(matches).toStrictEqual(CSSselect.selectAll("* < *", [dom]));
         });
     });
 
     describe("selectOne", () => {
         it("should select elements in traversal order", () => {
-            let match = CSSselect.selectOne("p", [dom]);
-            assert.strictEqual(match, dom.children[0]);
-            match = CSSselect.selectOne(":contains(foo)", [dom]);
-            assert.strictEqual(match, dom);
+            expect(CSSselect.selectOne("p", [dom])).toBe(dom.children[0]);
+            expect(CSSselect.selectOne(":contains(foo)", [dom])).toBe(dom);
         });
         it("should take shortcuts when applicable", () => {
             let match = CSSselect.selectOne(falseFunc, {
                 get length() {
                     throw new Error("Did not take shortcut");
                 },
             });
-            assert.strictEqual(match, null);
+            expect(match).toBeNull();
             match = CSSselect.selectOne("*", []);
-            assert.strictEqual(match, null);
+            expect(match).toBeNull();
         });
     });
 
     describe("options", () => {
         const opts = { xmlMode: true };
         it("should recognize xmlMode in :has and :not", () => {
-            assert(CSSselect.is(xmlDom, "DiV:has(P)", opts));
-            assert(CSSselect.is(xmlDom, "DiV:not(div)", opts));
-            assert(
+            expect(CSSselect.is(xmlDom, "DiV:has(P)", opts)).toBe(true);
+            expect(CSSselect.is(xmlDom, "DiV:not(div)", opts)).toBe(true);
+            expect(
                 CSSselect.is(xmlDom.children[0], "DiV:has(P) :not(p)", opts)
-            );
+            ).toBe(true);
         });
 
         it("should be strict", () => {
             const opts = { strict: true };
-            assert.throws(() => CSSselect.compile(":checkbox", opts), Error);
-            assert.throws(() => CSSselect.compile("[attr=val i]", opts), Error);
-            assert.throws(() => CSSselect.compile("[attr!=val]", opts), Error);
-            assert.throws(
-                () => CSSselect.compile("[attr!=val i]", opts),
+            expect(() => CSSselect.compile(":checkbox", opts)).toThrow(Error);
+            expect(() => CSSselect.compile("[attr=val i]", opts)).toThrow(
                 Error
             );
-            assert.throws(() => CSSselect.compile("foo < bar", opts), Error);
-            assert.throws(
-                () => CSSselect.compile(":not(:parent)", opts),
+            expect(() => CSSselect.compile("[attr!=val]", opts)).toThrow(Error);
+            expect(() => CSSselect.compile("[attr!=val i]", opts)).toThrow(
                 Error
             );
-            assert.throws(() => CSSselect.compile(":not(a > b)", opts), Error);
-            assert.throws(() => CSSselect.compile(":not(a, b)", opts), Error);
+            expect(() => CSSselect.compile("foo < bar", opts)).toThrow(Error);
+            expect(() => CSSselect.compile(":not(:parent)", opts)).toThrow(
+                Error
+            );
+            expect(() => CSSselect.compile(":not(a > b)", opts)).toThrow(Error);
+            expect(() => CSSselect.compile(":not(a, b)", opts)).toThrow(Error);
         });
 
         it("should recognize contexts", () => {
             const div = CSSselect.selectAll("div", [dom]);
             const p = CSSselect.selectAll("p", [dom]);
 
-            assert.strictEqual(
-                CSSselect.selectOne("div", div, { context: div }),
+            expect(CSSselect.selectOne("div", div, { context: div })).toBe(
                 div[0]
             );
-            assert.strictEqual(
-                CSSselect.selectOne("div", div, { context: p }),
-                null
-            );
-            assert.deepStrictEqual(
-                CSSselect.selectAll("p", div, { context: div }),
-                p
-            );
+            expect(CSSselect.selectOne("div", div, { context: p })).toBe(null);
+            expect(
+                CSSselect.selectAll("p", div, { context: div })
+            ).toStrictEqual(p);
         });
     });
 });