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

package/tests/mongo-push-messages.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 {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:push-messages:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
+  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', 'push-messages'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+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 === 'pushMessages') {
+    try {
+      debug(`pushMessages`);
+      debug(JSON.stringify(params));
+      //{correlationId, messages, messageField = 'messages'}
+      const opResult = await mongoOperator.pushMessages(params);
+      debug(`pushMessages 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-query-by-id.spec.js

@@ -0,0 +1,106 @@
+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, compareToDbEntry, formatQueueItem} from './testUtils';
+
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:query-by-id:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'query-by-id'],
+  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', 'query-by-id'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  expectedOpResult = undefined,
+  updateStateBeforeTest = undefined,
+  resultIndex = 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 === 'queryById') {
+    try {
+      debug(`queryById`);
+      debug(JSON.stringify(params));
+      //{correlationId, checkModTime = false}
+      // 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.queryById(params);
+      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));
+      }
+      const compareResultIndex = resultIndex ? resultIndex : 0;
+      await compareToDbEntry({mongoFixtures, expectedResult, resultIndex: compareResultIndex, expectModificationTime, formatDates: true});
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-query.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 createDebugLogger from 'debug';
+//import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils';
+import {getMongoOperator, handleError} 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', 'query'],
+  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', 'query'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  expectedOpResult = 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 === 'query') {
+    try {
+      debug(`query`);
+      debug(JSON.stringify(params));
+      //params, showParams = {}
+      //params: skip, limit, rest (rest: actual mongo queryParams)
+      //showParams: {showAll = 0, showOperations = 0, showOperationSettings = 0, showRecordLoadParams = 0, showImportJobState = 0} = showParams;
+      debug(`${JSON.stringify(params.params)}`);
+      debug(`${JSON.stringify(params.showParams)}`);
+      const opResult = await mongoOperator.query(params.params, params.showParams);
+      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);
+      }
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-read-content.spec.js

@@ -0,0 +1,115 @@
+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, streamToString} from './testUtils';
+
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:read-content:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'read-content'],
+  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', 'read-content'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  contentStream = false,
+  createBulkParams = 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 === 'readContent') {
+    try {
+      debug(`readContent`);
+      debug(JSON.stringify(params));
+      //correlationId
+
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (createBulkParams) {
+        const stream = contentStream ? await getFixture({components: ['contentStream'], reader: READERS.STREAM}) : createBulkParams.stream;
+        //debug(stream);
+        const params2 = {...createBulkParams, stream};
+        const createBulkResult = await mongoOperator.createBulk(params2);
+        debug(`createBulkResult: ${JSON.stringify(createBulkResult)}`);
+      }
+
+      const opResult = await mongoOperator.readContent(params);
+      const opResultString = await streamToString(opResult.readStream);
+
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (createBulkParams && createBulkParams.contentType) {
+        expect(opResult.contentType).to.eql(createBulkParams.contentType);
+      }
+
+      if (contentStream) {
+        const contentStreamString = await getFixture({components: ['contentStream'], reader: READERS.TEXT});
+        //debug(contentStreamString);
+        expect(opResultString).to.eql(contentStreamString);
+        return;
+      }
+
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-remove.spec.js

@@ -0,0 +1,110 @@
+//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:remove:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'remove'],
+  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', 'remove'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+// eslint-disable-next-line max-statements
+async function callback({
+  getFixture,
+  functionName,
+  params,
+  expectModificationTime = false,
+  preFillDb = false,
+  expectedToThrow = false,
+  expectedErrorMessage = '',
+  expectedErrorStatus = '',
+  contentStream = false,
+  createBulkParams = undefined,
+  expectedFileCount = undefined,
+  expectUndefined = 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 === 'remove') {
+
+    try {
+      debug(`remove`);
+      debug(JSON.stringify(params));
+      //params: {correlationId}
+
+      // eslint-disable-next-line functional/no-conditional-statements
+      if (createBulkParams) {
+        const stream = contentStream ? await getFixture({components: ['contentStream'], reader: READERS.STREAM}) : createBulkParams.stream;
+        //debug(stream);
+        const params2 = {...createBulkParams, stream};
+        const createBulkResult = await mongoOperator.createBulk(params2);
+        debug(`createBulkResult: ${JSON.stringify(createBulkResult)}`);
+      }
+
+      const opResult = await mongoOperator.remove(params);
+      debug(`remove result: ${JSON.stringify(opResult)}`);
+      debug(`expectUndefined: ${expectUndefined}`);
+
+      await compareToFirstDbEntry({mongoFixtures, expectedResult: expectUndefined ? undefined : expectedResult, expectModificationTime, formatDates: true, expectedFileCount});
+
+    } catch (error) {
+      handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus});
+      return;
+    }
+    return;
+  }
+  throw new Error(`Unknown functionName: ${functionName}`);
+}

package/tests/mongo-set-blob-size.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 {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:set-blob-size:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', 'set-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', 'set-blob-size'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+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 === 'setBlobSize') {
+    try {
+      debug(`setBlobSize`);
+      debug(JSON.stringify(params));
+      //{correlationId,  blobSize}
+      const opResult = await mongoOperator.setBlobSize(params);
+      debug(`setBlobSize 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-set-import-job-state.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:set-import-job-state:test');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'mongo', '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', 'set-import-job-state'],
+    gridFS: {bucketName: 'foobar'},
+    useObjectId: true
+  });
+}
+
+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 === 'setImportJobState') {
+    try {
+      debug(`setImportJobState`);
+      debug(JSON.stringify(params));
+      //{correlationId, operation, importJobState}
+      const opResult = await mongoOperator.setImportJobState(params);
+      debug(`setImportJobState 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}`);
+}
+