@natlibfi/melinda-rest-api-commons 6.1.0-alpha.0 → 6.2.0-alpha.0

package/{tests/amqp-error-branches.test.js → test/amqp-error-branches.test.ts}

@@ -3,24 +3,47 @@ import {test} from 'node:test';
 import {execFile} from 'node:child_process';
 import {fileURLToPath} from 'node:url';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import createAmqp from '../src/amqp.js';
+import type {Message} from 'amqplib';
+import createAmqp, {type QueueItemMessagePayload, type QueueItemRecordPayload} from '../src/amqp.ts';
 
-const AMQP_MODULE_PATH = fileURLToPath(new URL('../src/amqp.js', import.meta.url));
+const AMQP_MODULE_PATH = fileURLToPath(new URL('../src/amqp.ts', import.meta.url));
 
 const DUMMY_URL = 'amqp://stub:5672/';
 const QUEUE = 'TESTQUEUE';
 
-function makeMessage(correlationId, deliveryTag) {
+/**
+ * A minimal stub for an amqplib message. The fields beyond deliveryTag
+ * match the shape of a real amqplib message (the tests only exercise
+ * deliveryTag, correlationId and the message body).
+ */
+function makeMessage(correlationId: string, deliveryTag: number): Message {
   const data = {leader: '00000nam a22000000i 4500', fields: [{tag: '001', value: '123'}]};
   const content = JSON.stringify({data});
   return {
     content: Buffer.from(content),
-    properties: {correlationId, headers: {from: 'TEST'}},
-    fields: {deliveryTag}
+    // only correlationId and headers are exercised by these tests; the
+    // remaining message properties stay undefined
+    properties: {
+      contentType: undefined,
+      contentEncoding: undefined,
+      headers: {from: 'TEST'},
+      deliveryMode: undefined,
+      priority: undefined,
+      correlationId,
+      replyTo: undefined,
+      expiration: undefined,
+      messageId: undefined,
+      timestamp: undefined,
+      type: undefined,
+      userId: undefined,
+      appId: undefined,
+      clusterId: undefined
+    },
+    fields: {deliveryTag, redelivered: false, exchange: '', routingKey: ''}
   };
 }
 
-function makeChannel(overrides = {}) {
+function makeChannel(overrides: Record<string, unknown> = {}) {
   return {
     assertQueue: async () => ({messageCount: 0}),
     checkQueue: async () => ({messageCount: 0}),
@@ -34,14 +57,17 @@ function makeChannel(overrides = {}) {
   };
 }
 
-async function makeOperator(channelOverrides) {
+/**
+ * Create an operator with the given channel stub overrides injected via deps
+ */
+async function makeOperator(channelOverrides?: Record<string, unknown>) {
   const channel = makeChannel(channelOverrides);
   const connection = {createChannel: async () => channel, close: async () => {}};
   return createAmqp(DUMMY_URL, false, {connection, channel});
 }
 
 test('consumeChunk returns false when queue drains mid-pump', async () => {
-  // (src/amqp.js, getData/pump):
+  // (src/amqp.ts, getData/pump):
   // FIXED: pump now bails out (returns results) when channel.get -> null,
   // and consumeChunk maps an empty pump result to false, matching the
   // empty-queue contract of checkQueue. Previously this crashed with
@@ -67,14 +93,14 @@ test('consumeChunk returns partial chunk when queue drains after first message',
       return first;
     }
   });
-  const {records, messages} = await amqpOperator.consumeChunk(QUEUE, true);
+  const {records, messages} = (await amqpOperator.consumeChunk(QUEUE, true)) as QueueItemRecordPayload;
   assert.equal(messages.length, 1);
   assert.equal(records.length, 1);
 });
 
 
 test('consumeChunk deduplicates messages with same correlationId + deliveryTag', async () => {
-  // (src/amqp.js, getData/pump):
+  // (src/amqp.ts, getData/pump):
   // FIXED: dedup now compares correlationId + deliveryTag field-by-field,
   // so duplicate messages are filtered out. (Previously the includes()
   // check compared object references and never triggered.)
@@ -83,7 +109,7 @@ test('consumeChunk deduplicates messages with same correlationId + deliveryTag',
     checkQueue: async () => ({messageCount: 2}),
     get: async () => duplicate
   });
-  const {records, messages} = await amqpOperator.consumeChunk(QUEUE, true);
+  const {records, messages} = (await amqpOperator.consumeChunk(QUEUE, true)) as QueueItemRecordPayload;
   assert.equal(messages.length, 1);
   assert.equal(records.length, 1);
 });
@@ -96,21 +122,20 @@ test('same deliveryTag with different correlationIds is NOT deduplicated', async
     checkQueue: async () => ({messageCount: 2}),
     get: async () => messages.shift()
   });
-  const {messages: got} = await amqpOperator.consumeChunk(QUEUE, true);
+  const {messages: got} = (await amqpOperator.consumeChunk(QUEUE, true)) as QueueItemRecordPayload;
   assert.equal(got.length, 2);
 });
 
 test('removeQueue closes the temp channel even when deleteQueue throws', async () => {
-  // (src/amqp.js, removeQueue):
+  // (src/amqp.ts, removeQueue):
   // FIXED: the throwaway tempChannel is now closed in a finally block, so a
   // missing queue (deleteQueue throws) no longer leaks a channel.
-  const closedChannels = [];
+  const closedChannels: any[] = [];
   const tempChannel = {
     deleteQueue: async () => {
       throw new Error('NOT_FOUND - queue missing');
     },
     close: async () => {
-      // eslint-disable-next-line functional/immutable-data
       closedChannels.push('temp');
     }
   };
@@ -123,13 +148,12 @@ test('removeQueue closes the temp channel even when deleteQueue throws', async (
 });
 
 test('removeQueue closes the temp channel on success too', async () => {
-  const closedChannels = [];
+  const closedChannels: any[] = [];
   const amqpOperator = await createAmqp(DUMMY_URL, false, {
     connection: {
       createChannel: async () => ({
         deleteQueue: async () => {},
         close: async () => {
-          // eslint-disable-next-line functional/immutable-data
           closedChannels.push('temp');
         }
       }),
@@ -142,7 +166,7 @@ test('removeQueue closes the temp channel on success too', async () => {
 });
 
 test('healthCheck loop stops after closeChannel and does not keep firing or throw', async () => {
-  // (src/amqp.js, healthCheck):
+  // (src/amqp.ts, healthCheck):
   // FIXED: closeChannel/closeConnection cancel the recursive healthCheck loop,
   // so the ~200 ms chain short-circuits instead of running until the closed
   // channel throws (which used to make graceful shutdown flaky).
@@ -151,9 +175,8 @@ test('healthCheck loop stops after closeChannel and does not keep firing or thro
   let closed = false;
   let healthCheckCalls = 0;
   const channel = {
-    assertQueue: async (name) => {
+    assertQueue: async (name: string) => {
       if (name === 'HEALTHCHECK') {
-        // eslint-disable-next-line functional/immutable-data
         healthCheckCalls += 1;
         if (closed) {
           throw new Error('channel closed');
@@ -167,7 +190,6 @@ test('healthCheck loop stops after closeChannel and does not keep firing or thro
     nack: () => {},
     purgeQueue: async () => {},
     close: async () => {
-      // eslint-disable-next-line functional/immutable-data
       closed = true;
     }
   };
@@ -194,7 +216,7 @@ test('happy path: consumeChunk returns two distinct messages', async () => {
     checkQueue: async () => ({messageCount: messages.length}),
     get: async () => messages.shift()
   });
-  const {headers, records, messages: got} = await amqpOperator.consumeChunk(QUEUE, true);
+  const {headers, records, messages: got} = (await amqpOperator.consumeChunk(QUEUE, true)) as QueueItemRecordPayload;
   assert.equal(got.length, 2);
   assert.equal(records.length, 2);
   assert.deepStrictEqual(headers, {from: 'TEST'});
@@ -218,7 +240,7 @@ test('checkQueue style one returns the {headers, records, messages} form when to
     assertQueue: async () => ({messageCount: 1}),
     get: async () => message
   });
-  const {headers, records, messages} = await amqpOperator.checkQueue({queue: QUEUE, style: 'one', toRecord: true});
+  const {headers, records, messages} = (await amqpOperator.checkQueue({queue: QUEUE, style: 'one', toRecord: true})) as QueueItemRecordPayload;
   assert.deepStrictEqual(headers, {from: 'TEST'});
   assert.equal(records.length, 1);
   assert.strictEqual(messages.length, 1);
@@ -257,7 +279,7 @@ test('checkQueue style basic returns a chunk of records and messages when the qu
     checkQueue: async () => ({messageCount: messages.length}),
     get: async () => messages.shift()
   });
-  const {headers, records, messages: got} = await amqpOperator.checkQueue({queue: QUEUE, style: 'basic', toRecord: true});
+  const {headers, records, messages: got} = (await amqpOperator.checkQueue({queue: QUEUE, style: 'basic', toRecord: true})) as QueueItemRecordPayload;
   assert.deepStrictEqual(headers, {from: 'TEST'});
   assert.equal(records.length, 2);
   assert.equal(got.length, 2);
@@ -276,17 +298,15 @@ test('checkQueue rejects with a 500 ApiError for an unknown style', async () =>
 });
 
 test('checkQueue purges the queue before returning the style result', async () => {
-  const purgeCalls = [];
+  const purgeCalls: any[] = [];
   let assertCalls = 0;
   const amqpOperator = await makeOperator({
     assertQueue: async () => {
-      // eslint-disable-next-line functional/immutable-data
       assertCalls += 1;
       // first call (before the purge) reports 3 pending, after the purge 0
       return assertCalls === 1 ? {messageCount: 3} : {messageCount: 0};
     },
-    purgeQueue: async (name) => {
-      // eslint-disable-next-line functional/immutable-data
+    purgeQueue: async (name: string) => {
       purgeCalls.push(name);
     }
   });
@@ -309,7 +329,7 @@ test('consumeOne returns the plain message when toRecord is false', async () =>
 test('consumeOne returns the {headers, records, messages} form when toRecord is true', async () => {
   const message = makeMessage('c1', 1);
   const amqpOperator = await makeOperator({get: async () => message});
-  const {headers, records, messages} = await amqpOperator.consumeOne(QUEUE, true);
+  const {headers, records, messages} = (await amqpOperator.consumeOne(QUEUE, true)) as QueueItemRecordPayload;
   assert.deepStrictEqual(headers, {from: 'TEST'});
   assert.equal(records.length, 1);
   assert.strictEqual(messages.length, 1);
@@ -341,7 +361,7 @@ test('consumeChunk returns {headers, messages} without records when toRecord is
     checkQueue: async () => ({messageCount: messages.length}),
     get: async () => messages.shift()
   });
-  const {headers, messages: got} = await amqpOperator.consumeChunk(QUEUE, false);
+  const {headers, messages: got} = (await amqpOperator.consumeChunk(QUEUE, false)) as QueueItemMessagePayload;
   assert.deepStrictEqual(headers, {from: 'TEST'});
   assert.equal(got.length, 2);
 });
@@ -360,11 +380,10 @@ test('consumeChunk rejects when the amqplib checkQueue throws a plain Error', as
 // ---------------------------------------------------------------------------
 
 test('ackMessages acks every message on the channel', async () => {
-  const acked = [];
+  const acked: Message[] = [];
   const messages = [makeMessage('c1', 1), makeMessage('c2', 2)];
   const amqpOperator = await makeOperator({
-    ack: (message) => {
-      // eslint-disable-next-line functional/immutable-data
+    ack: (message: Message) => {
       acked.push(message);
     }
   });
@@ -373,11 +392,10 @@ test('ackMessages acks every message on the channel', async () => {
 });
 
 test('nackMessages nacks every message on the channel', async () => {
-  const nacked = [];
+  const nacked: Message[] = [];
   const messages = [makeMessage('c1', 1), makeMessage('c2', 2)];
   const amqpOperator = await makeOperator({
-    nack: (message) => {
-      // eslint-disable-next-line functional/immutable-data
+    nack: (message: Message) => {
       nacked.push(message);
     }
   });
@@ -390,10 +408,9 @@ test('nackMessages nacks every message on the channel', async () => {
 // ---------------------------------------------------------------------------
 
 test('sendToQueue sends the JSON body with correlationId, persistent and headers options', async () => {
-  const sent = [];
+  const sent: {queue: string, content: Buffer, options: Record<string, unknown>}[] = [];
   const amqpOperator = await makeOperator({
-    sendToQueue: async (queue, content, options) => {
-      // eslint-disable-next-line functional/immutable-data
+    sendToQueue: async (queue: string, content: Buffer, options: Record<string, unknown>) => {
       sent.push({queue, content, options});
     }
   });
@@ -405,10 +422,10 @@ test('sendToQueue sends the JSON body with correlationId, persistent and headers
     data
   });
   assert.equal(sent.length, 1);
-  assert.equal(sent[0].queue, QUEUE);
-  assert.ok(Buffer.isBuffer(sent[0].content));
-  assert.deepStrictEqual(JSON.parse(sent[0].content.toString()), {data});
-  assert.deepStrictEqual(sent[0].options, {correlationId: 'cid-1', persistent: true, headers: {h: 1}});
+  assert.equal(sent[0]?.queue, QUEUE);
+  assert.ok(sent[0] && Buffer.isBuffer(sent[0].content));
+  assert.deepStrictEqual(JSON.parse(sent[0]?.content.toString() ?? ''), {data});
+  assert.deepStrictEqual(sent[0]?.options, {correlationId: 'cid-1', persistent: true, headers: {h: 1}});
 });
 
 test('sendToQueue rejects with a 500 ApiError when the queue is undefined', async () => {
@@ -442,13 +459,12 @@ test('checkQueue rejects with a 500 ApiError when the queue is an empty string',
 // ---------------------------------------------------------------------------
 
 test('closeConnection closes the connection and the operator resolves', async () => {
-  const closed = [];
+  const closed: any[] = [];
   const channel = makeChannel();
   const amqpOperator = await createAmqp(DUMMY_URL, false, {
     connection: {
       createChannel: async () => channel,
       close: async () => {
-        // eslint-disable-next-line functional/immutable-data
         closed.push('connection');
       }
     },
@@ -459,16 +475,14 @@ test('closeConnection closes the connection and the operator resolves', async ()
 });
 
 test('healthCheck error arriving after cancel does not rethrow and stops the loop', async () => {
-  let rejectAssert;
+  let rejectAssert: ((reason?: unknown) => void) | undefined;
   const pending = new Promise((_, reject) => {
-    // eslint-disable-next-line functional/immutable-data
     rejectAssert = reject;
   });
   let healthCheckCalls = 0;
   const channel = makeChannel({
-    assertQueue: async (name) => {
+    assertQueue: async (name: string) => {
       if (name === 'HEALTHCHECK') {
-        // eslint-disable-next-line functional/immutable-data
         healthCheckCalls += 1;
         return pending;
       }
@@ -482,7 +496,9 @@ test('healthCheck error arriving after cancel does not rethrow and stops the loo
   // by now the loop is suspended on the pending assertQueue call;
   // cancel first, then let the error arrive so the catch sees the flag already cleared
   await amqpOperator.closeChannel();
-  rejectAssert(new Error('amqp down after close'));
+  if (rejectAssert) {
+    rejectAssert(new Error('amqp down after close'));
+  }
   await new Promise((resolve) => setTimeout(resolve, 50));
   assert.equal(healthCheckCalls, 1, 'no further health checks after cancel');
 });
@@ -497,7 +513,7 @@ test('healthCheck error while running rethrows into the un-awaited loop promise'
   const script = `
     import createAmqp from '${AMQP_MODULE_PATH}';
     const channel = {
-      assertQueue: async (name) => {
+      assertQueue: /** @param {*} name */ async (name) => {
         if (name === 'HEALTHCHECK') {
           throw new Error('amqp down');
         }
@@ -523,7 +539,7 @@ test('healthCheck error while running rethrows into the un-awaited loop promise'
     process.stdout.write(ok ? 'OK' : 'FAIL:' + JSON.stringify(captured.map((e) => String(e && e.message))));
     process.exit(ok ? 0 : 1);
   `;
-  const {code, stdout} = await new Promise((resolve) => {
+  const {code, stdout} = await new Promise<{code: number | string, stdout: string}>((resolve) => {
     const child = execFile(process.execPath, ['--input-type=module', '-e', script], (err, out) => {
       resolve({code: err ? (err.code ?? 1) : 0, stdout: out ?? ''});
     });

package/{tests/amqp.healthtest.js → test/amqp.healthtest.ts}

@@ -1,7 +1,8 @@
 import {describe, it} from 'node:test';
 import assert from 'node:assert';
 import createDebugLogger from 'debug';
-import {amqpFactory} from '../src/index.js';
+import {amqpFactory} from '../src/index.ts';
+import type {AmqpOperator} from '../src/amqp.ts';
 
 
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
@@ -35,7 +36,11 @@ describe('HealthCheck: amqpOperator should error if channel or connection fails'
     debug(`Closing connection`);
     await amqpOperator.closeConnection();
 
-    async function awaitTime(amqpOperator, close) {
+    /**
+     * @param amqpOperator
+     * @param close
+     */
+    async function awaitTime(amqpOperator: AmqpOperator, close: boolean): Promise<void> {
       if (close) {
         // wrap the wait so any error thrown by the (cancelled) loop fails the test
         await amqpOperator.closeChannel();
@@ -53,4 +58,3 @@ describe('HealthCheck: amqpOperator should error if channel or connection fails'
 
   });
 });
-

package/{tests/amqp.tests.localtest.js → test/amqp.tests.localtest.ts}

@@ -3,8 +3,11 @@ import createDebugLogger from 'debug';
 import {promisify} from 'util';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
+import type {CallbackArgs} from '@natlibfi/fixugen';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import {amqpFactory} from '../src/index.js';
+import type {GetMessage, Message} from 'amqplib';
+import {amqpFactory} from '../src/index.ts';
+import type {AmqpOperator, QueueItemMessagePayload, QueueItemRecordPayload, SendToQueueParams} from '../src/amqp.ts';
 
 const setTimeoutPromise = promisify(setTimeout);
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
@@ -18,8 +21,7 @@ const testData = {
 
 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;
+let amqpOperator: AmqpOperator;
 
 generateTests({
   callback,
@@ -48,8 +50,15 @@ generateTests({
   }
 });
 
-// eslint-disable-next-line max-statements
-async function callback({
+/**
+ * One fixture case. See the fixture metadata files in test-fixtures/amqp
+ * for the possible keys (getFixture, expectToFail, expectedErrorStatus,
+ * ackMessages, nackMessages, checkNextMessage, checkQueueStyle, queue,
+ * sentToQueue, expectedMessageCount, removeQueue, expectedErrorMessage,
+ * expectApiError, expectFalseCheckResult).
+ */
+async function callback(callbackParams: CallbackArgs) {
+  const {
   getFixture,
   expectToFail = false,
   expectedErrorStatus = '',
@@ -57,14 +66,16 @@ async function callback({
   nackMessages = false,
   checkNextMessage = false,
   checkQueueStyle = false,
-  queue = testData.queue,
+  queue: queueFromFixture = testData.queue,
   sentToQueue,
   expectedMessageCount,
   removeQueue = false,
   expectedErrorMessage = undefined,
   expectApiError = false,
   expectFalseCheckResult = false
-}) {
+  } = callbackParams;
+  // the fixture contract passes the queue name as a string
+  const queue = queueFromFixture as string;
   try {
     await sendMessagesToQueue();
 
@@ -79,7 +90,7 @@ async function callback({
     assert.equal(messageCount, expectedMessageCount);
 
     if (checkNextMessage) {
-      const {headers, records} = await queueCheckNextMessage();
+      const {headers, records} = (await queueCheckNextMessage()) as QueueItemRecordPayload;
       const nextMessage = {headers, records};
       const expectedNextMessage = getFixture('expectedMessage.json');
       assert.deepStrictEqual(
@@ -97,15 +108,19 @@ async function callback({
     testErrors(error);
   }
 
-  function testErrors(error) {
+  /**
+   * @param error
+   */
+  function testErrors(error: unknown) {
     const isApiError = error instanceof ApiError;
     if (expectApiError) {
       assert.equal(isApiError, true);
       debug(`We expected and got an ApiError`);
-      assert.equal(error.status, expectedErrorStatus);
+      const apiError = error as ApiError;
+      assert.equal(apiError.status, expectedErrorStatus);
 
       if (expectedErrorMessage) {
-        assert.equal(error.payload, expectedErrorMessage);
+        assert.equal(apiError.payload, expectedErrorMessage);
         return;
       }
 
@@ -113,26 +128,26 @@ async function callback({
     }
     assert.equal(isApiError, false);
     debug(`We expected and got an non-ApiError`);
-    debug(`Error is a ${error.constructor.name}`);
+    const maybeError = error as Error;
+    debug(`Error is a ${maybeError.constructor.name}`);
   }
 
   function queueRemoval() {
     if (removeQueue) {
-      return amqpOperator.removeQueue(removeQueue);
+      return amqpOperator.removeQueue(removeQueue as string);
     }
 
     return;
   }
 
-  function queueCheckNextMessage() {
+  function queueCheckNextMessage(): Promise<QueueItemRecordPayload> | false {
     if (checkNextMessage) {
-      return amqpOperator.consumeOne(testData.queue, true);
+      return amqpOperator.consumeOne(testData.queue, true) as Promise<QueueItemRecordPayload>;
     }
 
     return false;
   }
 
-  // eslint-disable-next-line max-statements
   async function checkQueue() {
     debug(`checkQueueStyle: ${checkQueueStyle}`);
 
@@ -144,18 +159,19 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 1);
-      assert.equal(result.messages.length, 1);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 1);
+      assert.equal(recordResult.messages.length, 1);
 
       return;
     }
 
     if (checkQueueStyle === 'oneNotRecord') {
       const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: false, purge: false});
-      const {fields} = result;
+      const {fields} = result as GetMessage;
 
       if (expectFalseCheckResult) {
         assert.strictEqual(result, false);
@@ -178,14 +194,15 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 3);
-      assert.equal(result.messages.length, 3);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 3);
+      assert.equal(recordResult.messages.length, 3);
       const expectedResult = getFixture('expectedResult.json');
       assert.deepStrictEqual(
-        JSON.parse(JSON.stringify(result.records)),
+        JSON.parse(JSON.stringify(recordResult.records)),
         expectedResult,
       );
 
@@ -200,11 +217,13 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.messages.length, 3);
+      const messageResult = result as QueueItemMessagePayload;
+      assert.equal(Object.hasOwn(messageResult, 'headers'), true);
+      assert.equal(Object.hasOwn(messageResult, 'messages'), true);
+      assert.equal(messageResult.messages.length, 3);
 
-      const [{fields}] = result.messages;
+      const [firstMessage] = messageResult.messages as [Message, ...Message[]];
+      const {fields} = firstMessage;
 
       assert.equal(typeof fields.deliveryTag, 'number');
       assert.equal(typeof fields.messageCount, 'number');
@@ -228,14 +247,14 @@ async function callback({
   async function ackOrNackMessages() {
     if (ackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.ackMessages([message]);
+      await amqpOperator.ackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
 
     if (nackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.nackMessages([message]);
+      await amqpOperator.nackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
@@ -245,7 +264,7 @@ async function callback({
 
   async function sendMessagesToQueue() {
     if (sentToQueue) {
-      const messages = getFixture('input.json');
+      const messages = getFixture('input.json') as SendToQueueParams[];
       // {queue, correlationId, headers, data}
 
       const promises = messages.map(message => amqpOperator.sendToQueue(message));