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

package/tests/helpers/validation.spec.js

@@ -0,0 +1,58 @@
+import {expect} from 'chai';
+import fixtureFactory, {READERS} from '@natlibfi/fixura';
+import {MarcRecord} from '@natlibfi/marc-record';
+import createValidator from '../../src/helpers/validation';
+
+describe('services/validate', () => {
+  const FIXTURES_PATH = [
+    __dirname,
+    '..',
+    '..',
+    'test-fixtures',
+    'validation'
+  ];
+  const {getFixture} = fixtureFactory({root: FIXTURES_PATH, reader: READERS.JSON});
+
+  describe('f003-fi-melinda', () => {
+    it('Should have failed: false', async () => {
+      const validator = await createValidator();
+      const record = new MarcRecord(getFixture({
+        components: [
+          'in',
+          'f003-fi-melinda.json'
+        ]
+      }));
+      const result = await validator(record.toObject());
+      const expected = getFixture({
+        components: [
+          'out',
+          'f003-fi-melinda.json'
+        ]
+      });
+      expect(result).to.eql(expected);
+      expect(result.failed).to.equal(false);
+    });
+  });
+
+  describe('f003-not-fi-melinda', () => {
+    it('Should have failed: true', async () => {
+      const validator = await createValidator();
+      const record = new MarcRecord(getFixture({
+        components: [
+          'in',
+          'f003-not-fi-melinda.json'
+        ]
+      }));
+      const result = await validator(record.toObject());
+      const expected = getFixture({
+        components: [
+          'out',
+          'f003-not-fi-melinda.json'
+        ]
+      });
+      expect(result).to.eql(expected);
+      expect(result.failed).to.equal(true);
+    });
+  });
+});
+

package/tests/mongo-add-blob-size.spec.js

@@ -0,0 +1,92 @@
+//import {expect} from 'chai';
+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';
+
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:add-blob-size:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
+  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', 'add-blob-size'],
+    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 = ''
+
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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 === 'addBlobSize') {
+    try {
+      debug(`addBlobSize`);
+      debug(JSON.stringify(params));
+      //{correlationId}
+      const opResult = await mongoOperator.addBlobSize(params);
+      debug(`addBlobSize result: ${JSON.stringify(opResult)}`);
+      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-and-check-state.spec.js

@@ -0,0 +1,105 @@
+import {expect} from 'chai';
+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';
+
+
+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 = '',
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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,104 @@
+import {expect} from 'chai';
+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';
+
+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 = '',
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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 === '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,104 @@
+import {expect} from 'chai';
+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';
+
+
+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 = '',
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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,93 @@
+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';
+
+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,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  contentStream = false,
+  expectedFileCount = undefined
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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 === '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,89 @@
+//import {expect} from 'chai';
+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';
+
+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
+  });
+}
+
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = ''
+}) {
+
+  const mongoOperator = await getMongoOperator(mongoFixtures);
+  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 === '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}`);
+}
+