@defra-fish/pocl-job 1.61.0-rc.8 → 1.61.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@defra-fish/pocl-job",
-  "version": "1.61.0-rc.8",
+  "version": "1.61.0",
   "description": "Post Office Counter Licence sales processor",
   "type": "module",
   "engines": {
-    "node": ">=18.17"
+    "node": ">=20"
   },
   "keywords": [
     "rod",
@@ -35,8 +35,8 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.61.0-rc.8",
-    "@defra-fish/connectors-lib": "1.61.0-rc.8",
+    "@defra-fish/business-rules-lib": "1.61.0",
+    "@defra-fish/connectors-lib": "1.61.0",
     "commander": "^7.2.0",
     "debug": "^4.3.3",
     "filesize": "^6.4.0",
@@ -45,5 +45,5 @@
     "moment-timezone": "^0.5.34",
     "sax-stream": "^1.3.0"
   },
-  "gitHead": "6ee197c0caa5d83c4b111f6a382eee271d1e4f61"
+  "gitHead": "8d1841265a40178f285288e5323a36e887483434"
 }

package/src/__tests__/config.spec.js

@@ -1,12 +1,7 @@
-import AwsMock from 'aws-sdk'
 import config from '../config.js'
 
 describe('config', () => {
   beforeAll(async () => {
-    AwsMock.SecretsManager.__setResponse('getSecretValue', {
-      SecretString: 'test-ssh-key'
-    })
-
     process.env.POCL_FILE_STAGING_TABLE = 'test-file-staging-table'
     process.env.POCL_RECORD_STAGING_TABLE = 'test-record-staging-table'
     process.env.POCL_STAGING_TTL = 1234

package/src/io/__tests__/db.spec.js

@@ -1,5 +1,6 @@
 import * as db from '../db.js'
-import AwsMock from 'aws-sdk'
+import { AWS } from '@defra-fish/connectors-lib'
+const { docClient } = AWS.mock.results[0].value
 
 jest.mock('../../config.js', () => ({
   db: {
@@ -9,16 +10,28 @@ jest.mock('../../config.js', () => ({
   }
 }))
 
+jest.mock('@defra-fish/connectors-lib', () => ({
+  AWS: jest.fn(() => ({
+    docClient: {
+      batchWriteAllPromise: jest.fn(),
+      get: jest.fn(() => ({ Item: undefined })),
+      scanAllPromise: jest.fn(),
+      update: jest.fn(),
+      createUpdateExpression: jest.fn(() => ({})),
+      queryAllPromise: jest.fn()
+    }
+  }))
+}))
+
 describe('database operations', () => {
   const TEST_FILENAME = 'testfile.xml'
   beforeEach(() => {
     jest.clearAllMocks()
-    AwsMock.__resetAll()
   })
   describe('getFileRecord', () => {
     it('calls a get operation on dynamodb', async () => {
       await db.getFileRecord(TEST_FILENAME)
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.get).toHaveBeenCalledWith({
+      expect(docClient.get).toHaveBeenCalledWith({
         TableName: 'TestFileTable',
         Key: { filename: TEST_FILENAME },
         ConsistentRead: true
@@ -29,7 +42,7 @@ describe('database operations', () => {
   describe('getFileRecords', () => {
     it('retrieves all records for the given file if no stages are provided', async () => {
       await db.getFileRecords()
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.scan).toHaveBeenCalledWith(
+      expect(docClient.scanAllPromise).toHaveBeenCalledWith(
         expect.objectContaining({
           TableName: 'TestFileTable',
           ConsistentRead: true
@@ -39,7 +52,7 @@ describe('database operations', () => {
 
     it('retrieves all records a given set of stages', async () => {
       await db.getFileRecords('STAGE 1', 'STAGE 2')
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.scan).toHaveBeenCalledWith(
+      expect(docClient.scanAllPromise).toHaveBeenCalledWith(
         expect.objectContaining({
           TableName: 'TestFileTable',
           FilterExpression: 'stage IN (:stage0,:stage1)',
@@ -52,8 +65,21 @@ describe('database operations', () => {
 
   describe('updateFileStagingTable', () => {
     it('calls update on dynamodb including all necessary parameters', async () => {
+      docClient.createUpdateExpression.mockReturnValueOnce({
+        UpdateExpression: 'SET #expires = :expires,#param1 = :param1,#param2 = :param2',
+        ExpressionAttributeNames: {
+          '#expires': 'expires',
+          '#param1': 'param1',
+          '#param2': 'param2'
+        },
+        ExpressionAttributeValues: {
+          ':expires': expect.any(Number),
+          ':param1': 'test1',
+          ':param2': 'test2'
+        }
+      })
       await db.updateFileStagingTable({ filename: TEST_FILENAME, param1: 'test1', param2: 'test2' })
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.update).toHaveBeenCalledWith(
+      expect(docClient.update).toHaveBeenCalledWith(
         expect.objectContaining({
           TableName: 'TestFileTable',
           Key: { filename: TEST_FILENAME },
@@ -77,7 +103,7 @@ describe('database operations', () => {
     it('calls batchWrite on dynamodb including all necessary parameters', async () => {
       const records = [{ id: 'test1' }, { id: 'test2' }]
       await db.updateRecordStagingTable(TEST_FILENAME, records)
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.batchWrite).toHaveBeenCalledWith(
+      expect(docClient.batchWriteAllPromise).toHaveBeenCalledWith(
         expect.objectContaining({
           RequestItems: {
             TestRecordTable: [
@@ -99,14 +125,14 @@ describe('database operations', () => {
 
     it('is a no-op if records is empty', async () => {
       await db.updateRecordStagingTable(TEST_FILENAME, [])
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.batchWrite).not.toHaveBeenCalled()
+      expect(docClient.batchWriteAllPromise).not.toHaveBeenCalled()
     })
   })
 
   describe('getProcessedRecords', () => {
     it('retrieves all records for the given file if no stages are provided', async () => {
       await db.getProcessedRecords(TEST_FILENAME)
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.query).toHaveBeenCalledWith(
+      expect(docClient.queryAllPromise).toHaveBeenCalledWith(
         expect.objectContaining({
           TableName: 'TestRecordTable',
           KeyConditionExpression: 'filename = :filename',
@@ -118,7 +144,7 @@ describe('database operations', () => {
 
     it('retrieves all records a given set of stages', async () => {
       await db.getProcessedRecords(TEST_FILENAME, 'STAGE 1', 'STAGE 2')
-      expect(AwsMock.DynamoDB.DocumentClient.mockedMethods.query).toHaveBeenCalledWith(
+      expect(docClient.queryAllPromise).toHaveBeenCalledWith(
         expect.objectContaining({
           TableName: 'TestRecordTable',
           KeyConditionExpression: 'filename = :filename',

package/src/io/__tests__/s3.spec.js

@@ -2,19 +2,31 @@ import { refreshS3Metadata } from '../s3'
 import moment from 'moment'
 import { updateFileStagingTable } from '../../io/db.js'
 import { DYNAMICS_IMPORT_STAGE, FILE_STAGE, POST_OFFICE_DATASOURCE } from '../../staging/constants.js'
-import { salesApi } from '@defra-fish/connectors-lib'
+import { salesApi, AWS } from '@defra-fish/connectors-lib'
 import fs from 'fs'
-import AwsMock from 'aws-sdk'
+const { s3, ListObjectsV2Command } = AWS.mock.results[0].value
 
-jest.mock('fs')
 jest.mock('md5-file')
 jest.mock('../../io/db.js')
 jest.mock('../../io/file.js')
 
 jest.mock('@defra-fish/connectors-lib', () => {
   const actual = jest.requireActual('@defra-fish/connectors-lib')
+  const AWS = jest.fn(() => ({
+    docClient: {
+      update: jest.fn(),
+      createUpdateExpression: jest.fn(() => ({}))
+    },
+    s3: {
+      getObject: jest.fn(() => ({
+        createReadStream: jest.fn()
+      })),
+      send: jest.fn()
+    },
+    ListObjectsV2Command: jest.fn()
+  }))
   return {
-    AWS: actual.AWS,
+    AWS,
     salesApi: {
       ...Object.keys(actual.salesApi).reduce((acc, k) => ({ ...acc, [k]: jest.fn(async () => {}) }), {})
     }
@@ -29,19 +41,19 @@ jest.mock('../../config.js', () => ({
     bucket: 'testbucket'
   }
 }))
+
 describe('s3 operations', () => {
   beforeEach(() => {
     jest.clearAllMocks()
-    AwsMock.__resetAll()
   })
 
   describe('refreshS3Metadata', () => {
-    it('gets a list of files from S3', async () => {
+    describe('gets a list of files from S3', () => {
       const s3Key1 = `${moment().format('YYYY-MM-DD')}/test1.xml`
       const s3Key2 = `${moment().format('YYYY-MM-DD')}/test2.xml`
 
-      AwsMock.S3.mockedMethods.listObjectsV2.mockReturnValueOnce({
-        promise: () => ({
+      beforeEach(async () => {
+        s3.send.mockReturnValueOnce({
           IsTruncated: false,
           Contents: [
             {
@@ -58,52 +70,66 @@ describe('s3 operations', () => {
             }
           ]
         })
-      })
 
-      await refreshS3Metadata()
+        await refreshS3Metadata()
+      })
 
-      expect(AwsMock.S3.mockedMethods.listObjectsV2).toHaveBeenNthCalledWith(1, {
-        Bucket: 'testbucket',
-        ContinuationToken: undefined
+      it('calls ListObjectsV2Command, with bucket name and no continuation token', () => {
+        expect(ListObjectsV2Command).toHaveBeenNthCalledWith(1, {
+          Bucket: 'testbucket',
+          ContinuationToken: undefined
+        })
       })
-      expect(updateFileStagingTable).toHaveBeenNthCalledWith(1, {
-        filename: 'test1.xml',
-        md5: 'example-md5',
-        fileSize: '1 KB',
-        stage: FILE_STAGE.Pending,
-        s3Key: s3Key1
+
+      it('calls updateFileStagingTable first with initial test file', () => {
+        expect(updateFileStagingTable).toHaveBeenNthCalledWith(1, {
+          filename: 'test1.xml',
+          md5: 'example-md5',
+          fileSize: '1 KB',
+          stage: FILE_STAGE.Pending,
+          s3Key: s3Key1
+        })
       })
-      expect(updateFileStagingTable).toHaveBeenNthCalledWith(2, {
-        filename: 'test2.xml',
-        md5: 'example-md5',
-        fileSize: '2 KB',
-        stage: FILE_STAGE.Pending,
-        s3Key: s3Key2
+
+      it('calls updateFileStagingTable a second time with second test file', () => {
+        expect(updateFileStagingTable).toHaveBeenNthCalledWith(2, {
+          filename: 'test2.xml',
+          md5: 'example-md5',
+          fileSize: '2 KB',
+          stage: FILE_STAGE.Pending,
+          s3Key: s3Key2
+        })
       })
-      expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(1, 'test1.xml', {
-        status: DYNAMICS_IMPORT_STAGE.Pending,
-        dataSource: POST_OFFICE_DATASOURCE,
-        fileSize: '1 KB',
-        receiptTimestamp: expect.any(String),
-        salesDate: expect.any(String),
-        notes: 'Retrieved from the remote server and awaiting processing'
+
+      it('calls upsertTransactionFile for first test file', () => {
+        expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(1, 'test1.xml', {
+          status: DYNAMICS_IMPORT_STAGE.Pending,
+          dataSource: POST_OFFICE_DATASOURCE,
+          fileSize: '1 KB',
+          receiptTimestamp: expect.any(String),
+          salesDate: expect.any(String),
+          notes: 'Retrieved from the remote server and awaiting processing'
+        })
       })
-      expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(2, 'test2.xml', {
-        status: DYNAMICS_IMPORT_STAGE.Pending,
-        dataSource: POST_OFFICE_DATASOURCE,
-        fileSize: '2 KB',
-        receiptTimestamp: expect.any(String),
-        salesDate: expect.any(String),
-        notes: 'Retrieved from the remote server and awaiting processing'
+
+      it('calls upsertTransactionFile for second test file', () => {
+        expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(2, 'test2.xml', {
+          status: DYNAMICS_IMPORT_STAGE.Pending,
+          dataSource: POST_OFFICE_DATASOURCE,
+          fileSize: '2 KB',
+          receiptTimestamp: expect.any(String),
+          salesDate: expect.any(String),
+          notes: 'Retrieved from the remote server and awaiting processing'
+        })
       })
     })
 
-    it('gets a truncated list of files from S3', async () => {
+    describe('gets a truncated list of files from S3', () => {
       const s3Key1 = `${moment().format('YYYY-MM-DD')}/test1.xml`
 
-      AwsMock.S3.mockedMethods.listObjectsV2
-        .mockReturnValue({
-          promise: () => ({
+      beforeEach(async () => {
+        s3.send
+          .mockReturnValue({
             IsTruncated: false,
             Contents: [
               {
@@ -114,9 +140,7 @@ describe('s3 operations', () => {
               }
             ]
           })
-        })
-        .mockReturnValueOnce({
-          promise: () => ({
+          .mockReturnValueOnce({
             IsTruncated: true,
             NextContinuationToken: 'token',
             Contents: [
@@ -128,53 +152,72 @@ describe('s3 operations', () => {
               }
             ]
           })
-        })
 
-      await refreshS3Metadata()
+        await refreshS3Metadata()
+      })
 
-      expect(AwsMock.S3.mockedMethods.listObjectsV2).toHaveBeenNthCalledWith(1, {
-        Bucket: 'testbucket',
-        ContinuationToken: undefined
+      it('calls ListObjectsV2Command a first time with bucket name and no continuation token', () => {
+        expect(ListObjectsV2Command).toHaveBeenNthCalledWith(1, {
+          Bucket: 'testbucket',
+          ContinuationToken: undefined
+        })
       })
-      expect(AwsMock.S3.mockedMethods.listObjectsV2).toHaveBeenNthCalledWith(2, {
-        Bucket: 'testbucket',
-        ContinuationToken: 'token'
+
+      it('calls ListObjectsV2Command a second time with bucket name and continuation token', () => {
+        expect(ListObjectsV2Command).toHaveBeenNthCalledWith(2, {
+          Bucket: 'testbucket',
+          ContinuationToken: 'token'
+        })
       })
-      expect(updateFileStagingTable).toHaveBeenNthCalledWith(1, {
-        filename: 'test1.xml',
-        md5: 'example-md5',
-        fileSize: '1 KB',
-        stage: FILE_STAGE.Pending,
-        s3Key: s3Key1
+
+      it('updates file staging table with first test file', () => {
+        expect(updateFileStagingTable).toHaveBeenNthCalledWith(1, {
+          filename: 'test1.xml',
+          md5: 'example-md5',
+          fileSize: '1 KB',
+          stage: FILE_STAGE.Pending,
+          s3Key: s3Key1
+        })
       })
-      expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(1, 'test1.xml', {
-        status: DYNAMICS_IMPORT_STAGE.Pending,
-        dataSource: POST_OFFICE_DATASOURCE,
-        fileSize: '1 KB',
-        receiptTimestamp: expect.any(String),
-        salesDate: expect.any(String),
-        notes: 'Retrieved from the remote server and awaiting processing'
+
+      it('updates file staging table with second test file', () => {
+        expect(updateFileStagingTable).toHaveBeenNthCalledWith(2, {
+          filename: 'test1.xml',
+          md5: 'example-md5',
+          fileSize: '1 KB',
+          stage: FILE_STAGE.Pending,
+          s3Key: s3Key1
+        })
+      })
+
+      it('upserts sales api with transaction file details', () => {
+        expect(salesApi.upsertTransactionFile).toHaveBeenNthCalledWith(1, 'test1.xml', {
+          status: DYNAMICS_IMPORT_STAGE.Pending,
+          dataSource: POST_OFFICE_DATASOURCE,
+          fileSize: '1 KB',
+          receiptTimestamp: expect.any(String),
+          salesDate: expect.any(String),
+          notes: 'Retrieved from the remote server and awaiting processing'
+        })
       })
     })
 
     it('skips file processing if a file has already been marked as processed in Dynamics', async () => {
-      fs.createReadStream.mockReturnValueOnce('teststream')
-      fs.statSync.mockReturnValueOnce({ size: 1024 })
+      jest.spyOn(fs, 'createReadStream').mockReturnValueOnce('teststream')
+      jest.spyOn(fs, 'statSync').mockReturnValueOnce({ size: 1024 })
       salesApi.getTransactionFile.mockResolvedValueOnce({ status: { description: 'Processed' } })
       const s3Key = `${moment().format('YYYY-MM-DD')}/test-already-processed.xml`
 
-      AwsMock.S3.mockedMethods.listObjectsV2.mockReturnValueOnce({
-        promise: () => ({
-          IsTruncated: false,
-          Contents: [
-            {
-              Key: s3Key,
-              LastModified: moment().toISOString(),
-              ETag: 'example-md5',
-              Size: 1024
-            }
-          ]
-        })
+      s3.send.mockReturnValueOnce({
+        IsTruncated: false,
+        Contents: [
+          {
+            Key: s3Key,
+            LastModified: moment().toISOString(),
+            ETag: 'example-md5',
+            Size: 1024
+          }
+        ]
       })
 
       await refreshS3Metadata()
@@ -186,33 +229,29 @@ describe('s3 operations', () => {
     it('skips file processing if a file is older than one week', async () => {
       const s3Key1 = `${moment().format('YYYY-MM-DD')}/test1.xml`
 
-      AwsMock.S3.mockedMethods.listObjectsV2
+      s3.send
         .mockReturnValue({
-          promise: () => ({
-            IsTruncated: false,
-            Contents: [
-              {
-                Key: s3Key1,
-                LastModified: moment().subtract(1, 'days').toISOString(),
-                ETag: 'example-md5',
-                Size: 1024
-              }
-            ]
-          })
+          IsTruncated: false,
+          Contents: [
+            {
+              Key: s3Key1,
+              LastModified: moment().subtract(1, 'days').toISOString(),
+              ETag: 'example-md5',
+              Size: 1024
+            }
+          ]
         })
         .mockReturnValueOnce({
-          promise: () => ({
-            IsTruncated: true,
-            NextContinuationToken: 'token',
-            Contents: [
-              {
-                Key: s3Key1,
-                LastModified: moment().subtract(1, 'days').toISOString(),
-                ETag: 'example-md5',
-                Size: 1024
-              }
-            ]
-          })
+          IsTruncated: true,
+          NextContinuationToken: 'token',
+          Contents: [
+            {
+              Key: s3Key1,
+              LastModified: moment().subtract(1, 'days').toISOString(),
+              ETag: 'example-md5',
+              Size: 1024
+            }
+          ]
         })
 
       await refreshS3Metadata()
@@ -221,15 +260,11 @@ describe('s3 operations', () => {
       expect(salesApi.upsertTransactionFile).not.toHaveBeenCalled()
     })
 
-    it('logs any errors raised by calling s3.listObjectsV2', async () => {
+    it('logs any errors raised by calling ListObjectsV2Command', async () => {
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
 
       const testError = new Error('Test error')
-      AwsMock.S3.mockedMethods.listObjectsV2.mockReturnValue({
-        promise: () => {
-          throw testError
-        }
-      })
+      s3.send.mockRejectedValueOnce(testError)
 
       await expect(refreshS3Metadata()).rejects.toThrow(testError)
       expect(consoleErrorSpy).toHaveBeenCalledWith(testError)
@@ -238,10 +273,8 @@ describe('s3 operations', () => {
     it('raises a warning if the bucket is empty', async () => {
       const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
 
-      AwsMock.S3.mockedMethods.listObjectsV2.mockReturnValueOnce({
-        promise: () => ({
-          IsTruncated: false
-        })
+      s3.send.mockReturnValueOnce({
+        IsTruncated: false
       })
 
       await refreshS3Metadata()

package/src/io/db.js

@@ -10,13 +10,11 @@ const { docClient } = AWS()
  * @returns {Promise<void>}
  */
 export const updateFileStagingTable = async ({ filename, ...entries }) => {
-  await docClient
-    .update({
-      TableName: config.db.fileStagingTable,
-      Key: { filename },
-      ...docClient.createUpdateExpression({ expires: Math.floor(Date.now() / 1000) + config.db.stagingTtlDelta, ...entries })
-    })
-    .promise()
+  await docClient.update({
+    TableName: config.db.fileStagingTable,
+    Key: { filename },
+    ...docClient.createUpdateExpression({ expires: Math.floor(Date.now() / 1000) + config.db.stagingTtlDelta, ...entries })
+  })
 }
 
 /**
@@ -42,7 +40,7 @@ export const getFileRecords = async (...stages) => {
  * @returns {DocumentClient.AttributeMap}
  */
 export const getFileRecord = async filename => {
-  const result = await docClient.get({ TableName: config.db.fileStagingTable, Key: { filename }, ConsistentRead: true }).promise()
+  const result = await docClient.get({ TableName: config.db.fileStagingTable, Key: { filename }, ConsistentRead: true })
   return result.Item
 }
 

package/src/io/s3.js

@@ -4,11 +4,12 @@ import config from '../config.js'
 import { DYNAMICS_IMPORT_STAGE } from '../staging/constants.js'
 import { storeS3Metadata } from '../transport/storeS3MetaData.js'
 import { AWS, salesApi } from '@defra-fish/connectors-lib'
-const { s3 } = AWS()
+const { s3, ListObjectsV2Command } = AWS()
 
 const listObjectsV2 = async function (params) {
   try {
-    return s3.listObjectsV2(params).promise()
+    const command = new ListObjectsV2Command(params)
+    return await s3.send(command)
   } catch (e) {
     console.error(e)
     throw e

package/src/staging/__tests__/pocl-data-staging.spec.js

@@ -5,12 +5,12 @@ import { stage } from '../pocl-data-staging.js'
 import { createTransactions } from '../create-transactions.js'
 import { finaliseTransactions } from '../finalise-transactions.js'
 import { getFileRecord, updateFileStagingTable } from '../../io/db.js'
+
 import fs from 'fs'
 
 jest.mock('../create-transactions.js')
 jest.mock('../finalise-transactions.js')
 jest.mock('../../io/db.js')
-jest.mock('fs')
 jest.mock('md5-file', () => () => 'test-md5')
 
 jest.mock('@defra-fish/connectors-lib', () => {
@@ -37,6 +37,7 @@ describe('pocl data staging', () => {
       ['the file has not previously been processed', undefined],
       ['the file has pending state', { stage: FILE_STAGE.Pending }]
     ])('%s', async (desc, val) => {
+      jest.spyOn(fs, 'statSync')
       getFileRecord.mockResolvedValueOnce(val)
       getFileRecord.mockResolvedValueOnce({
         stagingSucceeded: 5,
@@ -87,6 +88,7 @@ describe('pocl data staging', () => {
   })
 
   it('only runs finalisation if the creation phase has previously been completed', async () => {
+    jest.spyOn(fs, 'statSync')
     getFileRecord.mockResolvedValue({ stage: FILE_STAGE.Finalising })
     fs.statSync.mockReturnValueOnce({ size: 1024 })
     salesApi.getTransactionFile.mockResolvedValueOnce({ status: { description: DYNAMICS_IMPORT_STAGE.InProgress } })
@@ -104,6 +106,7 @@ describe('pocl data staging', () => {
   })
 
   it('updates the status in Dynamics if the Dynamics returns InProgress but now marked completed in DynamoDB', async () => {
+    jest.spyOn(fs, 'statSync')
     salesApi.getTransactionFile.mockResolvedValueOnce({ status: { description: DYNAMICS_IMPORT_STAGE.InProgress } })
     getFileRecord.mockResolvedValue({ stage: FILE_STAGE.Completed })
     fs.statSync.mockReturnValueOnce({ size: 1024 })
@@ -116,6 +119,7 @@ describe('pocl data staging', () => {
   })
 
   it('is a no-op if the file is marked as processed in Dynamics', async () => {
+    jest.spyOn(fs, 'statSync')
     const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
     salesApi.getTransactionFile.mockResolvedValueOnce({ status: { description: DYNAMICS_IMPORT_STAGE.ProcessedWithWarnings } })
     getFileRecord.mockResolvedValue({ stage: FILE_STAGE.Completed })

package/src/transport/__tests__/s3-to-local.spec.js

@@ -1,9 +1,10 @@
 import { s3ToLocal } from '../s3-to-local.js'
 import stream from 'stream'
-import AwsMock from 'aws-sdk'
+import { AWS } from '@defra-fish/connectors-lib'
+import fs from 'fs'
+const { s3 } = AWS.mock.results[0].value
 
 const MOCK_TMP = '/tmp/local/mock'
-jest.mock('fs')
 jest.mock('stream')
 jest.mock('../../io/file.js', () => ({
   getTempDir: jest.fn((...subfolders) => `${MOCK_TMP}/${subfolders.join('/')}`)
@@ -15,17 +16,23 @@ jest.mock('../../config.js', () => ({
   }
 }))
 
+jest.mock('@defra-fish/connectors-lib', () => ({
+  AWS: jest.fn(() => ({
+    s3: {
+      getObject: jest.fn(() => ({
+        createReadStream: jest.fn(() => ({}))
+      }))
+    }
+  }))
+}))
+
 describe('s3-to-local', () => {
   beforeEach(() => {
     jest.clearAllMocks()
-    AwsMock.__resetAll()
   })
 
   it('retrieves a file from s3 for a given key', async () => {
-    const mockCreateReadStream = jest.fn()
-    AwsMock.S3.mockedMethods.getObject.mockImplementationOnce(() => {
-      return { createReadStream: mockCreateReadStream }
-    })
+    jest.spyOn(fs, 'createWriteStream').mockReturnValueOnce({})
     stream.pipeline.mockImplementation(
       jest.fn((streams, callback) => {
         callback()
@@ -33,10 +40,12 @@ describe('s3-to-local', () => {
     )
 
     const result = await s3ToLocal('/example/testS3Key.xml')
+    const { createReadStream } = s3.getObject.mock.results[0].value
+
     expect(result).toBe(`${MOCK_TMP}/example/testS3Key.xml`)
-    expect(mockCreateReadStream).toHaveBeenCalled()
+    expect(createReadStream).toHaveBeenCalled()
     expect(stream.pipeline).toHaveBeenCalled()
-    expect(AwsMock.S3.mockedMethods.getObject).toHaveBeenCalledWith({
+    expect(s3.getObject).toHaveBeenCalledWith({
       Bucket: 'testbucket',
       Key: '/example/testS3Key.xml'
     })