Move to Vitest for testing

Vitest can test all the files, including testing the types.

Author: chris-pardy

package.json

@@ -4,12 +4,12 @@
   "description": "Rules Engine expressed in simple json",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
+  "type": "module",
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "mocha && npm run lint --silent && npm run test:types",
-    "test:types": "tsd",
+    "test": "vitest --typecheck",
     "lint": "eslint",
     "format": "prettier -w .",
     "prepublishOnly": "npm run build",
@@ -29,18 +29,6 @@
   "publishConfig": {
     "tag": "next"
   },
-  "mocha": {
-    "require": [
-      "babel-core/register",
-      "babel-polyfill"
-    ],
-    "file": "./test/support/bootstrap.js",
-    "checkLeaks": true,
-    "recursive": true,
-    "globals": [
-      "expect"
-    ]
-  },
   "author": "Cache Hamm <[email protected]>",
   "contributors": [
     "Chris Pardy <[email protected]>"
@@ -60,20 +48,17 @@
     "babel-preset-es2015": "~6.24.1",
     "babel-preset-stage-0": "~6.24.1",
     "babel-register": "6.26.0",
-    "chai": "^4.3.4",
-    "chai-as-promised": "^7.1.1",
     "colors": "~1.4.0",
     "dirty-chai": "2.0.1",
     "eslint": "^9.13.0",
     "globals": "^15.11.0",
     "lodash": "4.17.21",
-    "mocha": "^8.4.0",
     "perfy": "^1.1.5",
     "prettier": "^3.3.3",
-    "sinon": "^11.1.1",
-    "sinon-chai": "^3.7.0",
     "tsd": "^0.17.0",
-    "typescript-eslint": "^8.11.0"
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.11.0",
+    "vitest": "^2.1.3"
   },
   "dependencies": {
     "clone": "^2.1.2",

test/acceptance/acceptance.js renamed to test/acceptance/acceptance.test.mjs

@@ -1,21 +1,10 @@
-"use strict";
-
-import sinon from "sinon";
-import { expect } from "chai";
-import { Engine } from "../../src/index";
-
+import { Engine } from "../../src/index.mjs";
+import { describe, it, expect, vi } from "vitest";
 /**
  * acceptance tests are intended to use features that, when used in combination,
  * could cause integration bugs not caught by the rest of the test suite
  */
 describe("Acceptance", () => {
-  let sandbox;
-  before(() => {
-    sandbox = sinon.createSandbox();
-  });
-  afterEach(() => {
-    sandbox.restore();
-  });
   const factParam = 1;
   const event1 = {
     type: "event-1",
@@ -61,8 +50,8 @@ describe("Acceptance", () => {
 
   function setup(options = {}) {
     const engine = new Engine();
-    highPrioritySpy = sandbox.spy();
-    lowPrioritySpy = sandbox.spy();
+    highPrioritySpy = vi.fn();
+    lowPrioritySpy = vi.fn();
 
     engine.addRule({
       name: "first",
@@ -87,10 +76,10 @@ describe("Acceptance", () => {
       },
       event: event1,
       onSuccess: async (event, almanac, ruleResults) => {
-        expect(ruleResults.name).to.equal("first");
-        expect(ruleResults.event).to.deep.equal(event1);
-        expect(ruleResults.priority).to.equal(10);
-        expect(ruleResults.conditions).to.deep.equal(expectedFirstRuleResult);
+        expect(ruleResults.name).toBe("first");
+        expect(ruleResults.event).toEqual(event1);
+        expect(ruleResults.priority).toBe(10);
+        expect(ruleResults.conditions).toEqual(expectedFirstRuleResult);
 
         return delay(
           almanac.addRuntimeFact("rule-created-fact", {
@@ -150,8 +139,8 @@ describe("Acceptance", () => {
       const baseIndex = await almanac.factValue("baseIndex");
       return delay(baseIndex);
     });
-    successSpy = sandbox.spy();
-    failureSpy = sandbox.spy();
+    successSpy = vi.fn();
+    failureSpy = vi.fn();
     engine.on("success", successSpy);
     engine.on("failure", failureSpy);
 
@@ -169,8 +158,8 @@ describe("Acceptance", () => {
     );
 
     // results
-    expect(results.length).to.equal(2);
-    expect(results[0]).to.deep.equal({
+    expect(results.length).toBe(2);
+    expect(results[0]).toEqual({
       conditions: {
         all: [
           {
@@ -205,7 +194,7 @@ describe("Acceptance", () => {
       priority: 10,
       result: true,
     });
-    expect(results[1]).to.deep.equal({
+    expect(results[1]).toEqual({
       conditions: {
         all: [
           {
@@ -233,20 +222,30 @@ describe("Acceptance", () => {
       priority: 1,
       result: true,
     });
-    expect(failureResults).to.be.empty();
+    expect(failureResults).toHaveLength(0);
 
     // events
-    expect(failureEvents.length).to.equal(0);
-    expect(events.length).to.equal(2);
-    expect(events[0]).to.deep.equal(event1);
-    expect(events[1]).to.deep.equal(event2);
+    expect(failureEvents.length).toBe(0);
+    expect(events.length).toBe(2);
+    expect(events[0]).toEqual(event1);
+    expect(events[1]).toEqual(event2);
 
     // callbacks
-    expect(successSpy).to.have.been.calledTwice();
-    expect(successSpy).to.have.been.calledWith(event1);
-    expect(successSpy).to.have.been.calledWith(event2);
-    expect(highPrioritySpy).to.have.been.calledBefore(lowPrioritySpy);
-    expect(failureSpy).to.not.have.been.called();
+    expect(successSpy).toHaveBeenCalledTimes(2);
+    expect(successSpy).toHaveBeenCalledWith(
+      event1,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(successSpy).toHaveBeenCalledWith(
+      event2,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(Math.min(...highPrioritySpy.mock.invocationCallOrder)).toBeLessThan(
+      Math.min(...lowPrioritySpy.mock.invocationCallOrder),
+    );
+    expect(failureSpy).not.toHaveBeenCalled();
   });
 
   it("fails", async () => {
@@ -259,16 +258,26 @@ describe("Acceptance", () => {
       { baseIndex: 1, "rule-created-fact": "" },
     );
 
-    expect(results.length).to.equal(0);
-    expect(failureResults.length).to.equal(2);
-    expect(failureResults.every((rr) => rr.result === false)).to.be.true();
+    expect(results.length).toBe(0);
+    expect(failureResults.length).toBe(2);
+    expect(failureResults.every((rr) => rr.result === false)).toBe(true);
 
-    expect(events.length).to.equal(0);
-    expect(failureEvents.length).to.equal(2);
-    expect(failureSpy).to.have.been.calledTwice();
-    expect(failureSpy).to.have.been.calledWith(event1);
-    expect(failureSpy).to.have.been.calledWith(event2);
-    expect(highPrioritySpy).to.have.been.calledBefore(lowPrioritySpy);
-    expect(successSpy).to.not.have.been.called();
+    expect(events.length).toBe(0);
+    expect(failureEvents.length).toBe(2);
+    expect(failureSpy).toHaveBeenCalledTimes(2);
+    expect(failureSpy).toHaveBeenCalledWith(
+      event1,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(failureSpy).toHaveBeenCalledWith(
+      event2,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(Math.min(...highPrioritySpy.mock.invocationCallOrder)).toBeLessThan(
+      Math.min(...lowPrioritySpy.mock.invocationCallOrder),
+    );
+    expect(successSpy).not.toHaveBeenCalled();
   });
 });