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

package/.github/workflows/melinda-node-tests.yml

@@ -63,7 +63,7 @@ jobs:
       # Setup .npmrc file to publish to npm
       - uses: actions/setup-node@v4
         with:
-          node-version: '18.x'
+          node-version: '22.x'
           registry-url: 'https://registry.npmjs.org'
       - run: npm i
       - run: npm publish

package/dist/index.js

@@ -105,6 +105,5 @@ Object.keys(_constants).forEach(function (key) {
     }
   });
 });
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_mongo","_interopRequireDefault","require","_mongoLog","_amqp","_conversion","_validation","fixes","_interopRequireWildcard","exports","_utils","_constants","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","defineProperty","enumerable","get","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","n","__proto__","a","getOwnPropertyDescriptor","u","i","set"],"sources":["../src/index.js"],"sourcesContent":["\n\nimport mongoFactory from './mongo';\nimport mongoLogFactory from './mongoLog';\nimport amqpFactory from './amqp';\nimport conversions from './helpers/conversion';\nimport validations from './helpers/validation';\nimport * as fixes from './helpers/fix';\nimport {logError, createImportJobState, createImportJobStateForQuery, createRecordResponseItem, addRecordResponseItem, addRecordResponseItems} from './utils';\n\nexport {mongoFactory, mongoLogFactory, amqpFactory, conversions, validations, fixes, logError, createImportJobState, createImportJobStateForQuery, createRecordResponseItem, addRecordResponseItem, addRecordResponseItems};\nexport * from './constants';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,SAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,KAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,WAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,WAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,KAAA,GAAAC,uBAAA,CAAAN,OAAA;AAAuCO,OAAA,CAAAF,KAAA,GAAAA,KAAA;AACvC,IAAAG,MAAA,GAAAR,OAAA;AAGA,IAAAS,UAAA,GAAAT,OAAA;AAAAU,MAAA,CAAAC,IAAA,CAAAF,UAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAN,OAAA,IAAAA,OAAA,CAAAM,GAAA,MAAAJ,UAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAQ,cAAA,CAAAX,OAAA,EAAAM,GAAA;IAAAM,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAX,UAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAA4B,SAAAQ,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAhB,wBAAAgB,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAK,OAAA,EAAAL,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAL,GAAA,CAAAE,CAAA,OAAAO,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAArB,MAAA,CAAAQ,cAAA,IAAAR,MAAA,CAAAsB,wBAAA,WAAAC,CAAA,IAAAX,CAAA,oBAAAW,CAAA,OAAAlB,cAAA,CAAAC,IAAA,CAAAM,CAAA,EAAAW,CAAA,SAAAC,CAAA,GAAAH,CAAA,GAAArB,MAAA,CAAAsB,wBAAA,CAAAV,CAAA,EAAAW,CAAA,UAAAC,CAAA,KAAAA,CAAA,CAAAd,GAAA,IAAAc,CAAA,CAAAC,GAAA,IAAAzB,MAAA,CAAAQ,cAAA,CAAAW,CAAA,EAAAI,CAAA,EAAAC,CAAA,IAAAL,CAAA,CAAAI,CAAA,IAAAX,CAAA,CAAAW,CAAA,YAAAJ,CAAA,CAAAF,OAAA,GAAAL,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAU,GAAA,CAAAb,CAAA,EAAAO,CAAA,GAAAA,CAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_mongo","_interopRequireDefault","require","_mongoLog","_amqp","_conversion","_validation","fixes","_interopRequireWildcard","exports","_utils","_constants","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","defineProperty","enumerable","get","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","set","getOwnPropertyDescriptor"],"sources":["../src/index.js"],"sourcesContent":["\n\nimport mongoFactory from './mongo';\nimport mongoLogFactory from './mongoLog';\nimport amqpFactory from './amqp';\nimport conversions from './helpers/conversion';\nimport validations from './helpers/validation';\nimport * as fixes from './helpers/fix';\nimport {logError, createImportJobState, createImportJobStateForQuery, createRecordResponseItem, addRecordResponseItem, addRecordResponseItems} from './utils';\n\nexport {mongoFactory, mongoLogFactory, amqpFactory, conversions, validations, fixes, logError, createImportJobState, createImportJobStateForQuery, createRecordResponseItem, addRecordResponseItem, addRecordResponseItems};\nexport * from './constants';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,SAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,KAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,WAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,WAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,KAAA,GAAAC,uBAAA,CAAAN,OAAA;AAAuCO,OAAA,CAAAF,KAAA,GAAAA,KAAA;AACvC,IAAAG,MAAA,GAAAR,OAAA;AAGA,IAAAS,UAAA,GAAAT,OAAA;AAAAU,MAAA,CAAAC,IAAA,CAAAF,UAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAN,OAAA,IAAAA,OAAA,CAAAM,GAAA,MAAAJ,UAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAQ,cAAA,CAAAX,OAAA,EAAAM,GAAA;IAAAM,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAX,UAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAA4B,SAAAP,wBAAAe,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAjB,uBAAA,YAAAA,CAAAe,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAP,GAAA,CAAAC,CAAA,GAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAP,cAAA,CAAAC,IAAA,CAAAK,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAjB,MAAA,CAAAQ,cAAA,KAAAR,MAAA,CAAAwB,wBAAA,CAAAb,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAR,GAAA,IAAAQ,CAAA,CAAAK,GAAA,IAAAN,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA","ignoreList":[]}

package/package.json

@@ -14,7 +14,7 @@
     "url": "git@github.com:natlibfi/melinda-rest-api-commons.git"
   },
   "license": "MIT",
-  "version": "4.2.4-alpha.8",
+  "version": "4.2.5-alpha.1",
   "main": "./dist/index.js",
   "engines": {
     "node": ">=18"
@@ -28,44 +28,44 @@
     "lint": "eslint ./src",
     "lint:dev": "eslint ./src --fix",
     "test": "npm run lint && npm run test:base",
-    "test:base": "cross-env NODE_ENV=test nyc mocha --package ./package.json --exclude src/amqp.health.spec.js --exclude src/amqp.tests.spec.js",
-    "test:dev": "npm run lint:dev && cross-env NODE_ENV=test nyc mocha --package ./package.json --exclude src/amqp.health.spec.js --exclude src/amqp.tests.spec.js",
-    "test:local": "cross-env NODE_ENV=test nyc mocha --package ./package.json -- src/amqp.*.spec.js",
-    "test:healthcheck": "cross-env NODE_ENV=test nyc mocha --require @babel/register -- src/amqp.health.spec.js",
+    "test:base": "cross-env NODE_ENV=test nyc mocha --package ./package.json --exclude tests/amqp.health.spec.js --exclude tests/amqp.tests.spec.js",
+    "test:dev": "npm run lint:dev && cross-env NODE_ENV=test nyc mocha --package ./package.json --exclude tests/amqp.health.spec.js --exclude tests/amqp.tests.spec.js",
+    "test:local": "cross-env NODE_ENV=test nyc mocha --package ./package.json -- tests/amqp.*.spec.js",
+    "test:healthcheck": "cross-env NODE_ENV=test nyc mocha --require @babel/register -- tests/amqp.health.spec.js",
     "dev": "nodemon",
     "dev:debug": "cross-env LOG_LEVEL=debug DEBUG=@natlibfi/* NODE_ENV=test nodemon"
   },
   "dependencies": {
-    "@natlibfi/marc-record": "^9.1.3",
-    "@natlibfi/marc-record-serializers": "^10.1.5",
-    "@natlibfi/marc-record-validate": "^8.0.12",
-    "@natlibfi/marc-record-validators-melinda": "^11.5.3",
-    "@natlibfi/melinda-backend-commons": "^2.3.6",
-    "@natlibfi/melinda-commons": "^13.0.19",
-    "amqplib": "^0.10.5",
+    "@natlibfi/marc-record": "^9.1.5",
+    "@natlibfi/marc-record-serializers": "^10.1.6",
+    "@natlibfi/marc-record-validate": "^8.0.14",
+    "@natlibfi/marc-record-validators-melinda": "^11.6.2",
+    "@natlibfi/melinda-backend-commons": "^2.3.8",
+    "@natlibfi/melinda-commons": "^13.0.20",
+    "amqplib": "^0.10.8",
     "debug": "^4.4.0",
     "http-status": "^2.1.0",
     "moment": "^2.30.1",
     "mongo-sanitize": "^1.1.0",
-    "mongodb": "^6.12.0"
+    "mongodb": "^6.16.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.26.4",
-    "@babel/core": "^7.26.7",
-    "@babel/plugin-transform-runtime": "^7.25.9",
-    "@babel/preset-env": "^7.26.7",
-    "@babel/register": "^7.25.9",
+    "@babel/cli": "^7.27.1",
+    "@babel/core": "^7.27.1",
+    "@babel/plugin-transform-runtime": "^7.27.1",
+    "@babel/preset-env": "^7.27.1",
+    "@babel/register": "^7.27.1",
     "@natlibfi/eslint-config-melinda-backend": "^3.0.5",
-    "@natlibfi/fixugen": "^2.0.12",
-    "@natlibfi/fixura": "^3.0.11",
-    "@natlibfi/fixura-mongo": "^2.0.21",
+    "@natlibfi/fixugen": "^2.0.14",
+    "@natlibfi/fixura": "^3.0.13",
+    "@natlibfi/fixura-mongo": "^2.0.24",
     "babel-plugin-istanbul": "^7.0.0",
     "babel-plugin-rewire": "^1.2.0",
     "chai": "^4.5.0",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.1",
-    "mocha": "^11.1.0",
-    "nodemon": "^3.1.9",
+    "mocha": "^11.2.2",
+    "nodemon": "^3.1.10",
     "nyc": "^17.1.0"
   },
   "overrides": {
@@ -99,8 +99,8 @@
   },
   "mocha": {
     "spec": [
-      "src/*.spec.js",
-      "src/**/*.spec.js"
+      "tests/*.spec.js",
+      "tests/**/*.spec.js"
     ],
     "require": [
       "@babel/register"
@@ -114,14 +114,15 @@
   "nodemonConfig": {
     "exec": "npm run test:dev",
     "watch": [
+      "tests/*",
       "src/*",
       "test-fixtures/*"
     ]
   },
   "nyc": {
     "exclude": [
-      "src/*.spec.js",
-      "src/**/*.spec.js"
+      "tests/*.spec.js",
+      "tests/**/*.spec.js"
     ],
     "reporter": [
       "text"

package/{dist → tests}/amqp.health.spec.js

@@ -1,41 +1,48 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _debug = _interopRequireDefault(require("debug"));
-var _index = require("./index");
-var _util = require("util");
 //import {expect} from 'chai';
+import createDebugLogger from 'debug';
+import {amqpFactory} from '../src/index';
+
 
-const debug = (0, _debug.default)('@natlibfi/melinda-rest-api-commons:amqp:test');
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
 //const debugData = debug.extend('data');
 
-const setTimeoutPromise = (0, _util.promisify)(setTimeout);
+import {promisify} from 'util';
+const setTimeoutPromise = promisify(setTimeout);
+
 describe('HealthCheck: amqpOperator should error if channel or connection fails', () => {
+
   it('FIX: test healthCheck - this test does not really test anything, but error can be seen in debug!', async () => {
     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/';
-    const amqpOperator = await (0, _index.amqpFactory)(amqpUrl, true);
+
+    const amqpOperator = await amqpFactory(amqpUrl, true);
     debug(`Connecting to ${amqpUrl}, with healthCheck running`);
     await awaitTime(amqpOperator, false);
+
     debug(`Testing healthCheckLoop for ${amqpOperator}`);
     debug(`Waiting 0.5s and expecting healthCheckLoop to work`);
     await awaitTime(amqpOperator, false);
     debug(`Amqp Operator should have been alive.`);
+
     debug(`Testing healthCheckLoop with closed channel`);
     debug(`Waiting 0.5s and expecting healthCheckLoop to throw error`);
     await awaitTime(amqpOperator, true);
     debug(`Amqp Operator should have been errored.`);
+
     debug(`Closing connection`);
     await amqpOperator.closeConnection();
+
     async function awaitTime(amqpOperator, close) {
       if (close) {
         await amqpOperator.closeChannel();
         await setTimeoutPromise(500);
         return;
       }
+
       await setTimeoutPromise(500);
       return;
     }
+
   });
 });
-//# sourceMappingURL=amqp.health.spec.js.map
+

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