@natlibfi/melinda-rest-api-commons 4.2.3-alpha.1 → 4.2.4-alpha.11

package/tests/mongo-check-and-check-state.spec.js

@@ -0,0 +1,112 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {handleError, compareToFirstDbEntry} from './testUtils';
+
+
+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', 'check-and-set-state'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  //contentStream = false,
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  //expectedFileCount = undefined,
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  const expectedResult = await getFixture('expectedResult.json');
+
+  await doPreFillDb(preFillDb);
+
+  async function doPreFillDb(preFillDb) {
+    if (preFillDb) {
+      await mongoFixtures.populate(getFixture('dbContents.json'));
+      return;
+    }
+    return;
+  }
+
+  if (functionName === 'checkAndSetState') {
+    try {
+      debug(`checkAndSetState`);
+      debug(JSON.stringify(params));
+      //{correlationId, state, errorMessage = undefined, errorStatus = undefined})
+      // timeout
+
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (updateStateBeforeTest && params.correlationId) {
+        debug(`setState to reset modificationTime`);
+        await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
+      }
+      const opResult = await mongoOperator.checkAndSetState(params);
+      debug(`checkAndSetState 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);
+      }
+      await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
+
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+    }
+    return;
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-check-and-set-import-job-state.spec.js

@@ -0,0 +1,112 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {handleError, compareToFirstDbEntry} from './testUtils';
+
+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'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements, complexity
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  //contentStream = false,
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  //expectedFileCount = undefined,
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  const expectedResult = await getFixture('expectedResult.json');
+  // DEVELOP: we could use sama function for most of tests?
+  // debug(typeof mongoUri); // eslint-disable-line
+
+  await doPreFillDb(preFillDb);
+
+  async function doPreFillDb(preFillDb) {
+    if (preFillDb) {
+      await mongoFixtures.populate(getFixture('dbContents.json'));
+      return;
+    }
+    return;
+  }
+
+  if (functionName === 'checkAndSetImportJobState') {
+    try {
+      debug(`checkAndSetImportJobState`);
+      debug(JSON.stringify(params));
+      //{correlationId, operation, importJobState, errorMessage = '', errorStatus = ''}
+      // timeout
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (updateStateBeforeTest && params.correlationId) {
+        debug(`setState to reset modificationTime`);
+        await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
+      }
+      const opResult = await mongoOperator.checkAndSetImportJobState(params);
+      debug(`checkAndSetImportJobState 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);
+      }
+      await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-check-timeout.spec.js

@@ -0,0 +1,111 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {handleError, compareToFirstDbEntry} from './testUtils';
+
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-timeout:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements, complexity
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  //contentStream = false,
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  //expectedFileCount = undefined,
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  const expectedResult = await getFixture('expectedResult.json');
+
+  await doPreFillDb(preFillDb);
+
+  async function doPreFillDb(preFillDb) {
+    if (preFillDb) {
+      await mongoFixtures.populate(getFixture('dbContents.json'));
+      return;
+    }
+    return;
+  }
+
+  if (functionName === 'checkTimeOut') {
+    try {
+      debug(`checkTimeOut`);
+      debug(JSON.stringify(params));
+      //{correlationId}
+      // timeout
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (updateStateBeforeTest && params.correlationId) {
+        debug(`setState to reset modificationTime`);
+        await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
+      }
+      const opResult = await mongoOperator.checkTimeOut(params);
+      debug(`checkTimeOut 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);
+      }
+      await compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime, formatDates: true});
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-create-bulk.spec.js

@@ -0,0 +1,100 @@
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {handleError, compareToFirstDbEntry} from './testUtils';
+
+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'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements, complexity
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  //expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  contentStream = false,
+  //expectedOpResult = undefined,
+  //updateStateBeforeTest = undefined,
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  expectedFileCount = undefined
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  const expectedResult = await getFixture('expectedResult.json');
+  // DEVELOP: we could use sama function for most of tests?
+  // debug(typeof mongoUri); // eslint-disable-line
+
+  if (preFillDb) { // eslint-disable-line functional/no-conditional-statements
+    await mongoFixtures.populate(getFixture('dbContents.json'));
+  }
+
+  //return {createPrio, createBulk, checkAndSetState, checkAndSetImportJobState, query, queryById, remove, readContent, removeContent, getOne, getStream, setState, setImportJobState, pushIds, pushMessages, setOperation, setOperations, addBlobSize, setBlobSize};
+
+
+  if (functionName === 'createBulk') {
+    try {
+      debug(`CreateBulk`);
+      debug(JSON.stringify(params));
+      //{correlationId, cataloger, oCatalogerIn, operation, contentType, recordLoadParams, stream, operationSettings}
+      const stream = contentStream ? await getFixture({components: ['contentStream'], reader: READERS.STREAM}) : params.stream;
+      const params2 = {...params, stream};
+      const opResult = await mongoOperator.createBulk(params2);
+      debug(`createBulkResult: ${JSON.stringify(opResult)}`);
+      await compareToFirstDbEntry({mongoFixtures, expectedResult, formatDates: true, expectedFileCount});
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-create-prio.spec.js

@@ -0,0 +1,98 @@
+//import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+import {handleError, compareToFirstDbEntry} from './testUtils';
+// import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+
+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'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements, complexity
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  //expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = ''
+  //contentStream = false,
+  //expectedOpResult = undefined,
+  //updateStateBeforeTest = undefined,
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  //expectedFileCount = undefined,
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  const expectedResult = await getFixture('expectedResult.json');
+  // DEVELOP: we could use sama function for most of tests?
+  // debug(typeof mongoUri); // eslint-disable-line
+
+  if (preFillDb) { // eslint-disable-line functional/no-conditional-statements
+    await mongoFixtures.populate(getFixture('dbContents.json'));
+  }
+
+  //return {createPrio, createBulk, checkAndSetState, checkAndSetImportJobState, query, queryById, remove, readContent, removeContent, getOne, getStream, setState, setImportJobState, pushIds, pushMessages, setOperation, setOperations, addBlobSize, setBlobSize};
+
+  if (functionName === 'createPrio') {
+    try {
+      debug(`CreatePrio`);
+      debug(JSON.stringify(params));
+      const opResult = await mongoOperator.createPrio(params);
+      debug(`createPrio result: ${JSON.stringify(opResult)}`);
+      await compareToFirstDbEntry({mongoFixtures, expectedResult, formatDates: true});
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}
+

package/tests/mongo-get-one.spec.js

@@ -0,0 +1,103 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import generateTests from '@natlibfi/fixugen';
+import createMongoOperator from '../src/mongo';
+import createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {handleError} from './testUtils';
+
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-one:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      //debug(`<< Before`);
+      await initMongofixtures();
+    },
+    beforeEach: async () => {
+      //debug(`<< BeforeEach`);
+      await mongoFixtures.clear();
+    },
+    afterEach: async () => {
+      //debug(`<< AfterEach`);
+      await mongoFixtures.clear();
+    },
+    after: async () => {
+      //debug(`<< After`);
+      await mongoFixtures.close();
+    }
+  }
+});
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    recurse: false,
+    rootPath: [__dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements, complexity
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  //expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  //contentStream = false,
+  expectedOpResult = undefined
+  //updateStateBeforeTest = undefined,
+  //resultIndex = undefined,
+  //createBulkParams = undefined,
+  //expectedFileCount = undefined,
+  //expectUndefined = undefined
+}) {
+
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
+  //const expectedResult = await getFixture('expectedResult.json');
+
+  await doPreFillDb(preFillDb);
+
+  async function doPreFillDb(preFillDb) {
+    if (preFillDb) {
+      await mongoFixtures.populate(getFixture('dbContents.json'));
+      return;
+    }
+    return;
+  }
+
+
+  if (functionName === 'getOne') {
+    try {
+      debug(`getOne`);
+      debug(JSON.stringify(params));
+      //{queueItemState, importJobState = undefined}
+      const opResult = await mongoOperator.getOne(params);
+      debug(`getOne result: ${JSON.stringify(opResult)} (it should be: ${JSON.stringify(expectedOpResult)})}`);
+
+      expect(opResult).to.eql(expectedOpResult);
+
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+  throw new Error(`Unknown functionName: ${functionName}`);
+}