@defra-fish/connectors-lib 1.73.0 → 1.74.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/connectors-lib",
-  "version": "1.73.0",
+  "version": "1.74.0-rc.0",
   "description": "Shared connectors",
   "type": "module",
   "engines": {
@@ -47,5 +47,5 @@
     "node-fetch": "2.7.0",
     "redlock": "4.2.0"
   },
-  "gitHead": "128d150e6bd30468bca4e39fb44dd11c5598eb43"
+  "gitHead": "4528014dc6eea3407641b04f1733bf01ed297a5e"
 }

package/src/__tests__/govuk-pay-api.spec.js

@@ -2,25 +2,33 @@ import * as govUkPayApi from '../govuk-pay-api.js'
 jest.mock('node-fetch')
 const fetch = require('node-fetch')
 
-process.env.GOV_PAY_API_URL = 'http://0.0.0.0/payment'
-process.env.GOV_PAY_RCP_API_URL = 'http://0.0.0.0/agreement'
-process.env.GOV_PAY_APIKEY = 'key'
-process.env.GOV_PAY_RECURRING_APIKEY = 'recurringkey'
+const envVars = Object.freeze({
+  GOV_PAY_API_URL: 'http://0.0.0.0/payment',
+  GOV_PAY_RCP_API_URL: 'http://0.0.0.0/agreement',
+  GOV_PAY_APIKEY: 'key',
+  GOV_PAY_RECURRING_APIKEY: 'recurringkey'
+})
 
-const headers = {
+const headers = () => ({
   accept: 'application/json',
   authorization: `Bearer ${process.env.GOV_PAY_APIKEY}`,
   'content-type': 'application/json'
-}
+})
 
-const recurringHeaders = {
+const recurringHeaders = () => ({
   accept: 'application/json',
   authorization: `Bearer ${process.env.GOV_PAY_RECURRING_APIKEY}`,
   'content-type': 'application/json'
-}
+})
 
 describe('govuk-pay-api-connector', () => {
-  beforeEach(jest.clearAllMocks)
+  beforeEach(() => {
+    jest.clearAllMocks()
+    for (const [key, value] of Object.entries(envVars)) {
+      process.env[key] = value
+    }
+    delete process.env.GOV_PAY_REQUEST_TIMEOUT_MS
+  })
 
   describe('createPayment', () => {
     it('creates new payments', async () => {
@@ -28,7 +36,7 @@ describe('govuk-pay-api-connector', () => {
       await expect(govUkPayApi.createPayment({ cost: 0 })).resolves.toEqual({ ok: true, status: 200 })
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment', {
         body: JSON.stringify({ cost: 0 }),
-        headers,
+        headers: headers(),
         method: 'post',
         timeout: 10000
       })
@@ -42,7 +50,7 @@ describe('govuk-pay-api-connector', () => {
       expect(govUkPayApi.createPayment({ cost: 0 })).rejects.toEqual(Error(''))
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment', {
         body: JSON.stringify({ cost: 0 }),
-        headers,
+        headers: headers(),
         method: 'post',
         timeout: 10000
       })
@@ -54,7 +62,7 @@ describe('govuk-pay-api-connector', () => {
       await expect(govUkPayApi.createPayment({ cost: 0 }, true)).resolves.toEqual({ ok: true, status: 200 })
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment', {
         body: JSON.stringify({ cost: 0 }),
-        headers: recurringHeaders,
+        headers: recurringHeaders(),
         method: 'post',
         timeout: 10000
       })
@@ -66,7 +74,7 @@ describe('govuk-pay-api-connector', () => {
       fetch.mockReturnValueOnce({ ok: true, status: 200, json: () => {} })
       await expect(govUkPayApi.fetchPaymentStatus(123)).resolves.toEqual(expect.objectContaining({ ok: true, status: 200 }))
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123', {
-        headers,
+        headers: headers(),
         method: 'get',
         timeout: 10000
       })
@@ -78,7 +86,7 @@ describe('govuk-pay-api-connector', () => {
         throw new Error('')
       })
       await expect(govUkPayApi.fetchPaymentStatus(123)).rejects.toEqual(Error(''))
-      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123', { headers, method: 'get', timeout: 10000 })
+      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123', { headers: headers(), method: 'get', timeout: 10000 })
       expect(consoleErrorSpy).toHaveBeenCalled()
     })
 
@@ -86,7 +94,7 @@ describe('govuk-pay-api-connector', () => {
       fetch.mockReturnValueOnce({ ok: true, status: 200, json: () => {} })
       await expect(govUkPayApi.fetchPaymentStatus(123, true)).resolves.toEqual(expect.objectContaining({ ok: true, status: 200 }))
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123', {
-        headers: recurringHeaders,
+        headers: recurringHeaders(),
         method: 'get',
         timeout: 10000
       })
@@ -97,7 +105,7 @@ describe('govuk-pay-api-connector', () => {
     it('retrieves payment events', async () => {
       fetch.mockReturnValueOnce({ ok: true, status: 200, json: () => {} })
       await expect(govUkPayApi.fetchPaymentEvents(123)).resolves.toEqual(expect.objectContaining({ ok: true, status: 200 }))
-      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123/events', { headers, method: 'get', timeout: 10000 })
+      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123/events', { headers: headers(), method: 'get', timeout: 10000 })
     })
 
     it('logs and throws errors', async () => {
@@ -113,7 +121,7 @@ describe('govuk-pay-api-connector', () => {
       fetch.mockReturnValueOnce({ ok: true, status: 200, json: () => {} })
       await expect(govUkPayApi.fetchPaymentEvents(123, true)).resolves.toEqual(expect.objectContaining({ ok: true, status: 200 }))
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/payment/123/events', {
-        headers: recurringHeaders,
+        headers: recurringHeaders(),
         method: 'get',
         timeout: 10000
       })
@@ -126,7 +134,7 @@ describe('govuk-pay-api-connector', () => {
       await expect(govUkPayApi.createRecurringPaymentAgreement({ cost: 0 })).resolves.toEqual({ ok: true, status: 200 })
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/agreement', {
         body: JSON.stringify({ cost: 0 }),
-        headers: recurringHeaders,
+        headers: recurringHeaders(),
         method: 'post',
         timeout: 10000
       })
@@ -140,7 +148,7 @@ describe('govuk-pay-api-connector', () => {
       expect(govUkPayApi.createRecurringPaymentAgreement({ reference: '123' })).rejects.toEqual(Error(''))
       expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/agreement', {
         body: JSON.stringify({ reference: '123' }),
-        headers: recurringHeaders,
+        headers: recurringHeaders(),
         method: 'post',
         timeout: 10000
       })
@@ -148,6 +156,106 @@ describe('govuk-pay-api-connector', () => {
     })
   })
 
+  describe('queueRecurringPayment', () => {
+    const getSamplePreparedPayment = (overrides = {}) => ({
+      agreement_id: 'agreement_id',
+      ...overrides
+    })
+
+    it('queues a recurring payment', async () => {
+      const GOV_PAY_API_URL = 'GovPay API URL'
+      const GOV_PAY_REQUEST_TIMEOUT_MS = '12345'
+      const GOV_PAY_RECURRING_APIKEY = 'GovPay Recurring API Key'
+      process.env.GOV_PAY_API_URL = GOV_PAY_API_URL
+      process.env.GOV_PAY_REQUEST_TIMEOUT_MS = GOV_PAY_REQUEST_TIMEOUT_MS
+      process.env.GOV_PAY_RECURRING_APIKEY = GOV_PAY_RECURRING_APIKEY
+      const batcher = { addRequest: jest.fn() }
+      const preparedPayment = getSamplePreparedPayment({ cost: 0 })
+      govUkPayApi.queueRecurringPayment(preparedPayment, batcher)
+
+      expect(batcher.addRequest).toHaveBeenCalledWith(
+        GOV_PAY_API_URL,
+        expect.objectContaining({
+          headers: recurringHeaders(),
+          method: 'post',
+          body: JSON.stringify(preparedPayment),
+          timeout: GOV_PAY_REQUEST_TIMEOUT_MS
+        }),
+        expect.anything()
+      )
+    })
+
+    it('adds agreement id as a reference', async () => {
+      // eslint-disable-next-line camelcase
+      const agreement_id = Symbol('agreement_id')
+      const batcher = { addRequest: jest.fn() }
+      govUkPayApi.queueRecurringPayment({ cost: 0, reference: '123', agreement_id }, batcher)
+      expect(batcher.addRequest).toHaveBeenCalledWith(expect.any(String), expect.any(Object), agreement_id)
+    })
+
+    it("uses default timeout of 10000ms if GOV_PAY_REQUEST_TIMEOUT_MS isn't set", async () => {
+      delete process.env.GOV_PAY_REQUEST_TIMEOUT_MS
+      const batcher = { addRequest: jest.fn() }
+
+      govUkPayApi.queueRecurringPayment(getSamplePreparedPayment({ cost: 0 }), batcher)
+
+      expect(batcher.addRequest).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          timeout: 10000
+        }),
+        expect.anything()
+      )
+    })
+  })
+
+  describe('queueRecurringPaymentStatusCheck', () => {
+    it.each(['abc-123', 'def-456'])('queues a recurring payment status check with payment id %s', async paymentId => {
+      const GOV_PAY_API_URL = 'GovPay API URL'
+      const GOV_PAY_REQUEST_TIMEOUT_MS = '12345'
+      const GOV_PAY_RECURRING_APIKEY = 'GovPay Recurring API Key'
+      process.env.GOV_PAY_API_URL = GOV_PAY_API_URL
+      process.env.GOV_PAY_REQUEST_TIMEOUT_MS = GOV_PAY_REQUEST_TIMEOUT_MS
+      process.env.GOV_PAY_RECURRING_APIKEY = GOV_PAY_RECURRING_APIKEY
+      const batcher = { addRequest: jest.fn() }
+      govUkPayApi.queueRecurringPaymentStatusCheck(paymentId, batcher)
+
+      expect(batcher.addRequest).toHaveBeenCalledWith(
+        `${GOV_PAY_API_URL}/${paymentId}`,
+        expect.objectContaining({
+          headers: recurringHeaders(),
+          method: 'get',
+          timeout: GOV_PAY_REQUEST_TIMEOUT_MS
+        }),
+        expect.any(String)
+      )
+    })
+
+    it.each(['3c726d49-a1c0-42f0-88ca-78c0b9932bcd', '4122f2d9-b6ae-47ee-9590-c5d7f45fd9da'])(
+      'adds payment id %s as a reference',
+      async paymentId => {
+        const batcher = { addRequest: jest.fn() }
+        govUkPayApi.queueRecurringPaymentStatusCheck(paymentId, batcher)
+        expect(batcher.addRequest).toHaveBeenCalledWith(expect.any(String), expect.any(Object), paymentId)
+      }
+    )
+
+    it("uses default timeout of 10000ms if GOV_PAY_REQUEST_TIMEOUT_MS isn't set", async () => {
+      delete process.env.GOV_PAY_REQUEST_TIMEOUT_MS
+      const batcher = { addRequest: jest.fn() }
+
+      govUkPayApi.queueRecurringPaymentStatusCheck('aaa-111', batcher)
+
+      expect(batcher.addRequest).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          timeout: 10000
+        }),
+        expect.any(String)
+      )
+    })
+  })
+
   describe('isGovPayUp', () => {
     it.each(['http://gov.uk.pay/health/check/url', 'https://gov-uk-pay?health-check-url'])(
       'calls healthy endpoint %s',
@@ -191,7 +299,7 @@ describe('govuk-pay-api-connector', () => {
       await expect(govUkPayApi.getRecurringPaymentAgreementInformation(123)).resolves.toEqual(
         expect.objectContaining({ ok: true, status: 200 })
       )
-      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/agreement/123', { headers: recurringHeaders, method: 'get', timeout: 10000 })
+      expect(fetch).toHaveBeenCalledWith('http://0.0.0.0/agreement/123', { headers: recurringHeaders(), method: 'get', timeout: 10000 })
     })
 
     it('logs and throws errors', async () => {

package/src/__tests__/http-request-batcher.spec.js

@@ -3,7 +3,7 @@ import fetch from 'node-fetch'
 import db from 'debug'
 const [{ value: debug }] = db.mock.results
 
-jest.mock('node-fetch', () => jest.fn(() => ({ status: 200 })))
+jest.mock('node-fetch', () => jest.fn(() => Promise.resolve({ status: 200 })))
 jest.mock('debug', () => jest.fn(() => jest.fn()))
 
 describe('HTTP Request Batcher', () => {
@@ -34,7 +34,7 @@ describe('HTTP Request Batcher', () => {
 
   it('initialises with an empty response queue', () => {
     const batcher = new HTTPRequestBatcher()
-    expect(batcher.responses).toEqual([])
+    expect(batcher.responseDetails).toEqual([])
   })
 
   it('initialises with a custom batch size', () => {
@@ -50,9 +50,39 @@ describe('HTTP Request Batcher', () => {
     batcher.addRequest('https://api-three.example.com', { method: 'PUT' })
 
     expect(batcher.requestQueue).toEqual([
-      { url: 'https://api-one.example.com', options: { method: 'GET' } },
-      { url: 'https://api-b.example.com', options: { method: 'POST' } },
-      { url: 'https://api-three.example.com', options: { method: 'PUT' } }
+      expect.objectContaining({ url: 'https://api-one.example.com', options: { method: 'GET' } }),
+      expect.objectContaining({ url: 'https://api-b.example.com', options: { method: 'POST' } }),
+      expect.objectContaining({ url: 'https://api-three.example.com', options: { method: 'PUT' } })
+    ])
+  })
+
+  it('allows an optional reference to be added to a request', () => {
+    const reference1 = Symbol('ref-1')
+    const reference2 = Symbol('ref-2')
+    const batcher = new HTTPRequestBatcher()
+
+    batcher.addRequest('https://api-one.example.com', { method: 'GET' }, reference1)
+    batcher.addRequest('https://api-b.example.com', { method: 'POST' }, reference2)
+
+    expect(batcher.requestQueue).toEqual([
+      expect.objectContaining({ url: 'https://api-one.example.com', options: { method: 'GET' }, reference: reference1 }),
+      expect.objectContaining({ url: 'https://api-b.example.com', options: { method: 'POST' }, reference: reference2 })
+    ])
+  })
+
+  it('persists the reference in the responseDetails array after fetch', async () => {
+    const reference1 = Symbol('ref-1')
+    const reference2 = Symbol('ref-2')
+    const batcher = new HTTPRequestBatcher()
+
+    batcher.addRequest('https://api-one.example.com', { method: 'GET' }, reference1)
+    batcher.addRequest('https://api-b.example.com', { method: 'POST' }, reference2)
+
+    await batcher.fetch()
+
+    expect(batcher.responseDetails).toEqual([
+      expect.objectContaining({ url: 'https://api-one.example.com', options: { method: 'GET' }, reference: reference1 }),
+      expect.objectContaining({ url: 'https://api-b.example.com', options: { method: 'POST' }, reference: reference2 })
     ])
   })
 
@@ -99,13 +129,26 @@ describe('HTTP Request Batcher', () => {
     }
     await batcher.fetch()
 
-    expect(batcher.responses).toEqual([{ status: 200 }, { status: 200 }])
+    expect(batcher.responseDetails.map(rd => rd.responses[0])).toEqual([{ status: 200 }, { status: 200 }])
+  })
+
+  it('pairs responses with the corresponding request', async () => {
+    const batcher = new HTTPRequestBatcher({ batchSize: 2 })
+    batcher.addRequest('https://api-one.example.com', { method: 'GET' })
+    batcher.addRequest('https://api-two.example.com', { method: 'POST' })
+    await batcher.fetch()
+
+    expect(batcher.responseDetails).toEqual([
+      expect.objectContaining({ responses: [{ status: 200 }], url: 'https://api-one.example.com', options: { method: 'GET' } }),
+      expect.objectContaining({ responses: [{ status: 200 }], url: 'https://api-two.example.com', options: { method: 'POST' } })
+    ])
   })
 
   describe('multiple batches', () => {
     beforeEach(() => {
       jest.useFakeTimers()
       jest.spyOn(global, 'setTimeout')
+      global.setTimeout.mockImplementation(cb => cb())
     })
 
     afterEach(() => {
@@ -166,20 +209,57 @@ describe('HTTP Request Batcher', () => {
       const batcher = new HTTPRequestBatcher({ batchSize: 1 })
       batcher.addRequest('https://api.example.com')
       batcher.addRequest('https://alt-api.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
-      expect(batcher.responses).toEqual([{ status: 200 }, { status: 200 }])
+      expect(batcher.responseDetails.map(rd => rd.responses[0])).toEqual([{ status: 200 }, { status: 200 }])
     })
 
     it('retries requests that received a 429 response', async () => {
       const batcher = new HTTPRequestBatcher({ batchSize: 1 })
       fetch.mockImplementationOnce(() => ({ status: 429 }))
       batcher.addRequest('https://api.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(fetch).toHaveBeenCalledTimes(2)
     })
 
+    it.each([10, 7])('retries requests that received a 429 response up to configured maxRequestAttempts(%i)', async maxRequestAttempts => {
+      const batcher = new HTTPRequestBatcher({ batchSize: 1 })
+      batcher.maxRequestAttempts = maxRequestAttempts
+      for (let x = 0; x < maxRequestAttempts; x++) {
+        fetch.mockImplementationOnce(() => ({ status: 429 }))
+      }
+      batcher.addRequest('https://api.example.com')
+      await batcher.fetch()
+      expect(fetch).toHaveBeenCalledTimes(maxRequestAttempts)
+    })
+
+    it.each([10, 7])(
+      'only retries until a successful response is received when maxRequestAttempts is set to %i',
+      async maxRequestAttempts => {
+        const batcher = new HTTPRequestBatcher({ batchSize: 1 })
+        batcher.maxRequestAttempts = maxRequestAttempts
+        for (let x = 0; x < maxRequestAttempts - 3; x++) {
+          fetch.mockImplementationOnce(() => ({ status: 429 }))
+        }
+        fetch.mockResolvedValueOnce({ status: 200 })
+        batcher.addRequest('https://api.example.com')
+
+        await batcher.fetch()
+
+        expect(fetch).toHaveBeenCalledTimes(maxRequestAttempts - 3 + 1)
+      }
+    )
+
+    it('stops retrying requests that received a 429 response once a successful response is received', async () => {
+      const batcher = new HTTPRequestBatcher({ batchSize: 1 })
+      batcher.maxRequestAttempts = 5
+      for (let x = 0; x < 4; x++) {
+        fetch.mockImplementationOnce(() => ({ status: 429 }))
+      }
+      batcher.addRequest('https://api.example.com')
+      await batcher.fetch()
+      expect(fetch).toHaveBeenCalledTimes(5)
+    })
+
     it('retries requests with the same options as the original request', async () => {
       const batcher = new HTTPRequestBatcher({ batchSize: 3 })
       fetch.mockResolvedValueOnce({ status: 200 }).mockResolvedValueOnce({ status: 429 })
@@ -188,7 +268,6 @@ describe('HTTP Request Batcher', () => {
       batcher.addRequest('https://alt-api.example.com', sampleOptions)
       batcher.addRequest('https://api-three.example.com')
       batcher.addRequest('https://api-four.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(fetch).toHaveBeenNthCalledWith(5, 'https://alt-api.example.com', sampleOptions)
     })
@@ -199,7 +278,6 @@ describe('HTTP Request Batcher', () => {
       batcher.addRequest('https://api.example.com')
       batcher.addRequest('https://alt-api.example.com')
       batcher.addRequest('https://api-three.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(batcher.batchSize).toBe(2)
     })
@@ -210,7 +288,6 @@ describe('HTTP Request Batcher', () => {
       batcher.addRequest('https://api.example.com')
       batcher.addRequest('https://alt-api.example.com')
       batcher.addRequest('https://api-three.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(debug).toHaveBeenCalledWith('429 response received for https://api.example.com, reducing batch size to 2')
     })
@@ -221,7 +298,6 @@ describe('HTTP Request Batcher', () => {
       batcher.addRequest('https://api.example.com')
       batcher.addRequest('https://api.example.com')
       batcher.addRequest('https://api.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(debug).toHaveBeenCalledWith(
         'Beginning batched fetch of 4 requests with initial batch size of 3 and delay between batches of 1000ms'
@@ -232,18 +308,54 @@ describe('HTTP Request Batcher', () => {
       const batcher = new HTTPRequestBatcher({ batchSize: 1 })
       fetch.mockImplementationOnce(() => ({ status: 429 }))
       batcher.addRequest('https://api.example.com')
-      global.setTimeout.mockImplementationOnce(cb => cb())
       await batcher.fetch()
       expect(batcher.batchSize).toBe(1)
     })
 
     it('only retry once if a 429 response is received again', async () => {
       const batcher = new HTTPRequestBatcher({ batchSize: 1 })
-      fetch.mockResolvedValueOnce({ status: 429 }).mockResolvedValueOnce({ status: 429 })
       batcher.addRequest('https://api.example.com')
-      global.setTimeout.mockImplementation(cb => cb())
+      fetch.mockResolvedValueOnce({ status: 429 }).mockResolvedValueOnce({ status: 429 })
       await batcher.fetch()
       expect(fetch).toHaveBeenCalledTimes(2)
     })
+
+    it('sends all requests whether or not they fail', async () => {
+      fetch
+        .mockResolvedValueOnce({ ok: true, status: 200, json: () => {} })
+        .mockResolvedValueOnce({ ok: false, status: 500, json: () => {} })
+        .mockRejectedValueOnce(new Error('test event error'))
+        .mockResolvedValueOnce({ ok: true, status: 200, json: () => {} })
+        .mockResolvedValueOnce({ ok: true, status: 200, json: () => {} })
+      const batcher = new HTTPRequestBatcher()
+      batcher.addRequest('https://api.example.com/endpoint-1', { method: 'GET' })
+      batcher.addRequest('https://api.example.com/endpoint-3', { method: 'GET' })
+      batcher.addRequest('https://api.example.com/endpoint-2', { method: 'GET' })
+      batcher.addRequest('https://api.example.com/endpoint-gamma', { method: 'GET' })
+      batcher.addRequest('https://api.example.com/endpoint-alpha', { method: 'GET' })
+
+      await batcher.fetch()
+
+      expect(fetch).toHaveBeenCalledTimes(5)
+      expect(fetch).toHaveBeenNthCalledWith(1, 'https://api.example.com/endpoint-1', { method: 'GET' })
+      expect(fetch).toHaveBeenNthCalledWith(2, 'https://api.example.com/endpoint-3', { method: 'GET' })
+      expect(fetch).toHaveBeenNthCalledWith(3, 'https://api.example.com/endpoint-2', { method: 'GET' })
+      expect(fetch).toHaveBeenNthCalledWith(4, 'https://api.example.com/endpoint-gamma', { method: 'GET' })
+      expect(fetch).toHaveBeenNthCalledWith(5, 'https://api.example.com/endpoint-alpha', { method: 'GET' })
+    })
+
+    it('does not add more than one entry in responseDetails array for the same request when retrying a request', async () => {
+      fetch
+        .mockResolvedValueOnce({ ok: true, status: 200, json: () => {} })
+        .mockResolvedValueOnce({ ok: false, status: 429, json: () => {} })
+      const batcher = new HTTPRequestBatcher()
+      batcher.addRequest('https://api.example.com/endpoint-1', { method: 'GET' })
+      batcher.addRequest('https://api.example.com/endpoint-2', { method: 'GET' })
+
+      await batcher.fetch()
+
+      expect(batcher.responseDetails.length).toBe(2)
+      expect(batcher.responseDetails[0]).not.toBe(batcher.responseDetails[1])
+    })
   })
 })

package/src/govuk-pay-api.js

@@ -32,6 +32,31 @@ export const createRecurringPaymentAgreement = async preparedPayment => {
   }
 }
 
+export const queueRecurringPayment = (preparedPayment, batcher) => {
+  batcher.addRequest(
+    process.env.GOV_PAY_API_URL,
+    {
+      headers: headers(true),
+      method: 'post',
+      body: JSON.stringify(preparedPayment),
+      timeout: process.env.GOV_PAY_REQUEST_TIMEOUT_MS || GOV_PAY_REQUEST_TIMEOUT_MS_DEFAULT
+    },
+    preparedPayment.agreement_id
+  )
+}
+
+export const queueRecurringPaymentStatusCheck = (paymentId, batcher) => {
+  batcher.addRequest(
+    `${process.env.GOV_PAY_API_URL}/${paymentId}`,
+    {
+      headers: headers(true),
+      method: 'get',
+      timeout: process.env.GOV_PAY_REQUEST_TIMEOUT_MS || GOV_PAY_REQUEST_TIMEOUT_MS_DEFAULT
+    },
+    paymentId
+  )
+}
+
 /**
  * Create a new payment
  * @param preparedPayment - see the GOV.UK pay API reference for details

package/src/http-request-batcher.js

@@ -4,10 +4,11 @@ import { StatusCodes } from 'http-status-codes'
 
 const debug = db('connectors:http-request-batcher')
 export default class HTTPRequestBatcher {
+  maxRequestAttempts = 2
   #batchSize
   #delay
   #requests = []
-  #responses = []
+  #responseDetails = []
 
   constructor ({ batchSize = 50, delay = 1000 } = {}) {
     this.#batchSize = batchSize
@@ -22,34 +23,49 @@ export default class HTTPRequestBatcher {
     return this.#requests
   }
 
-  get responses () {
-    return this.#responses
+  get responseDetails () {
+    return this.#responseDetails
   }
 
   get delay () {
     return this.#delay
   }
 
-  addRequest (url, options) {
+  addRequest (url, options, reference = null) {
     if (!url) {
       throw new Error('URL is required')
     }
-    this.#requests.push({ url, options })
+    this.#requests.push({
+      url,
+      options,
+      reference,
+      responses: []
+    })
   }
 
-  async _sendBatch (fetchRequests, sentRequests, requestQueue) {
-    const batchResponses = await Promise.all(fetchRequests)
-    this.#responses.push(...batchResponses)
-    for (let x = 0; x < batchResponses.length; x++) {
-      const response = batchResponses[x]
-      if (response.status === StatusCodes.TOO_MANY_REQUESTS && sentRequests[x].attempts < 2) {
-        requestQueue.push({ ...sentRequests[x], attempts: sentRequests[x].attempts + 1 })
+  async #processBatch (fetchRequests, requestQueue) {
+    for (const fetchRequest of fetchRequests) {
+      const response = await (async () => {
+        try {
+          return await fetchRequest.responsePromise
+        } catch (e) {
+          return e
+        }
+      })()
+      fetchRequest.responses.push(response)
+      if (
+        fetchRequest.responses.at(-1).status === StatusCodes.TOO_MANY_REQUESTS &&
+        fetchRequest.responses.length < this.maxRequestAttempts
+      ) {
+        requestQueue.push(fetchRequest)
         this.#batchSize = Math.max(this.#batchSize - 1, 1)
-        debug(`429 response received for ${sentRequests[x].url}, reducing batch size to ${this.#batchSize}`)
+        debug(`${StatusCodes.TOO_MANY_REQUESTS} response received for ${fetchRequest.url}, reducing batch size to ${this.#batchSize}`)
+      }
+      if (!this.#responseDetails.includes(fetchRequest)) {
+        this.#responseDetails.push(fetchRequest)
       }
     }
     fetchRequests.length = 0
-    sentRequests.length = 0
     if (requestQueue.length) {
       // don't wait if this is the last batch
       await new Promise(resolve => setTimeout(resolve, this.#delay))
@@ -63,14 +79,13 @@ export default class HTTPRequestBatcher {
       } and delay between batches of ${this.#delay}ms`
     )
     const requestQueue = [...this.#requests]
-    const sentRequests = []
     const fetchRequests = []
     while (requestQueue.length) {
       const request = requestQueue.shift()
-      fetchRequests.push(fetch(request.url, request.options))
-      sentRequests.push({ attempts: 1, ...request })
-      if (fetchRequests.length === this.#batchSize) {
-        await this._sendBatch(fetchRequests, sentRequests, requestQueue)
+      request.responsePromise = fetch(request.url, request.options)
+      fetchRequests.push(request)
+      if (fetchRequests.length === this.#batchSize || requestQueue.length === 0) {
+        await this.#processBatch(fetchRequests, requestQueue)
       }
     }
     debug('Batched fetch complete')