@defra-fish/sqs-receiver-service 1.61.0-rc.9 → 1.62.0-rc.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@defra-fish/sqs-receiver-service",
-  "version": "1.61.0-rc.9",
+  "version": "1.62.0-rc.0",
   "description": "SQS Receiver service",
   "type": "module",
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20"
   },
   "keywords": [
     "rod",
@@ -35,7 +35,7 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/connectors-lib": "1.61.0-rc.9",
+    "@defra-fish/connectors-lib": "1.62.0-rc.0",
     "debug": "^4.3.1",
     "joi": "^17.3.0",
     "node-fetch": "^2.6.1",
@@ -44,5 +44,5 @@
   "devDependencies": {
     "pm2": "^4.5.6"
   },
-  "gitHead": "b9c65c7827bb974c94056bf5e387d80564d3ddc6"
+  "gitHead": "d56e1a0d0f4b22f1dded800c0ed511b737cb91a7"
 }

package/src/__tests__/delete-messages.spec.js

@@ -1,9 +1,33 @@
 'use strict'
 
 import deleteMessages from '../delete-messages'
-import AWS from 'aws-sdk'
+import { AWS } from '@defra-fish/connectors-lib'
+const { sqs } = AWS.mock.results[0].value
+
+const getSampleDeleteMessageBatchResponse = (successfulIds, failedIds = []) => ({
+  ResponseMetadata: {
+    RequestId: '00000000-0000-0000-0000-000000000000'
+  },
+  Successful: successfulIds.map(Id => ({ Id })),
+  Failed: failedIds.map(Id => ({ Id }))
+})
+
+jest.mock('@defra-fish/connectors-lib', () => ({
+  AWS: jest.fn(() => ({
+    sqs: {
+      deleteMessageBatch: jest.fn(() => {})
+    }
+  }))
+}))
+
+beforeEach(() => {
+  sqs.deleteMessageBatch.mockClear()
+})
 
 test('Delete messages successfully', async () => {
+  sqs.deleteMessageBatch.mockResolvedValueOnce(
+    getSampleDeleteMessageBatchResponse(['58f6f3c9-97f8-405a-a3a7-5ac467277521', '58f6f3c9-97f8-405a-a3a7-5ac467277522'])
+  )
   const results = await deleteMessages('http://0.0.0.0:0000/queue', [
     {
       id: '58f6f3c9-97f8-405a-a3a7-5ac467277521',
@@ -26,6 +50,7 @@ test('Delete messages successfully', async () => {
 })
 
 test('Delete messages nothing to delete', async () => {
+  sqs.deleteMessageBatch.mockResolvedValueOnce(getSampleDeleteMessageBatchResponse([]))
   const results = await deleteMessages('http://0.0.0.0:0000/queue', [
     {
       id: '58f6f3c9-97f8-405a-a3a7-5ac467277521',
@@ -45,11 +70,14 @@ test('Delete messages nothing to delete', async () => {
   ])
 
   expect(results).toBeUndefined()
+  sqs.deleteMessageBatch.mockReset()
 })
 
 test('Delete messages with failures', async () => {
   const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
-  AWS.__mockDeleteMessageFailures()
+  sqs.deleteMessageBatch.mockResolvedValueOnce(
+    getSampleDeleteMessageBatchResponse([], ['58f6f3c9-97f8-405a-a3a7-5ac467277521', '58f6f3c9-97f8-405a-a3a7-5ac467277522'])
+  )
   const results = await deleteMessages('http://0.0.0.0:0000/queue', [
     {
       id: '58f6f3c9-97f8-405a-a3a7-5ac467277521',
@@ -73,7 +101,9 @@ test('Delete messages with failures', async () => {
 })
 
 test('Delete message does not throw exception', async () => {
-  AWS.__mockNotFound()
+  const exception = new Error('Not Found')
+  exception.code = 404
+  sqs.deleteMessageBatch.mockRejectedValueOnce(exception)
 
   const result = await deleteMessages('http://0.0.0.0:0000/queue', [
     {
@@ -84,3 +114,20 @@ test('Delete message does not throw exception', async () => {
   ])
   expect(result).toBeUndefined()
 })
+
+test('Delete message batch logs exception with console.error', async () => {
+  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
+  const exception = new Error('Not Found')
+  exception.code = 404
+  const url = 'http://0.0.0.0:0000/queue'
+  sqs.deleteMessageBatch.mockRejectedValueOnce(exception)
+
+  await deleteMessages(url, [
+    {
+      id: '58f6f3c9-97f8-405a-a3a7-5ac467277521',
+      handle: '58f6f3c9-97f8-405a-a3a7-5ac467277521#03f003bc-7770-41c2-9217-aed966b578b1',
+      status: 200
+    }
+  ])
+  expect(consoleError).toHaveBeenCalledWith('Error deleting messages for %s: %o', url, exception)
+})

package/src/__tests__/read-queue.spec.js

@@ -1,19 +1,73 @@
 'use strict'
 
 import readQueue from '../read-queue'
-import AWS from 'aws-sdk'
+import { AWS } from '@defra-fish/connectors-lib'
+const { sqs } = AWS.mock.results[0].value
+
+jest.mock('@defra-fish/connectors-lib', () => ({
+  AWS: jest.fn(() => ({
+    sqs: {
+      receiveMessage: jest.fn(() => ({ Messages: [] }))
+    }
+  }))
+}))
+
+const getSampleError = (httpStatusCode = undefined) => {
+  const error = new Error('Queue error')
+  if (httpStatusCode) {
+    error.$metadata = { httpStatusCode }
+  }
+  return error
+}
+
+beforeEach(() => {
+  sqs.receiveMessage.mockClear()
+})
 
 test('Nothing queued', async () => {
-  AWS.__mockEmptyQueue()
   const messages = await readQueue('http://0.0.0.0:0000/queue')
   expect(messages).toHaveLength(0)
 })
 
+test.each`
+  queueUrl                         | visibilityTimeoutMs | waitTimeMs | expectedVTS | expectedWTS
+  ${'http://0.0.0.0:0000/queue'}   | ${1000}             | ${2000}    | ${1}        | ${2}
+  ${'http://1.2.3.4:5432/line'}    | ${3000}             | ${4000}    | ${3}        | ${4}
+  ${'http://9.8.7.6:1234/joinThe'} | ${7000}             | ${20000}   | ${7}        | ${20}
+`(
+  'Specifies message configuration: queue url $queueUrl read with visibility timeout $expectedVTS seconds and a wait time of $expectedWTS seconds',
+  async ({ queueUrl, visibilityTimeoutMs, waitTimeMs, expectedVTS, expectedWTS }) => {
+    await readQueue(queueUrl, visibilityTimeoutMs, waitTimeMs)
+    expect(sqs.receiveMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        QueueUrl: queueUrl,
+        MaxNumberOfMessages: 10,
+        MessageAttributeNames: ['/*'],
+        AttributeNames: ['MessageGroupId'],
+        VisibilityTimeout: expectedVTS,
+        WaitTimeSeconds: expectedWTS
+      })
+    )
+  }
+)
+
 test('One message queued', async () => {
-  AWS.__mockOneMessage()
+  sqs.receiveMessage.mockResolvedValueOnce({
+    Messages: [
+      {
+        MessageId: '15eb8abc-c7c1-4167-9590-839c8feed6dd',
+        ReceiptHandle: '15eb8abc-c7c1-4167-9590-839c8feed6dd#9be8971c-f9a9-4bb2-8515-98cdab660e1b',
+        MD5OfBody: '640ad880b5be372fcb5c5ad8b5eb50af',
+        Body: '{"id":"7f6e04fe-4cec-4f40-b763-8c66d71062d9"}',
+        Attributes: {
+          MessageGroupId: 'service-1'
+        }
+      }
+    ]
+  })
   const messages = await readQueue('http://0.0.0.0:0000/queue')
   expect(messages).toHaveLength(1)
-  expect(messages).toContainEqual({
+  expect(messages[0]).toMatchObject({
     MessageId: '15eb8abc-c7c1-4167-9590-839c8feed6dd',
     ReceiptHandle: '15eb8abc-c7c1-4167-9590-839c8feed6dd#9be8971c-f9a9-4bb2-8515-98cdab660e1b',
     MD5OfBody: '640ad880b5be372fcb5c5ad8b5eb50af',
@@ -25,29 +79,50 @@ test('One message queued', async () => {
 })
 
 test('Five messages queued', async () => {
-  AWS.__mockNMessages(5)
-  const messages = await readQueue('http://0.0.0.0:0000/queue')
-  expect(messages).toHaveLength(5)
+  const messages = Array(5)
+    .fill(null)
+    .map((_, i) => ({
+      MessageId: `msg-${i}`,
+      ReceiptHandle: `handle-${i}`,
+      MD5OfBody: 'hash',
+      Body: '{}',
+      Attributes: { MessageGroupId: 'service-1' }
+    }))
+  sqs.receiveMessage.mockResolvedValueOnce({ Messages: messages })
+  const result = await readQueue('http://0.0.0.0:0000/queue')
+  expect(result).toHaveLength(5)
 })
 
-test('Throws exception on no queue available', async () => {
+test.each([
+  ['when error contains http status code', 500],
+  ["when error doesn't contain http status code", undefined]
+])('Writes error to console %s', async (_d, httpStatusCode) => {
   const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
-  AWS.__mockFailNoQueue()
-  async function check () {
-    try {
-      return readQueue('http://0.0.0.0:0000/queue')
-    } catch (error) {
-      throw new Error()
-    }
+  const e = getSampleError(httpStatusCode)
+  sqs.receiveMessage.mockRejectedValueOnce(e)
+  try {
+    await readQueue('http://0.0.0.0:0000/queue')
+  } catch {
+    // swallow error (if it's thrown) as we're not interested in it
   }
-  await expect(check()).rejects.toThrow(Error)
   expect(consoleError).toHaveBeenCalled()
 })
 
-test('Completes on general processing error', async () => {
-  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
-  AWS.__mockAWSError()
+test('Handles queue errors gracefully', async () => {
+  jest.spyOn(console, 'error').mockImplementation(() => {})
+  sqs.receiveMessage.mockRejectedValueOnce(getSampleError(500))
   const result = await readQueue('http://0.0.0.0:0000/queue')
-  expect(result).toStrictEqual([])
-  expect(consoleError).toHaveBeenCalled()
+  expect(result).toEqual([])
+})
+
+test("If error doesn't contain an HTTP status code, it is re-thrown", async () => {
+  jest.spyOn(console, 'error').mockImplementation(() => {})
+  sqs.receiveMessage.mockRejectedValueOnce(getSampleError())
+  await expect(readQueue('http://0.0.0.0:0000/queue')).rejects.toThrow('Queue error')
+})
+
+test("messages default to an empty array if messages key isn't available on receiveMessage return value", async () => {
+  sqs.receiveMessage.mockResolvedValueOnce({})
+  const result = await readQueue('http://0.0.0.0:0000/queue')
+  expect(result).toEqual([])
 })

package/src/__tests__/receiver.spec.js

@@ -1,13 +1,57 @@
-import AWS from 'aws-sdk'
 import fetch from 'node-fetch'
 import testEnv from '../../test-env'
+import { AWS } from '@defra-fish/connectors-lib'
+import { v4 as uuidv4 } from 'uuid'
+
+jest.mock('@defra-fish/connectors-lib', () => {
+  const AWS = jest.fn(() => ({
+    sqs: {
+      getQueueAttributes: jest.fn(() => ({
+        Attributes: {
+          ApproximateNumberOfMessagesDelayed: 0,
+          ApproximateNumberOfMessagesNotVisible: 0,
+          ApproximateNumberOfMessages: 0
+        }
+      })),
+      receiveMessage: jest.fn(() => ({
+        Messages: []
+      })),
+      send: jest.fn()
+    }
+  }))
+  return { AWS }
+})
+
+const getSampleMessages = (number = 1) => {
+  const Messages = []
+  for (let i = 0; i < number; i++) {
+    Messages.push({
+      MessageId: uuidv4(),
+      ReceiptHandle: '15eb8abc-c7c1-4167-9590-839c8feed6dd#9be8971c-f9a9-4bb2-8515-98cdab660e1b',
+      Body: `{"id":"${uuidv4()}"}`,
+      Attributes: {
+        MessageGroupId: 'service-1'
+      }
+    })
+  }
+  return {
+    ResponseMetadata: {
+      RequestId: '00000000-0000-0000-0000-000000000000'
+    },
+    Messages
+  }
+}
 
 let receiver
+let sqs
 
 beforeEach(() => {
   jest.clearAllMocks()
   process.env = Object.assign(process.env, testEnv)
   receiver = require('../receiver').default
+  if (!sqs) {
+    sqs = AWS.mock.results[0].value.sqs
+  }
 })
 
 afterAll(() => {
@@ -15,25 +59,24 @@ afterAll(() => {
 })
 
 test('One message: completes without error', async () => {
-  AWS.__mockOneMessage()
+  sqs.receiveMessage.mockResolvedValueOnce(getSampleMessages())
   fetch.__goodResult()
   await expect(receiver()).resolves.toBeUndefined()
 })
 
 test('No messages: complete without error', async () => {
-  AWS.__mockEmptyQueue()
   fetch.__goodResult()
   await expect(receiver()).resolves.toBeUndefined()
 })
 
 test('10 messages: complete without error', async () => {
-  AWS.__mockNMessages(10)
+  sqs.receiveMessage.mockResolvedValueOnce(getSampleMessages(10))
   fetch.__goodResult()
   await expect(receiver()).resolves.toBeUndefined()
 })
 
 test('Imposes delay after several empty reads', async () => {
-  AWS.__mockEmptyQueue()
+  sqs.receiveMessage.mockResolvedValueOnce({ Messages: [] })
   fetch.__goodResult()
   const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
   for (let i = 0; i < testEnv.TEST_ATTEMPTS_WITH_NO_DELAY; i++) {
@@ -44,7 +87,10 @@ test('Imposes delay after several empty reads', async () => {
 
 test('Receiver: throws exception on general error', async () => {
   const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
-  AWS.__mockFailNoQueue()
+  const queueError = new Error('connect ECONNREFUSED 0.0.0.0:9325')
+  queueError.code = 'NetworkingError'
+  sqs.receiveMessage.mockRejectedValueOnce(queueError)
+
   await expect(receiver()).rejects.toThrow(Error)
   expect(consoleError).toHaveBeenCalled()
 })

package/src/__tests__/show_queue-statistics.spec.js

@@ -1,11 +1,26 @@
-import AWS, { GetQueueAttributesMockImplementation } from 'aws-sdk'
+import { AWS } from '@defra-fish/connectors-lib'
 import showQueueStatistics from '../show-queue-statistics.js'
 import testEnv from '../../test-env'
 import debug from 'debug'
+const { sqs } = AWS.mock.results[0].value
+
+jest.mock('@defra-fish/connectors-lib', () => ({
+  AWS: jest.fn(() => ({
+    sqs: {
+      getQueueAttributes: jest.fn(() => ({
+        Attributes: {
+          ApproximateNumberOfMessages: 0,
+          ApproximateNumberOfMessagesNotVisible: 0,
+          ApproximateNumberOfMessagesDelayed: 0
+        }
+      }))
+    }
+  }))
+}))
 
 beforeEach(() => {
   process.env = Object.assign(process.env, testEnv)
-  GetQueueAttributesMockImplementation.mockClear()
+  sqs.getQueueAttributes.mockClear()
 })
 
 test('shows queue statistics when debug is enabled', async () => {
@@ -15,20 +30,20 @@ test('shows queue statistics when debug is enabled', async () => {
     await showQueueStatistics('http://0.0.0.0:0000/queue')
   }
   await expect(check()).resolves.toBeUndefined()
-  expect(GetQueueAttributesMockImplementation).toHaveBeenCalledTimes(2)
+  expect(sqs.getQueueAttributes).toHaveBeenCalledTimes(2)
 })
 
 test('does not throw errors if the AWS API call fails', async () => {
-  AWS.__mockGetAttributesThrows()
+  sqs.getQueueAttributes.mockRejectedValueOnce(new Error('AWS API call failed'))
   debug.enable('sqs:queue-stats')
   const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {})
   await expect(showQueueStatistics('http://0.0.0.0:0000/queue')).resolves.toBeUndefined()
-  expect(GetQueueAttributesMockImplementation).toHaveBeenCalledTimes(1)
+  expect(sqs.getQueueAttributes).toHaveBeenCalledTimes(1)
   expect(consoleError).toHaveBeenCalled()
 })
 
 test('does not query queue statistics if debug is not enabled', async () => {
   debug.disable()
   await expect(showQueueStatistics('http://0.0.0.0:0000/queue')).resolves.toBeUndefined()
-  expect(GetQueueAttributesMockImplementation).not.toHaveBeenCalled()
+  expect(sqs.getQueueAttributes).not.toHaveBeenCalled()
 })

package/src/delete-messages.js

@@ -18,7 +18,7 @@ const deleteMessages = async (url, messageSubscriberResults) => {
     }
 
     if (params.Entries.length) {
-      const results = await sqs.deleteMessageBatch(params).promise()
+      const results = await sqs.deleteMessageBatch(params)
 
       if (results.Failed.length) {
         console.error('Failed to delete messages from %s: %o', url, results.Failed)

package/src/read-queue.js

@@ -1,6 +1,7 @@
 'use strict'
 import db from 'debug'
 import { AWS } from '@defra-fish/connectors-lib'
+
 const { sqs } = AWS()
 const debug = db('sqs:read-queue')
 
@@ -12,7 +13,7 @@ const debug = db('sqs:read-queue')
  * @param {number} waitTimeMs the amount of time to wait for messages to become available
  * @returns {Promise<SQS.Message[]|*[]>}
  */
-const readQueue = async (url, visibilityTimeoutMs, waitTimeMs) => {
+export default async (url, visibilityTimeoutMs, waitTimeMs) => {
   try {
     const params = {
       QueueUrl: url,
@@ -22,7 +23,7 @@ const readQueue = async (url, visibilityTimeoutMs, waitTimeMs) => {
       VisibilityTimeout: visibilityTimeoutMs / 1000,
       WaitTimeSeconds: waitTimeMs / 1000
     }
-    const data = await sqs.receiveMessage(params).promise()
+    const data = await sqs.receiveMessage(params)
     const messages = data.Messages || []
     debug('Retrieved %d messages from %s', messages.length, url)
     return messages
@@ -33,12 +34,9 @@ const readQueue = async (url, visibilityTimeoutMs, waitTimeMs) => {
      */
     console.error(`Error reading queue: ${url}`, err)
 
-    if (!err.statusCode) {
+    if (!err.$metadata?.httpStatusCode) {
       throw err
-    } else {
-      return []
     }
+    return []
   }
 }
-
-export default readQueue

package/src/show-queue-statistics.js

@@ -22,7 +22,7 @@ const showQueueStatistics = async url => {
         AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible', 'ApproximateNumberOfMessagesDelayed']
       }
 
-      const { Attributes } = await sqs.getQueueAttributes(params).promise()
+      const { Attributes } = await sqs.getQueueAttributes(params)
       const prt = attr => {
         const change = Number.parseInt(Attributes[attr]) - Number.parseInt(last[attr])
         if (change > 0) {

package/src/__mocks__/aws-sdk.js

@@ -1,190 +0,0 @@
-'use strict'
-
-import { v4 as uuidv4 } from 'uuid'
-import { configureAwsSdkMock } from '@defra-fish/connectors-lib/src/__mocks__/aws-mock-helper.js'
-const AwsSdk = configureAwsSdkMock()
-
-let result
-let exception
-let deleteFailures
-
-AwsSdk.__mockEmptyQueue = () => {
-  exception = null
-  result = Object.create({})
-}
-
-AwsSdk.__mockOneMessage = () => {
-  exception = null
-  result = Object.create({
-    ResponseMetadata: {
-      RequestId: '00000000-0000-0000-0000-000000000000'
-    },
-    Messages: [
-      {
-        MessageId: '15eb8abc-c7c1-4167-9590-839c8feed6dd',
-        ReceiptHandle: '15eb8abc-c7c1-4167-9590-839c8feed6dd#9be8971c-f9a9-4bb2-8515-98cdab660e1b',
-        MD5OfBody: '640ad880b5be372fcb5c5ad8b5eb50af',
-        Body: '{"id":"7f6e04fe-4cec-4f40-b763-8c66d71062d9"}',
-        Attributes: {
-          MessageGroupId: 'service-1'
-        }
-      }
-    ]
-  })
-}
-
-AwsSdk.__mockNMessages = n => {
-  exception = null
-  result = Object.create(
-    (result = Object.create({
-      ResponseMetadata: {
-        RequestId: '00000000-0000-0000-0000-000000000000'
-      },
-      Messages: []
-    }))
-  )
-  for (let i = 0; i < n; i++) {
-    result.Messages.push({
-      MessageId: uuidv4(),
-      ReceiptHandle: '15eb8abc-c7c1-4167-9590-839c8feed6dd#9be8971c-f9a9-4bb2-8515-98cdab660e1b',
-      MD5OfBody: '640ad880b5be372fcb5c5ad8b5eb50af',
-      Body: `{"id":"${uuidv4()}"}`,
-      Attributes: {
-        MessageGroupId: 'service-1'
-      }
-    })
-  }
-}
-
-AwsSdk.__mockFailNoQueue = () => {
-  exception = new Error('connect ECONNREFUSED 0.0.0.0:9325')
-  exception.code = 'NetworkingError'
-}
-
-AwsSdk.__mockNotFound = () => {
-  exception = new Error('Not Found')
-  exception.code = 404
-}
-
-AwsSdk.__mockAWSError = () => {
-  result = []
-  exception = new Error()
-  exception = Object.assign(exception, {
-    message: 'ReadCountOutOfRange; see the SQS docs.',
-    code: 'ReadCountOutOfRange',
-    time: '2020-03-05T10:27:42.852Z',
-    statusCode: 400,
-    retryable: false,
-    retryDelay: 49.19455461172468
-  })
-}
-
-AwsSdk.__mockDeleteMessages = () => {
-  exception = null
-  result = Object.create({
-    ResponseMetadata: {
-      RequestId: '00000000-0000-0000-0000-000000000000'
-    },
-    Successful: [
-      {
-        Id: '705e5bc6-bd0f-4424-95aa-7caf9a8eaab4'
-      },
-      {
-        Id: '7ae59705-333f-4d38-b5d9-2c71f4f4ecae'
-      },
-      {
-        Id: '23207320-8c75-4a12-960d-b87455ce7826'
-      }
-    ],
-    Failed: []
-  })
-}
-
-const receiveMessage = () => {
-  if (exception) {
-    throw exception
-  }
-  return {
-    promise: () => result
-  }
-}
-
-AwsSdk.__mockDeleteMessageFailures = () => {
-  deleteFailures = true
-}
-
-const deleteMessageBatch = params => {
-  if (exception) {
-    throw exception
-  }
-
-  result = () => {
-    if (deleteFailures) {
-      return {
-        ResponseMetadata: {
-          RequestId: '00000000-0000-0000-0000-000000000000'
-        },
-        Successful: [],
-        Failed: params.Entries.map(p => ({ Id: p.Id }))
-      }
-    } else {
-      return {
-        ResponseMetadata: {
-          RequestId: '00000000-0000-0000-0000-000000000000'
-        },
-        Successful: params.Entries.map(p => ({ Id: p.Id })),
-        Failed: []
-      }
-    }
-  }
-
-  return {
-    promise: () => result()
-  }
-}
-
-AwsSdk.__mockGetAttributesThrows = () => {
-  exception = new Error()
-}
-
-export const GetQueueAttributesMockImplementation = jest.fn()
-
-GetQueueAttributesMockImplementation.mockReturnValueOnce({
-  promise: () => {
-    if (exception) {
-      throw exception
-    }
-
-    return {
-      Attributes: {
-        ApproximateNumberOfMessagesDelayed: 1,
-        ApproximateNumberOfMessagesNotVisible: 2,
-        ApproximateNumberOfMessages: 3
-      }
-    }
-  }
-}).mockReturnValue({
-  promise: () => {
-    if (exception) {
-      throw exception
-    }
-
-    return {
-      Attributes: {
-        ApproximateNumberOfMessagesDelayed: 0,
-        ApproximateNumberOfMessagesNotVisible: 0,
-        ApproximateNumberOfMessages: 0
-      }
-    }
-  }
-})
-
-AwsSdk.SQS.mockImplementation(() => {
-  return {
-    receiveMessage: receiveMessage,
-    deleteMessageBatch: deleteMessageBatch,
-    getQueueAttributes: GetQueueAttributesMockImplementation
-  }
-})
-
-export default AwsSdk