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

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

package/tests/{mongo-query-by-id.spec.js → mongo-query-by-id.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, compareToDbEntry, formatQueueItem} from './testUtils';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, compareToDbEntry, formatQueueItem} from './testUtils.js';
 
 
 let mongoFixtures; // eslint-disable-line functional/no-let
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:query-
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'query-by-id'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'query-by-id'],
   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', 'query-by-id'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'query-by-id'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -91,7 +91,7 @@ async function callback({
       debug(`queryById result: ${JSON.stringify(opResult)} (it should be: ${JSON.stringify(expectedOpResult)})}`);
       // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
-        expect(formatQueueItem(opResult)).to.eql(formatQueueItem(expectedOpResult));
+        assert.deepStrictEqual(formatQueueItem(opResult), formatQueueItem(expectedOpResult));
       }
       const compareResultIndex = resultIndex ? resultIndex : 0;
       await compareToDbEntry({mongoFixtures, expectedResult, resultIndex: compareResultIndex, expectModificationTime, formatDates: true});

package/tests/{mongo-query.spec.js → mongo-query.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} 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
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'query'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'query'],
   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', 'query'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'query'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -85,7 +85,7 @@ async function callback({
       debug(`query result: ${JSON.stringify(opResult)} (it should be: ${JSON.stringify(expectedOpResult)})}`);
       // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
-        expect(opResult).to.eql(expectedOpResult);
+        assert.deepStrictEqual(opResult, expectedOpResult);
       }
     } catch (error) {
       handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});

package/tests/{mongo-read-content.spec.js → mongo-read-content.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, 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
@@ -12,14 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:read-c
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'read-content'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'read-content'],
   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', 'read-content'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'read-content'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
@@ -95,13 +95,13 @@ async function callback({
 
       // eslint-disable-next-line functional/no-conditional-statements
       if (createBulkParams && createBulkParams.contentType) {
-        expect(opResult.contentType).to.eql(createBulkParams.contentType);
+        assert.equal(opResult.contentType, createBulkParams.contentType);
       }
 
       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-remove.spec.js → mongo-remove.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:remove
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'remove'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'remove'],
   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', 'remove'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'remove'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-set-blob-size.spec.js → mongo-set-blob-size.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:set-blob-size:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-blob-size'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-blob-size'],
   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', 'set-blob-size'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-blob-size'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-set-import-job-state.spec.js → mongo-set-import-job-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:set-im
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-import-job-state'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-import-job-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', 'set-import-job-state'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-import-job-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-set-operation.spec.js → mongo-set-operation.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:set-operation:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-operation'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-operation'],
   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', 'set-operation'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-operation'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongo-set-operations.spec.js → mongo-set-operations.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:set-operations:test');
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-operations'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-operations'],
   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', 'set-operations'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-operations'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

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

@@ -1,10 +1,10 @@
-//import {expect} from 'chai';
+//import assert from 'node:assert';
+import createDebugLogger from 'debug';
 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:set-st
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-state'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongo', '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', 'set-state'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });

package/tests/{mongoLog.spec.js → mongoLog.test.js}

@@ -1,22 +1,21 @@
-// import {expect} from 'chai';
+import assert from 'node:assert';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
-import {expect} from 'chai';
-import createMongoLogOperator from '../src/mongoLog';
+import createMongoLogOperator from '../src/mongoLog.js';
 
 let mongoFixtures; // eslint-disable-line functional/no-let
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'mongoLog'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
   recurse: false,
   useMetadataFile: true,
   fixura: {
     failWhenNotFound: true,
     reader: READERS.JSON
   },
-  mocha: {
+  hooks: {
     before: async () => {
       await initMongofixtures();
     },
@@ -30,7 +29,7 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    rootPath: [__dirname, '..', 'test-fixtures', 'mongoLog'],
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
     gridFS: {bucketName: 'blobs'},
     useObjectId: true,
     format: {
@@ -51,34 +50,34 @@ async function callback({
   const expectedResult = await getFixture('expectedResult.json');
   // console.log(typeof mongoUri); // eslint-disable-line
 
-  if (preFillDb) { // eslint-disable-line functional/no-conditional-statements
+  if (preFillDb) {
     await mongoFixtures.populate(getFixture('dbContents.json'));
   }
 
   if (functionName === 'addLogItem') {
     await mongoLogOperator.addLogItem(params);
     const dump = await mongoFixtures.dump();
-    return expect(dump.logs[0]['0']).to.eql(expectedResult);
+    return assert.deepStrictEqual(dump.logs[0]['0'], expectedResult);
   }
 
   if (functionName === 'getListOfCatalogers') {
     const result = await mongoLogOperator.getListOfCatalogers();
     // console.log(result); // eslint-disable-line
 
-    return expect(result).to.eql(expectedResult);
+    return assert.deepEqual(result, expectedResult);
   }
 
   if (functionName === 'getExpandedListOfLogs') {
     const result = await mongoLogOperator.getExpandedListOfLogs(params);
     // console.log(result); // eslint-disable-line
 
-    return expect(result).to.eql(expectedResult);
+    return assert.deepEqual(result, expectedResult);
   }
 
   if (functionName === 'getListOfLogs') {
     const result = await mongoLogOperator.getListOfLogs(params);
     // console.log(result); // eslint-disable-line
-    return expect(result).to.eql(expectedResult);
+    return assert.deepEqual(result, expectedResult);
   }
   throw new Error(`Unknown functionName: ${functionName}`);
 }