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

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

package/tests/testUtils.js

@@ -1,7 +1,7 @@
 
-import {expect} from 'chai';
+import assert from 'node:assert';
 import createDebugLogger from 'debug';
-import createMongoOperator from '../src/mongo';
+import createMongoOperator from '../src/mongo.js';
 
 
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test');
@@ -32,10 +32,10 @@ export async function compareToDbEntry({mongoFixtures, expectedResult, resultInd
 
   if (formatDates && expectedResult !== undefined) {
     const formattedResult = formatQueueItem(result);
-    expect(formattedResult).to.eql(expectedResult);
+    assert.deepStrictEqual(formattedResult, expectedResult);
     return;
   }
-  expect(result).to.eql(expectedResult);
+  assert.deepStrictEqual(result, expectedResult);
   return;
 }
 
@@ -43,7 +43,7 @@ function checkFileCount({dump, expectedFileCount}) {
   if (expectedFileCount !== undefined) {
     const fileCount = dump['foobar.files']?.length;
     debug(`--- We have ${fileCount} files in db`);
-    expect(fileCount).to.eql(expectedFileCount);
+    assert.equal(fileCount, expectedFileCount);
     return;
   }
   return;
@@ -53,7 +53,8 @@ function checkFileCount({dump, expectedFileCount}) {
 function checkModificationTime({result, expectModificationTime}) {
   if (expectModificationTime) {
     debug('Check if modificationTime was edited');
-    expect(result.modificationTime).to.not.eql('');
+    const isNotEmpty = result.modificationTime !== '';
+    assert.equal(isNotEmpty, true);
     debug(`OK. We have modified modificationTime`);
     return;
   }
@@ -80,9 +81,9 @@ export function handleError({error, expectedToThrow, expectedErrorMessage, expec
     if (expectedErrorMessage !== '' || expectedErrorStatus !== '') {
       const errorMessage = error.message || error.payload.message || error.payload || '';
       debug(errorMessage);
-      expect(errorMessage).to.eql(expectedErrorMessage);
+      assert.equal(errorMessage, expectedErrorMessage);
       const errorStatus = error.status || '';
-      expect(errorStatus).to.eql(expectedErrorStatus);
+      assert.equal(errorStatus, expectedErrorStatus);
       return;
     }
     return;