test: refactor tests to use nodejs test runner

Author: karlprieb

.eslintrc

@@ -16,7 +16,6 @@
     "eslint:recommended",
     "plugin:@typescript-eslint/eslint-recommended",
     "plugin:@typescript-eslint/recommended",
-    "plugin:mocha/recommended",
     "prettier"
   ],
   "rules": {

package.json

@@ -77,7 +77,6 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-header": "^3.1.1",
     "eslint-plugin-jest-formatting": "^3.1.0",
-    "eslint-plugin-mocha": "^10.2.0",
     "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-unicorn": "^49.0.0",
     "mocha": "^10.2.0",

register.js

@@ -0,0 +1,4 @@
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+register('ts-node/esm', pathToFileURL('./'));

src/data/gateway-data-source.test.ts

@@ -15,82 +15,83 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+import { strict as assert } from 'node:assert';
+import { afterEach, before, beforeEach, describe, it, mock } from 'node:test';
 import axios from 'axios';
-import chai, { expect } from 'chai';
-import sinon, { SinonSandbox } from 'sinon';
-import sinonChai from 'sinon-chai';
 import * as winston from 'winston';
 import { GatewayDataSource } from './gateway-data-source.js';
 
-chai.use(sinonChai);
+let log: winston.Logger;
+let dataSource: GatewayDataSource;
+let mockedAxiosInstance: any;
 
-describe('GatewayDataSource', function () {
-  let log: winston.Logger;
-  let sandbox: SinonSandbox;
-  let dataSource: GatewayDataSource;
-  let mockedAxiosInstance: any;
-
-  before(function () {
-    log = winston.createLogger({ silent: true });
-  });
-
-  beforeEach(function () {
-    sandbox = sinon.createSandbox();
+before(async () => {
+  log = winston.createLogger({ silent: true });
+});
 
-    mockedAxiosInstance = {
-      request: sandbox.stub().resolves({
-        status: 200,
-        data: 'mocked stream',
-        headers: {
-          'content-length': '123',
-          'content-type': 'application/json',
-        },
-      }),
-      defaults: {
-        baseURL: 'https://gateway.domain', // Ensure this matches what you expect
+beforeEach(async () => {
+  mockedAxiosInstance = {
+    request: async () => ({
+      status: 200,
+      data: 'mocked stream',
+      headers: {
+        'content-length': '123',
+        'content-type': 'application/json',
       },
-    };
-    sandbox.stub(axios, 'create').returns(mockedAxiosInstance as any);
+    }),
+    defaults: {
+      baseURL: 'https://gateway.domain',
+    },
+  };
 
-    dataSource = new GatewayDataSource({
-      log,
-      trustedGatewayUrl: 'https://gateway.domain',
-    });
-  });
+  mock.method(axios, 'create', () => mockedAxiosInstance);
 
-  afterEach(function () {
-    sandbox.restore();
+  dataSource = new GatewayDataSource({
+    log,
+    trustedGatewayUrl: 'https://gateway.domain',
   });
+});
 
-  describe('getData', function () {
-    it('should fetch data successfully from the gateway', async function () {
+afterEach(async () => {
+  mock.restoreAll();
+});
+
+describe('GatewayDataSource', () => {
+  describe('getData', () => {
+    it('should fetch data successfully from the gateway', async () => {
       const data = await dataSource.getData('some-id');
 
-      expect(data).to.have.property('stream', 'mocked stream');
-      expect(data).to.have.property('size', 123);
-      expect(data).to.have.property('sourceContentType', 'application/json');
-      expect(data).to.have.property('verified', false);
-      expect(data).to.have.property('cached', false);
+      assert.deepEqual(data, {
+        stream: 'mocked stream',
+        size: 123,
+        sourceContentType: 'application/json',
+        verified: false,
+        cached: false,
+      });
     });
 
-    it('should throw an error for unexpected status code', async function () {
-      mockedAxiosInstance.request.resolves({ status: 404 });
+    it('should throw an error for unexpected status code', async () => {
+      mockedAxiosInstance.request = async () => ({ status: 404 });
 
       try {
         await dataSource.getData('bad-id');
+        assert.fail('Expected an error to be thrown');
       } catch (error: any) {
-        expect(error.message).to.equal(
-          'Unexpected status code from gateway: 404',
-        );
+        assert.equal(error.message, 'Unexpected status code from gateway: 404');
       }
     });
 
-    it('should handle network or Axios errors gracefully', async function () {
-      mockedAxiosInstance.request.rejects(new Error('Network Error'));
+    it('should handle network or Axios errors gracefully', async () => {
+      mockedAxiosInstance.request = async () => {
+        throw new Error('Network Error');
+      };
 
-      await expect(dataSource.getData('bad-id')).to.be.rejectedWith(
-        'Network Error',
-      );
+      try {
+        await dataSource.getData('bad-id');
+        assert.fail('Expected an error to be thrown');
+      } catch (error: any) {
+        assert.equal(error.message, 'Network Error');
+      }
     });
   });
 });

src/data/read-through-chunk-data-cache.test.ts

@@ -15,10 +15,9 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import chai, { expect } from 'chai';
 import fs from 'node:fs';
-import sinon, { SinonSandbox } from 'sinon';
-import sinonChai from 'sinon-chai';
+import { strict as assert } from 'node:assert';
+import { afterEach, before, describe, it, mock } from 'node:test';
 import * as winston from 'winston';
 
 import { ArweaveChunkSourceStub } from '../../test/stubs.js';
@@ -27,43 +26,32 @@ import { FsChunkDataStore } from '../store/fs-chunk-data-store.js';
 import { Chunk, ChunkData, ChunkDataStore } from '../types.js';
 import { ReadThroughChunkDataCache } from './read-through-chunk-data-cache.js';
 
-chai.use(sinonChai);
 const B64_DATA_ROOT = 'wRq6f05oRupfTW_M5dcYBtwK5P8rSNYu20vC6D_o-M4';
 const TX_SIZE = 256000;
 const ABSOLUTE_OFFSET = 51530681327863;
 const RELATIVE_OFFSET = 0;
 
-describe('ReadThroughChunkDataCache', () => {
-  let log: winston.Logger;
-  let chunkSource: ArweaveChunkSourceStub;
-  let chunkDataStore: ChunkDataStore;
-  let chunkCache: ReadThroughChunkDataCache;
-  let sandbox: SinonSandbox;
+let log: winston.Logger;
+let chunkSource: ArweaveChunkSourceStub;
+let chunkDataStore: ChunkDataStore;
+let chunkCache: ReadThroughChunkDataCache;
 
-  before(() => {
-    log = winston.createLogger({ silent: true });
-    chunkSource = new ArweaveChunkSourceStub();
-    chunkDataStore = new FsChunkDataStore({
-      log,
-      baseDir: 'data/chunks',
-    });
-    chunkCache = new ReadThroughChunkDataCache({
-      log,
-      chunkSource,
-      chunkDataStore,
-    });
+before(() => {
+  log = winston.createLogger({ silent: true });
+  chunkSource = new ArweaveChunkSourceStub();
+  chunkDataStore = new FsChunkDataStore({
+    log,
+    baseDir: 'data/chunks',
   });
-
-  beforeEach(() => {
-    sandbox = sinon.createSandbox();
-  });
-
-  afterEach(() => {
-    sandbox.restore();
+  chunkCache = new ReadThroughChunkDataCache({
+    log,
+    chunkSource,
+    chunkDataStore,
   });
+});
 
+describe('ReadThroughChunkDataCache', () => {
   // TODO remove mocks from tests
-
   describe('getChunkDataByAny', () => {
     let mockedChunk: Chunk;
     let mockedChunkData: ChunkData;
@@ -76,9 +64,9 @@ describe('ReadThroughChunkDataCache', () => {
         ),
       );
       const txPath = fromB64Url(jsonChunk.tx_path);
-      const dataRootBuffer = txPath.slice(-64, -32);
+      const dataRootBuffer = txPath.subarray(-64, -32);
       const dataPath = fromB64Url(jsonChunk.data_path);
-      const hash = dataPath.slice(-64, -32);
+      const hash = dataPath.subarray(-64, -32);
       mockedChunk = {
         tx_path: txPath,
         data_root: dataRootBuffer,
@@ -97,55 +85,68 @@ describe('ReadThroughChunkDataCache', () => {
       };
     });
 
+    afterEach(() => {
+      mock.restoreAll();
+    });
+
     it('should fetch chunk data from cache when available', async () => {
-      // mock the file exists
-      const storeGetSpy = sandbox
-        .stub(chunkDataStore, 'get')
-        .resolves(mockedChunkData);
-      const networkSpy = sandbox.spy(chunkSource, 'getChunkByAny');
+      mock.method(chunkDataStore, 'get', async () => mockedChunkData);
+      mock.method(chunkSource, 'getChunkByAny');
+
       await chunkCache.getChunkDataByAny(
         TX_SIZE,
         ABSOLUTE_OFFSET,
         B64_DATA_ROOT,
         0,
       );
-      expect(networkSpy).not.to.have.been.called;
-      expect(storeGetSpy).to.have.been.called;
+
+      assert.deepEqual((chunkSource.getChunkByAny as any).mock.callCount(), 0);
+      assert.deepEqual((chunkDataStore.get as any).mock.callCount(), 1);
     });
 
     it('should fetch chunk data from network when not in local cache', async () => {
-      // mock file does not exist
-      const storeHasSpy = sandbox.stub(chunkDataStore, 'has').resolves(false);
-      const storeGetSpy = sandbox.spy(chunkDataStore, 'get');
-      const networkSpy = sandbox
-        .stub(chunkSource, 'getChunkByAny')
-        .resolves(mockedChunk);
+      const chuunkDataStoreHasSpy = mock.method(
+        chunkDataStore,
+        'has',
+        async () => false,
+      );
+      const chunkDataStoreGetSpy = mock.method(chunkDataStore, 'get');
+      const networkSpy = mock.method(
+        chunkSource,
+        'getChunkByAny',
+        async () => mockedChunk,
+      );
       await chunkCache.getChunkDataByAny(
         TX_SIZE,
         ABSOLUTE_OFFSET,
         B64_DATA_ROOT,
         0,
       );
-      expect(storeGetSpy).to.have.been.called;
-      expect(storeHasSpy).to.have.been.called;
-      expect(networkSpy).to.have.been.called;
+      assert.deepEqual(chunkDataStoreGetSpy.mock.callCount(), 1);
+      assert.deepEqual(chuunkDataStoreHasSpy.mock.callCount(), 1);
+      assert.deepEqual(networkSpy.mock.callCount(), 1);
     });
 
     it('should fetch chunk data from network when an error occurs fetching from local cache', async () => {
-      const storeHasSpy = sandbox.stub(chunkDataStore, 'has').rejects();
-      const storeGetSpy = sandbox.spy(chunkDataStore, 'get');
-      const networkSpy = sandbox
-        .stub(chunkSource, 'getChunkByAny')
-        .resolves(mockedChunk);
+      const storeHasSpy = mock.method(chunkDataStore, 'has', async () => {
+        throw new Error('Error');
+      });
+      const storeGetSpy = mock.method(chunkDataStore, 'get');
+      const networkSpy = mock.method(
+        chunkSource,
+        'getChunkByAny',
+        async () => mockedChunk,
+      );
       await chunkCache.getChunkDataByAny(
         TX_SIZE,
         ABSOLUTE_OFFSET,
         B64_DATA_ROOT,
         0,
       );
-      expect(storeGetSpy).to.have.been.called;
-      expect(storeHasSpy).to.have.been.called;
-      expect(networkSpy).to.have.been.called;
+
+      assert.deepEqual(storeGetSpy.mock.callCount(), 1);
+      assert.deepEqual(storeHasSpy.mock.callCount(), 1);
+      assert.deepEqual(networkSpy.mock.callCount(), 1);
     });
   });
 });