@natlibfi/melinda-rest-api-commons 4.2.5 → 5.0.0-alpha.1

package/tests/helpers/{conversion.spec.js → conversion.test.js}

@@ -1,20 +1,23 @@
 
 
-import {expect} from 'chai';
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
 import fixtureFactory from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
 import {Error as ConversionError} from '@natlibfi/melinda-commons';
-import createConversionService from '../../src/helpers/conversion';
-import {CONVERSION_FORMATS} from '../../src/constants';
+import createConversionService from '../../src/helpers/conversion.js';
+import {CONVERSION_FORMATS} from '../../src/constants.js';
 
 describe('services/conversion', () => {
-  const {getFixture} = fixtureFactory({root: [
-    __dirname,
-    '..',
-    '..',
-    'test-fixtures',
-    'conversion'
-  ]});
+  const {getFixture} = fixtureFactory({
+    root: [
+      import.meta.dirname,
+      '..',
+      '..',
+      'test-fixtures',
+      'conversion'
+    ]
+  });
   const conversionService = createConversionService();
 
   const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']})), {subfieldValues: false});
@@ -27,69 +30,79 @@ describe('services/conversion', () => {
   describe('factory', () => {
     it('Should create the expected object', () => {
       const service = createConversionService();
-      expect(service).to.be.an('object').and
-        .respondTo('serialize')
-        .respondTo('unserialize');
+      assert.equal(typeof service, 'object');
+      assert.equal(Object.hasOwn(service, 'serialize'), true);
+      assert.equal(Object.hasOwn(service, 'unserialize'), true);
     });
   });
 
   describe('#serialize', () => {
     it('Should throw because of unsupported format', () => {
-      expect(conversionService.serialize).to.throw();
+      try {
+        conversionService.serialize();
+      } catch (error) {
+        assert(error instanceof ConversionError);
+      }
     });
 
     it('Should serialize to MARCXML', () => {
       const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.MARCXML);
-      expect(data).to.equal(marcXml);
+      assert.equal(data, marcXml);
     });
 
     it('Should serialize to ISO2709', () => {
       const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.ISO2709);
-      expect(data).to.equal(iso2709);
+      assert.equal(data, iso2709);
     });
 
     it('Should serialize to JSON', () => {
       const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.JSON);
-      expect(data).to.equal(json);
+      assert.equal(data, json);
     });
 
     it('Should serialize to aleph sequential', () => {
       const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.ALEPHSEQ);
-      expect(data).to.equal(alephSeq);
+      assert.equal(data, alephSeq);
     });
 
   });
 
   describe('#unserialize', () => {
     it('Should throw because of unsupported format', () => {
-      expect(conversionService.unserialize).to.throw();
+      try {
+        conversionService.unserialize();
+      } catch (error) {
+        assert(error instanceof ConversionError);
+      }
     });
 
     it('Should unserialize from MARCXML', async () => {
       const record = await conversionService.unserialize(marcXml, CONVERSION_FORMATS.MARCXML);
-      expect(record.equalsTo(marcRecord)).to.equal(true);
+      assert.equal(record.equalsTo(marcRecord), true);
     });
 
     it('Should unserialize from ISO2709', () => {
       const record = conversionService.unserialize(iso2709, CONVERSION_FORMATS.ISO2709);
-      expect(record.equalsTo(marcRecord)).to.equal(true);
+      assert.equal(record.equalsTo(marcRecord), true);
     });
 
     it('Should unserialize from JSON', () => {
       const record = conversionService.unserialize(json, CONVERSION_FORMATS.JSON);
-      expect(record.equalsTo(marcRecord)).to.equal(true);
+      assert.equal(record.equalsTo(marcRecord), true);
     });
 
     it('Should unserialize from Aleph sequential', () => {
       const record = conversionService.unserialize(alephSeq, CONVERSION_FORMATS.ALEPHSEQ);
-      expect(record.equalsTo(marcRecord)).to.equal(true);
+      assert.equal(record.equalsTo(marcRecord), true);
     });
 
 
     it('Should throw because the record could not be unserialized', () => {
-      expect(() => {
+      try {
         conversionService.unserialize('', CONVERSION_FORMATS.JSON);
-      }).to.throw(ConversionError);
+      } catch (error) {
+        assert(error instanceof ConversionError);
+      }
     });
   });
 });

package/tests/helpers/{fix.spec.js → fix.test.js}

@@ -1,10 +1,10 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
+import createDebugLogger from 'debug';
 import {MarcRecord} from '@natlibfi/marc-record';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import {fixRecord} from '../../src/helpers/fix';
-import * as fixSettings from '../../src/helpers/fix-constants';
-import createDebugLogger from 'debug';
+import {fixRecord} from '../../src/helpers/fix.js';
+import * as fixSettings from '../../src/helpers/fix-constants.js';
 // import inspect from 'util';
 
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:fix:test');
@@ -12,7 +12,7 @@ const debugData = debug.extend('data');
 
 generateTests({
   callback,
-  path: [__dirname, '..', '..', 'test-fixtures', 'fix'],
+  path: [import.meta.dirname, '..', '..', 'test-fixtures', 'fix'],
   recurse: true,
   useMetadataFile: true,
   fixura: {
@@ -36,6 +36,6 @@ function callback({getFixture, settings = undefined}) {
   const resultRecord = fixRecord(record, runSettings);
   debugData(`Result:   ${JSON.stringify(resultRecord)}`);
   debugData(`Expected: ${JSON.stringify(expectedRecord)}`);
-  expect(resultRecord).to.eql(expectedRecord);
+  assert.deepStrictEqual(resultRecord, expectedRecord);
 
 }

package/tests/helpers/{validation.spec.js → validation.test.js}

@@ -1,11 +1,12 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
 import fixtureFactory, {READERS} from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
-import createValidator from '../../src/helpers/validation';
+import createValidator from '../../src/helpers/validation.js';
 
 describe('services/validate', () => {
   const FIXTURES_PATH = [
-    __dirname,
+    import.meta.dirname,
     '..',
     '..',
     'test-fixtures',
@@ -23,14 +24,15 @@ describe('services/validate', () => {
         ]
       }));
       const result = await validator(record.toObject());
-      const expected = getFixture({
+      const {record: expectedRecord, ...rest} = getFixture({
         components: [
           'out',
           'f003-fi-melinda.json'
         ]
       });
-      expect(result).to.eql(expected);
-      expect(result.failed).to.equal(false);
+      const {_validationOptions, ...expectedRecordData} = expectedRecord;
+      assert.deepStrictEqual(result, {...rest, record: new MarcRecord(expectedRecordData, _validationOptions)});
+      assert.equal(result.failed, false);
     });
   });
 
@@ -44,14 +46,15 @@ describe('services/validate', () => {
         ]
       }));
       const result = await validator(record.toObject());
-      const expected = getFixture({
+      const {record: expectedRecord, ...rest} = getFixture({
         components: [
           'out',
           'f003-not-fi-melinda.json'
         ]
       });
-      expect(result).to.eql(expected);
-      expect(result.failed).to.equal(true);
+      const {_validationOptions, ...expectedRecordData} = expectedRecord;
+      assert.deepStrictEqual(result, {...rest, record: new MarcRecord(expectedRecordData, _validationOptions)});
+      assert.equal(result.failed, true);
     });
   });
 });

package/tests/{mongo-add-blob-size.spec.js → mongo-add-blob-size.test.js}

@@ -1,10 +1,10 @@
-//import {expect} from 'chai';
+//import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:add-bl
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -42,7 +42,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-check-and-check-state.spec.js → mongo-check-and-check-state.test.js}

@@ -1,10 +1,10 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test')
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -42,7 +42,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -91,7 +91,7 @@ async function callback({
 
       // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
-        expect(opResult).to.eql(expectedOpResult);
+        assert.deepStrictEqual(opResult, expectedOpResult);
       }
       await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
 

package/tests/{mongo-check-and-set-import-job-state.spec.js → mongo-check-and-set-import-job-state.test.js}

@@ -1,24 +1,24 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-and-set-import-job-state-test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -41,7 +41,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -91,7 +91,7 @@ async function callback({
 
       // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
-        expect(opResult).to.eql(expectedOpResult);
+        assert.deepStrictEqual(opResult, expectedOpResult);
       }
       await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
     } catch (error) {

package/tests/{mongo-check-timeout.spec.js → mongo-check-timeout.test.js}

@@ -1,10 +1,10 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -42,7 +42,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -91,7 +91,7 @@ async function callback({
 
       // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
-        expect(opResult).to.eql(expectedOpResult);
+        assert.deepStrictEqual(opResult, expectedOpResult);
       }
       await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
     } catch (error) {

package/tests/{mongo-create-bulk.spec.js → mongo-create-bulk.test.js}

@@ -2,22 +2,22 @@ import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test:create-bulk');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -40,7 +40,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-create-prio.spec.js → mongo-create-prio.test.js}

@@ -1,24 +1,24 @@
-//import {expect} from 'chai';
+//import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
-// import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+// import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:create-prio-test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -41,7 +41,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-get-one.spec.js → mongo-get-one.test.js}

@@ -1,10 +1,10 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-on
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -42,7 +42,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -81,7 +81,7 @@ async function callback({
       const opResult = await mongoOperator.getOne(params);
       debug(`getOne result: ${JSON.stringify(opResult)} (it should be: ${JSON.stringify(expectedOpResult)})}`);
 
-      expect(opResult).to.eql(expectedOpResult);
+      assert.deepStrictEqual(opResult, expectedOpResult);
 
     } catch (error) {
       handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});

package/tests/{mongo-get-stream.spec.js → mongo-get-stream.test.js}

@@ -1,24 +1,24 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, streamToString} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, streamToString} from './testUtils.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-stream:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'get-stream'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-stream'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -41,7 +41,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'get-stream'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-stream'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -96,7 +96,7 @@ async function callback({
       if (contentStream) {
         const contentStreamString = await getFixture({components: ['contentStream'], reader: READERS.TEXT});
         //debug(contentStreamString);
-        expect(opResultString).to.eql(contentStreamString);
+        assert.equal(opResultString, contentStreamString);
         return;
       }
 

package/tests/{mongo-push-ids.spec.js → mongo-push-ids.test.js}

@@ -2,8 +2,8 @@ import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -11,14 +11,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:push-i
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'push-ids'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-ids'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -41,7 +41,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'push-ids'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-ids'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-push-messages.spec.js → mongo-push-messages.test.js}

@@ -1,24 +1,24 @@
-//import {expect} from 'chai';
+//import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:push-messages:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       //debug(`<< Before`);
       await initMongofixtures();
@@ -41,7 +41,7 @@ generateTests({
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
     recurse: false,
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });