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

package/tests/amqp.tests.spec.js

@@ -0,0 +1,301 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import createDebugLogger from 'debug';
+import generateTests from '@natlibfi/fixugen';
+import {amqpFactory} from '../src/index';
+import {Error as ApiError} from '@natlibfi/melinda-commons';
+import {promisify} from 'util';
+
+const setTimeoutPromise = promisify(setTimeout);
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
+//const debugData = debug.extend('data');
+
+const testData = {
+  queue: 'TESTQUEUE',
+  correlationId: 'aaaaaaaa-0000-aaaa-0000-000000000000',
+  data: {'leader': '02518cam a2200745zi 4500', 'fields': [{'tag': '001', 'value': '000019640'}]}
+};
+
+debug(`Testing amqp against a local AMQP instance - we'll need some kind of mockup for this`);
+const amqpUrl = 'amqp://127.0.0.1:5672/';
+// eslint-disable-next-line functional/no-let
+let amqpOperator;
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'amqp'],
+  recurse: false,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: true,
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: async () => {
+      debug(`Connecting to ${amqpUrl}, with healthCheck running`);
+      amqpOperator = await amqpFactory(amqpUrl, true);
+    },
+    beforeEach: async () => {
+      await amqpOperator.checkQueue({queue: testData.queue, toRecord: false, purge: true});
+    },
+    afterEach: async () => {
+      await amqpOperator.removeQueue(testData.queue);
+    },
+    after: async () => {
+      await amqpOperator.closeConnection();
+      //await testHeathCheck();
+    }
+  }
+});
+
+// eslint-disable-next-line max-statements
+async function callback({
+  getFixture,
+  expectToFail = false,
+  expectedErrorStatus = '',
+  ackMessages = false,
+  nackMessages = false,
+  checkNextMessage = false,
+  checkQueueStyle = false,
+  queue = testData.queue,
+  sentToQueue,
+  expectedMessageCount,
+  removeQueue = false,
+  expectedErrorMessage = undefined,
+  expectApiError = false,
+  expectFalseCheckResult = false
+}) {
+  try {
+    await sendMessagesToQueue();
+
+    await ackOrNackMessages();
+
+    await checkQueue();
+
+    await queueRemoval();
+
+    const messageCount = await amqpOperator.checkQueue({queue, style: 'messages'});
+    debug(`MessageCount: ${messageCount}`);
+    expect(messageCount).to.eql(expectedMessageCount);
+
+    if (checkNextMessage) {
+      const {headers, records} = await queueCheckNextMessage();
+      const nextMessage = {headers, records};
+      const expectedNextMessage = getFixture('expectedMessage.json');
+      expect(nextMessage).to.eql(expectedNextMessage);
+      return;
+    }
+
+  } catch (error) {
+    if (!expectToFail) {
+      throw error;
+    }
+    expect(expectToFail, 'This is expected to fail').to.equal(true);
+    testErrors(error);
+  }
+
+  function testErrors(error) {
+
+    if (expectApiError) {
+      expect(error).to.be.instanceOf(ApiError);
+      debug(`We expected and got an ApiError`);
+      expect(error.status).to.equal(expectedErrorStatus);
+
+      if (expectedErrorMessage) {
+        expect(error.payload).to.eql(expectedErrorMessage);
+        return;
+      }
+
+      return;
+    }
+    expect(error).not.to.be.instanceOf(ApiError);
+    debug(`We expected and got an non-ApiError`);
+    debug(`Error is a ${error.constructor.name}`);
+  }
+
+  function queueRemoval() {
+    if (removeQueue) {
+      return amqpOperator.removeQueue(removeQueue);
+    }
+
+    return;
+  }
+
+  function queueCheckNextMessage() {
+    if (checkNextMessage) {
+      return amqpOperator.consumeOne(testData.queue, true);
+    }
+
+    return false;
+  }
+
+  // eslint-disable-next-line max-statements
+  async function checkQueue() {
+    debug(`checkQueueStyle: ${checkQueueStyle}`);
+
+    if (checkQueueStyle === 'oneToRecord') {
+      const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: true, purge: false});
+
+      if (expectFalseCheckResult) {
+        expect(result).to.eql(false);
+        return;
+      }
+
+      expect(result).to.have.property('headers');
+      expect(result).to.have.property('records');
+      expect(result).to.have.property('messages');
+      expect(result.records.length).to.eql(1);
+      expect(result.messages.length).to.eql(1);
+
+      return;
+    }
+
+    if (checkQueueStyle === 'oneNotRecord') {
+      const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: false, purge: false});
+      const {fields} = result;
+
+      if (expectFalseCheckResult) {
+        expect(result).to.eql(false);
+        return;
+      }
+
+      expect(fields).to.have.property('deliveryTag');
+      expect(fields).to.have.property('exchange');
+      expect(fields).to.have.property('messageCount');
+      expect(fields).to.have.property('redelivered');
+      expect(fields).to.have.property('routingKey');
+      expect(typeof fields.deliveryTag).to.be.eql('number');
+      expect(typeof fields.messageCount).to.be.eql('number');
+      expect(typeof fields.redelivered).to.be.eql('boolean');
+      expect(typeof fields.routingKey).to.be.eql('string');
+
+      return;
+    }
+
+    if (checkQueueStyle === 'basicToRecord') {
+      const result = await amqpOperator.checkQueue({queue, style: 'basic', toRecord: true, purge: false});
+
+      if (expectFalseCheckResult) {
+        expect(result).to.eql(false);
+        return;
+      }
+
+      expect(result).to.have.property('headers');
+      expect(result).to.have.property('records');
+      expect(result).to.have.property('messages');
+      expect(result.records.length).to.eql(3);
+      expect(result.messages.length).to.eql(3);
+      const expectedResult = getFixture('expectedResult.json');
+      expect(result.records).to.eql(expectedResult);
+
+      return;
+    }
+
+    if (checkQueueStyle === 'basicNotRecord') {
+      const result = await amqpOperator.checkQueue({queue, style: 'basic', toRecord: false, purge: false});
+
+      if (expectFalseCheckResult) {
+        expect(result).to.eql(false);
+        return;
+      }
+
+      expect(result).to.have.property('headers');
+      expect(result).to.have.property('messages');
+      expect(result.messages.length).to.eql(3);
+
+      const [{fields}] = result.messages;
+
+      expect(fields).to.have.property('deliveryTag');
+      expect(fields).to.have.property('exchange');
+      expect(fields).to.have.property('messageCount');
+      expect(fields).to.have.property('redelivered');
+      expect(fields).to.have.property('routingKey');
+
+      expect(typeof fields.deliveryTag).to.be.eql('number');
+      expect(typeof fields.messageCount).to.be.eql('number');
+      expect(typeof fields.redelivered).to.be.eql('boolean');
+      expect(typeof fields.routingKey).to.be.eql('string');
+
+      return;
+    }
+
+    if (checkQueueStyle === 'purge') {
+      return amqpOperator.checkQueue({queue, style: 'messages', purge: true});
+    }
+
+    if (checkQueueStyle === 'foobar') {
+      return amqpOperator.checkQueue({queue, style: 'foobar', toRecord: false, purge: false});
+    }
+
+    return false;
+  }
+
+  async function ackOrNackMessages() {
+    if (ackMessages) {
+      const message = await amqpOperator.consumeOne(testData.queue, false);
+      await amqpOperator.ackMessages([message]);
+
+      return setTimeoutPromise(10);
+    }
+
+    if (nackMessages) {
+      const message = await amqpOperator.consumeOne(testData.queue, false);
+      await amqpOperator.nackMessages([message]);
+
+      return setTimeoutPromise(10);
+    }
+
+    return;
+  }
+
+  async function sendMessagesToQueue() {
+    if (sentToQueue) {
+      const messages = getFixture('input.json');
+      // {queue, correlationId, headers, data}
+
+      const promises = messages.map(message => amqpOperator.sendToQueue(message));
+      await Promise.all(promises);
+
+      return setTimeoutPromise(10);
+    }
+
+    return;
+  }
+}
+
+/*
+function testHeathCheck() {
+  return it('expects healthCheck', async () => {
+
+    const amqpOperator2 = await amqpFactory(amqpUrl, true);
+    try {
+
+      debug(`**********`);
+      await testHealthCheckLoopWorking(amqpOperator2);
+
+      debug(`**********`);
+      await testHealthCheckLoopErroring(amqpOperator2);
+    } catch (error) {
+      debug(error);
+      expect(error).to.eql('');
+    } finally {
+      amqpOperator2.closeConnection();
+    }
+
+    async function testHealthCheckLoopWorking(amqpOperator) {
+      debug(`Testing healthCheckLoop for ${amqpOperator}`);
+      debug(`Waiting 0.5s and expecting healthCheckLoop to work`);
+      await setTimeoutPromise('500');
+      debug(`Amqp Operator should have been alive.`);
+    }
+
+    async function testHealthCheckLoopErroring(amqpOperator) {
+      debug(`Testing healthCheckLoop with closed channel`);
+      amqpOperator.closeChannel();
+      debug(`Waiting 0.5s and expecting healthCheckLoop to throw error`);
+      await setTimeoutPromise('500');
+      debug(`amqpOperator should have errored`);
+    }
+  });
+}
+*/

package/tests/helpers/conversion.spec.js

@@ -0,0 +1,95 @@
+
+
+import {expect} from 'chai';
+import fixtureFactory from '@natlibfi/fixura';
+import {MarcRecord} from '@natlibfi/marc-record';
+import {Error as ConversionError} from '@natlibfi/melinda-commons';
+import createConversionService from '../../src/helpers/conversion';
+import {CONVERSION_FORMATS} from '../../src/constants';
+
+describe('services/conversion', () => {
+  const {getFixture} = fixtureFactory({root: [
+    __dirname,
+    '..',
+    '..',
+    'test-fixtures',
+    'conversion'
+  ]});
+  const conversionService = createConversionService();
+
+  const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']})), {subfieldValues: false});
+  const marcXml = getFixture({components: ['marcxml1']});
+  const iso2709 = getFixture({components: ['iso2709_1']});
+  const json = getFixture({components: ['json1']});
+  const alephSeq = getFixture({components: ['aleph_sequential']});
+
+
+  describe('factory', () => {
+    it('Should create the expected object', () => {
+      const service = createConversionService();
+      expect(service).to.be.an('object').and
+        .respondTo('serialize')
+        .respondTo('unserialize');
+    });
+  });
+
+  describe('#serialize', () => {
+    it('Should throw because of unsupported format', () => {
+      expect(conversionService.serialize).to.throw();
+    });
+
+    it('Should serialize to MARCXML', () => {
+      const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.MARCXML);
+      expect(data).to.equal(marcXml);
+    });
+
+    it('Should serialize to ISO2709', () => {
+      const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.ISO2709);
+      expect(data).to.equal(iso2709);
+    });
+
+    it('Should serialize to JSON', () => {
+      const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.JSON);
+      expect(data).to.equal(json);
+    });
+
+    it('Should serialize to aleph sequential', () => {
+      const data = conversionService.serialize(marcRecord, CONVERSION_FORMATS.ALEPHSEQ);
+      expect(data).to.equal(alephSeq);
+    });
+
+  });
+
+  describe('#unserialize', () => {
+    it('Should throw because of unsupported format', () => {
+      expect(conversionService.unserialize).to.throw();
+    });
+
+    it('Should unserialize from MARCXML', async () => {
+      const record = await conversionService.unserialize(marcXml, CONVERSION_FORMATS.MARCXML);
+      expect(record.equalsTo(marcRecord)).to.equal(true);
+    });
+
+    it('Should unserialize from ISO2709', () => {
+      const record = conversionService.unserialize(iso2709, CONVERSION_FORMATS.ISO2709);
+      expect(record.equalsTo(marcRecord)).to.equal(true);
+    });
+
+    it('Should unserialize from JSON', () => {
+      const record = conversionService.unserialize(json, CONVERSION_FORMATS.JSON);
+      expect(record.equalsTo(marcRecord)).to.equal(true);
+    });
+
+    it('Should unserialize from Aleph sequential', () => {
+      const record = conversionService.unserialize(alephSeq, CONVERSION_FORMATS.ALEPHSEQ);
+      expect(record.equalsTo(marcRecord)).to.equal(true);
+    });
+
+
+    it('Should throw because the record could not be unserialized', () => {
+      expect(() => {
+        conversionService.unserialize('', CONVERSION_FORMATS.JSON);
+      }).to.throw(ConversionError);
+    });
+  });
+});

package/tests/helpers/fix.spec.js

@@ -0,0 +1,41 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import {fixRecord} from '../../src/helpers/fix';
+import * as fixSettings from '../../src/helpers/fix-constants';
+import createDebugLogger from 'debug';
+// import inspect from 'util';
+
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:fix:test');
+const debugData = debug.extend('data');
+
+generateTests({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'fix'],
+  recurse: true,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: false,
+    reader: READERS.JSON
+  }
+});
+
+function callback({getFixture, settings = undefined}) {
+  if (settings !== undefined && fixSettings[settings] === undefined) {
+    throw new Error(`There are no settings ${settings} defined!`);
+  }
+  const runSettings = fixSettings[settings] || settings;
+
+  const record = new MarcRecord(getFixture('record.json'), {subfieldValues: false});
+  const expectedRecord = getFixture('expectedRecord.json');
+
+  debug(`Running fixer with settings ${settings}.`);
+  debugData(JSON.stringify(runSettings, null, 2));
+
+  const resultRecord = fixRecord(record, runSettings);
+  debugData(`Result:   ${JSON.stringify(resultRecord)}`);
+  debugData(`Expected: ${JSON.stringify(expectedRecord)}`);
+  expect(resultRecord).to.eql(expectedRecord);
+
+}

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