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

package/tests/{amqp.tests.spec.js → amqp.tests.localtest.js}

@@ -1,10 +1,10 @@
-import {expect} from 'chai';
-import {READERS} from '@natlibfi/fixura';
+import assert from 'node:assert';
 import createDebugLogger from 'debug';
+import {promisify} from 'util';
+import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import {amqpFactory} from '../src/index';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import {promisify} from 'util';
+import {amqpFactory} from '../src/index.js';
 
 const setTimeoutPromise = promisify(setTimeout);
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
@@ -23,14 +23,14 @@ let amqpOperator;
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'amqp'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'amqp'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       debug(`Connecting to ${amqpUrl}, with healthCheck running`);
       amqpOperator = await amqpFactory(amqpUrl, true);
@@ -76,13 +76,13 @@ async function callback({
 
     const messageCount = await amqpOperator.checkQueue({queue, style: 'messages'});
     debug(`MessageCount: ${messageCount}`);
-    expect(messageCount).to.eql(expectedMessageCount);
+    assert.equal(messageCount, expectedMessageCount);
 
     if (checkNextMessage) {
       const {headers, records} = await queueCheckNextMessage();
       const nextMessage = {headers, records};
       const expectedNextMessage = getFixture('expectedMessage.json');
-      expect(nextMessage).to.eql(expectedNextMessage);
+      assert.equal(nextMessage, expectedNextMessage);
       return;
     }
 
@@ -90,25 +90,25 @@ async function callback({
     if (!expectToFail) {
       throw error;
     }
-    expect(expectToFail, 'This is expected to fail').to.equal(true);
+    assert.equal(expectToFail, true, 'This is expected to fail');
     testErrors(error);
   }
 
   function testErrors(error) {
-
+    const isApiError = error instanceof ApiError;
     if (expectApiError) {
-      expect(error).to.be.instanceOf(ApiError);
+      assert.equal(isApiError, true);
       debug(`We expected and got an ApiError`);
-      expect(error.status).to.equal(expectedErrorStatus);
+      assert.equal(error.status, expectedErrorStatus);
 
       if (expectedErrorMessage) {
-        expect(error.payload).to.eql(expectedErrorMessage);
+        assert.equal(error.payload, expectedErrorMessage);
         return;
       }
 
       return;
     }
-    expect(error).not.to.be.instanceOf(ApiError);
+    assert.equal(isApiError, false);
     debug(`We expected and got an non-ApiError`);
     debug(`Error is a ${error.constructor.name}`);
   }
@@ -141,11 +141,11 @@ async function callback({
         return;
       }
 
-      expect(result).to.have.property('headers');
-      expect(result).to.have.property('records');
-      expect(result).to.have.property('messages');
-      expect(result.records.length).to.eql(1);
-      expect(result.messages.length).to.eql(1);
+      assert.equal(Object.hasOwn(result, 'headers'), true);
+      assert.equal(Object.hasOwn(result, 'records'), true);
+      assert.equal(Object.hasOwn(result, 'messages'), true);
+      assert.equal(result.records.length, 1);
+      assert.equal(result.messages.length, 1);
 
       return;
     }
@@ -159,15 +159,15 @@ async function callback({
         return;
       }
 
-      expect(fields).to.have.property('deliveryTag');
-      expect(fields).to.have.property('exchange');
-      expect(fields).to.have.property('messageCount');
-      expect(fields).to.have.property('redelivered');
-      expect(fields).to.have.property('routingKey');
-      expect(typeof fields.deliveryTag).to.be.eql('number');
-      expect(typeof fields.messageCount).to.be.eql('number');
-      expect(typeof fields.redelivered).to.be.eql('boolean');
-      expect(typeof fields.routingKey).to.be.eql('string');
+      assert.equal(Object.hasOwn(result, 'deliveryTag'), true);
+      assert.equal(Object.hasOwn(result, 'exchange'), true);
+      assert.equal(Object.hasOwn(result, 'messageCount'), true);
+      assert.equal(Object.hasOwn(result, 'redelivered'), true);
+      assert.equal(Object.hasOwn(result, 'routingKey'), true);
+      assert.equal(typeof fields.deliveryTag, 'number');
+      assert.equal(typeof fields.messageCount, 'number');
+      assert.equal(typeof fields.redelivered, 'boolean');
+      assert.equal(typeof fields.routingKey, 'string');
 
       return;
     }
@@ -180,13 +180,13 @@ async function callback({
         return;
       }
 
-      expect(result).to.have.property('headers');
-      expect(result).to.have.property('records');
-      expect(result).to.have.property('messages');
-      expect(result.records.length).to.eql(3);
-      expect(result.messages.length).to.eql(3);
+      assert.equal(Object.hasOwn(result, 'headers'), true);
+      assert.equal(Object.hasOwn(result, 'records'), true);
+      assert.equal(Object.hasOwn(result, 'messages'), true);
+      assert.equal(result.records.length, 3);
+      assert.equal(result.messages.length, 3);
       const expectedResult = getFixture('expectedResult.json');
-      expect(result.records).to.eql(expectedResult);
+      assert.deepStrictEqual(result.records, expectedResult);
 
       return;
     }
@@ -199,22 +199,22 @@ async function callback({
         return;
       }
 
-      expect(result).to.have.property('headers');
-      expect(result).to.have.property('messages');
-      expect(result.messages.length).to.eql(3);
+      assert.equal(Object.hasOwn(result, 'headers'), true);
+      assert.equal(Object.hasOwn(result, 'messages'), true);
+      assert.equal(result.messages.length, 3);
 
       const [{fields}] = result.messages;
 
-      expect(fields).to.have.property('deliveryTag');
-      expect(fields).to.have.property('exchange');
-      expect(fields).to.have.property('messageCount');
-      expect(fields).to.have.property('redelivered');
-      expect(fields).to.have.property('routingKey');
+      assert.equal(Object.hasOwn(result, 'deliveryTag'), true);
+      assert.equal(Object.hasOwn(result, 'exchange'), true);
+      assert.equal(Object.hasOwn(result, 'messageCount'), true);
+      assert.equal(Object.hasOwn(result, 'redelivered'), true);
+      assert.equal(Object.hasOwn(result, 'routingKey'), true);
 
-      expect(typeof fields.deliveryTag).to.be.eql('number');
-      expect(typeof fields.messageCount).to.be.eql('number');
-      expect(typeof fields.redelivered).to.be.eql('boolean');
-      expect(typeof fields.routingKey).to.be.eql('string');
+      assert.equal(typeof fields.deliveryTag, 'number');
+      assert.equal(typeof fields.messageCount, 'number');
+      assert.equal(typeof fields.redelivered, 'boolean');
+      assert.equal(typeof fields.routingKey, 'string');
 
       return;
     }

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
   });