@defra-fish/recurring-payments-job 1.64.0-rc.1 → 1.64.0-rc.10

package/README.md

@@ -8,21 +8,13 @@ When the RP job runs, all RP entries with an nextDueDate of the current date, a
 
 # Environment variables
 
-| name                           | description                                                     | required | default             | valid                         | notes                                                                             |
-| ------------------------------ | --------------------------------------------------------------- | :------: | ------------------- | ----------------------------- | --------------------------------------------------------------------------------- | --- |
-| NODE_ENV                       | Node environment                                                |    no    |                     | development, test, production |                                                                                   |
-| RUN_RECURRING_PAYMENTS         | Determine whether to run recurring payments job or not          |   yes    |                     |                               |                                                                                   |
-| SALES_API_URL                  | URL for the sales API                                           |    no    | http://0.0.0.0:4000 |                               |                                                                                   |
-| SALES_API_TIMEOUT_MS           | The timeout in milliseconds requests to the API                 |    no    | 10000               |                               |                                                                                   |
-| OAUTH_AUTHORITY_HOST_URL       | OAuth 2.0 authority host                                        |   yes    |                     |                               |                                                                                   |
-| OAUTH_TENANT                   | OAuth 2.0 tenant                                                |   yes    |                     |                               |                                                                                   |
-| OAUTH_CLIENT_ID                | OAuth 2.0 client ID for client credentials flow                 |   yes    |                     |                               |                                                                                   |
-| OAUTH_CLIENT_SECRET            | OAuth 2.0 client secret for client credentials flow             |   yes    |                     |                               |                                                                                   |
-| OAUTH_SCOPE                    | OAuth 2.0 scope to request (client credentials resource)        |   yes    |                     |                               |                                                                                   |
-| DYNAMICS_API_PATH              | Full URL to the Dynamics API                                    |   yes    |                     |                               | The full URL to the dynamics web api. e.g. https://dynamics-server/api/data/v9.1/ |
-| DYNAMICS_API_VERSION           | The version of the Dynamics API                                 |   yes    |                     |                               | The version of the dynamics web api. e.g. 9.1                                     |
-| 1                              |
-| RECURRING_PAYMENTS_LOCAL_DELAY | Delay for running recurring payments until sales api is running |    no    |                     |                               |                                                                                   |     |
+| name                           | description                                                     | required | default             | valid                         | notes |
+| ------------------------------ | --------------------------------------------------------------- | :------: | ------------------- | ----------------------------- | ----- |
+| NODE_ENV                       | Node environment                                                |    no    |                     | development, test, production |       |
+| RUN_RECURRING_PAYMENTS         | Determine whether to run recurring payments job or not          |   yes    |                     |                               |       |
+| SALES_API_URL                  | URL for the sales API                                           |    no    | http://0.0.0.0:4000 |                               |       |
+| SALES_API_TIMEOUT_MS           | The timeout in milliseconds requests to the API                 |    no    | 10000               |                               |       |
+| RECURRING_PAYMENTS_LOCAL_DELAY | Delay for running recurring payments until sales api is running |    no    |                     |                               |       |
 
 ### See also:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/recurring-payments-job",
-  "version": "1.64.0-rc.1",
+  "version": "1.64.0-rc.10",
   "description": "Rod Licensing Recurring Payments Job",
   "type": "module",
   "engines": {
@@ -36,11 +36,11 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.64.0-rc.1",
-    "@defra-fish/connectors-lib": "1.64.0-rc.1",
-    "commander": "^7.2.0",
-    "debug": "^4.3.3",
-    "moment-timezone": "^0.5.34"
+    "@defra-fish/business-rules-lib": "1.64.0-rc.10",
+    "@defra-fish/connectors-lib": "1.64.0-rc.10",
+    "commander": "7.2.0",
+    "debug": "4.3.3",
+    "moment-timezone": "0.5.34"
   },
-  "gitHead": "2d114ca497f84cd7ede12c2f93965a7044d2f39a"
+  "gitHead": "c70266a7758feee3a9eb9a6b68304d767c4929ce"
 }

package/src/__tests__/recurring-payments-processor.spec.js

@@ -70,6 +70,13 @@ const getMockDueRecurringPayment = ({ agreementId = 'test-agreement-id', id = 'a
   expanded: { activePermission: { entity: { referenceNumber } } }
 })
 
+// eslint-disable-next-line camelcase
+const getMockSendPaymentResponse = ({ payment_id = 'pay-1', agreementId = 'agr-1', created_date = '2025-01-01T00:00:00.000Z' } = {}) => ({
+  payment_id,
+  agreementId,
+  created_date
+})
+
 describe('recurring-payments-processor', () => {
   const [{ value: debugLogger }] = db.mock.results
 
@@ -209,7 +216,8 @@ describe('recurring-payments-processor', () => {
   })
 
   describe('When payment request throws an error...', () => {
-    it('debug is called with error message', async () => {
+    it('console.error is called with error message', async () => {
+      jest.spyOn(console, 'error')
       salesApi.getDueRecurringPayments.mockReturnValueOnce(getMockPaymentRequestResponse())
       const oopsie = new Error('payment gate down')
       sendPayment.mockRejectedValueOnce(oopsie)
@@ -218,7 +226,7 @@ describe('recurring-payments-processor', () => {
         await execute()
       } catch {}
 
-      expect(debugLogger).toHaveBeenCalledWith(expect.any(String), oopsie)
+      expect(console.error).toHaveBeenCalledWith(expect.any(String), oopsie)
     })
 
     it('prepares and sends all payment requests, even if some fail', async () => {
@@ -277,6 +285,7 @@ describe('recurring-payments-processor', () => {
     })
 
     it('logs an error for every failure', async () => {
+      jest.spyOn(console, 'error')
       const errors = [new Error('error 1'), new Error('error 2'), new Error('error 3')]
       salesApi.getDueRecurringPayments.mockReturnValueOnce([
         getMockDueRecurringPayment({ referenceNumber: 'fee', agreementId: 'a1' }),
@@ -293,7 +302,7 @@ describe('recurring-payments-processor', () => {
 
       await execute()
 
-      expect(debugLogger).toHaveBeenCalledWith(expect.any(String), ...errors)
+      expect(console.error).toHaveBeenCalledWith(expect.any(String), ...errors)
     })
   })
 
@@ -577,6 +586,7 @@ describe('recurring-payments-processor', () => {
   })
 
   it('logs an error if createTransaction fails', async () => {
+    jest.spyOn(console, 'error')
     salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment()])
     const error = new Error('Wuh-oh!')
     salesApi.createTransaction.mockImplementationOnce(() => {
@@ -585,9 +595,142 @@ describe('recurring-payments-processor', () => {
 
     await execute()
 
-    expect(debugLogger).toHaveBeenCalledWith(expect.any(String), error)
+    expect(console.error).toHaveBeenCalledWith(expect.any(String), error)
+  })
+
+  // --- //
+
+  it('should log errors from await salesApi.processRPResult', async () => {
+    salesApi.getDueRecurringPayments.mockResolvedValueOnce([getMockDueRecurringPayment()])
+    salesApi.createTransaction.mockResolvedValueOnce({ id: 'trans-1', cost: 30 })
+
+    const payment = getMockSendPaymentResponse()
+    sendPayment.mockResolvedValueOnce(payment)
+
+    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess())
+
+    const boom = new Error('boom')
+
+    salesApi.processRPResult.mockImplementation(transId => (transId === 'trans-1' ? Promise.reject(boom) : Promise.resolve()))
+
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await execute()
+
+    expect(errorSpy).toHaveBeenCalledWith('Failed to process Recurring Payment for trans-1', boom)
+
+    errorSpy.mockRestore()
   })
 
+  describe('handling failures for multiple due payments', () => {
+    beforeEach(() => {
+      salesApi.getDueRecurringPayments.mockResolvedValueOnce([getMockDueRecurringPayment(), getMockDueRecurringPayment()])
+
+      salesApi.preparePermissionDataForRenewal.mockResolvedValueOnce({ licensee: { countryCode: 'GB-ENG' } })
+
+      salesApi.createTransaction.mockResolvedValueOnce({ id: 'trans-1', cost: 30 }).mockResolvedValueOnce({ id: 'trans-2', cost: 30 })
+    })
+
+    it('continues when one sendPayment rejects (Promise.allSettled check)', async () => {
+      const secondPayment = getMockSendPaymentResponse({
+        payment_id: 'test-payment-second',
+        agreementId: 'agr-2',
+        created_date: '2025-01-01T00:00:00.000Z'
+      })
+
+      const gatewayDown = new Error('gateway down')
+      sendPayment.mockRejectedValueOnce(gatewayDown).mockResolvedValueOnce(secondPayment)
+      getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess())
+      salesApi.processRPResult.mockResolvedValueOnce()
+
+      await execute()
+
+      const summary = {
+        statusArgs: getPaymentStatus.mock.calls,
+        rpResultArgs: salesApi.processRPResult.mock.calls
+      }
+
+      expect(summary).toEqual({
+        statusArgs: [[secondPayment.payment_id]],
+        rpResultArgs: [['trans-2', secondPayment.payment_id, secondPayment.created_date]]
+      })
+    })
+
+    it('continues when processRPResult rejects for one payment', async () => {
+      const firstPayment = getMockSendPaymentResponse({
+        payment_id: 'pay-1',
+        agreementId: 'agr-1',
+        created_date: '2025-01-01T00:00:00.000Z'
+      })
+      const secondPayment = getMockSendPaymentResponse({
+        payment_id: 'pay-2',
+        agreementId: 'agr-2',
+        created_date: '2025-01-01T00:01:00.000Z'
+      })
+
+      sendPayment.mockResolvedValueOnce(firstPayment).mockResolvedValueOnce(secondPayment)
+      getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess()).mockResolvedValueOnce(getPaymentStatusSuccess())
+
+      const boom = new Error('boom')
+      salesApi.processRPResult.mockImplementation(transId => (transId === 'trans-1' ? Promise.reject(boom) : Promise.resolve()))
+
+      const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+      await execute()
+
+      const summary = {
+        rpResultArgs: salesApi.processRPResult.mock.calls,
+        rpCount: salesApi.processRPResult.mock.calls.length,
+        firstError: errorSpy.mock.calls[0]
+      }
+
+      errorSpy.mockRestore()
+
+      expect(summary).toEqual({
+        rpResultArgs: expect.arrayContaining([
+          ['trans-1', firstPayment.payment_id, firstPayment.created_date],
+          ['trans-2', secondPayment.payment_id, secondPayment.created_date]
+        ]),
+        rpCount: 2,
+        firstError: ['Failed to process Recurring Payment for trans-1', boom]
+      })
+    })
+
+    it('does not abort when getPaymentStatus rejects for one payment (allSettled at status stage)', async () => {
+      const p1 = getMockSendPaymentResponse({ payment_id: 'pay-1', created_date: '2025-01-01T00:00:00.000Z' })
+      const p2 = getMockSendPaymentResponse({ payment_id: 'pay-2', created_date: '2025-01-01T00:01:00.000Z' })
+
+      sendPayment.mockResolvedValueOnce(p1).mockResolvedValueOnce(p2)
+
+      getPaymentStatus.mockImplementation(async id => {
+        if (id === p1.payment_id) {
+          throw Object.assign(new Error('HTTP 500'), { response: { status: 500, data: 'boom' } })
+        }
+        return getPaymentStatusSuccess()
+      })
+
+      salesApi.processRPResult.mockResolvedValueOnce()
+
+      await execute()
+
+      const summary = {
+        statusArgs: getPaymentStatus.mock.calls,
+        statusCount: getPaymentStatus.mock.calls.length,
+        rpResultArgs: salesApi.processRPResult.mock.calls,
+        rpCount: salesApi.processRPResult.mock.calls.length
+      }
+
+      expect(summary).toEqual({
+        statusArgs: expect.arrayContaining([[p1.payment_id], [p2.payment_id]]),
+        statusCount: 2,
+        rpResultArgs: expect.arrayContaining([['trans-2', p2.payment_id, p2.created_date]]),
+        rpCount: 1
+      })
+    })
+  })
+
+  // --- //
+
   it.each([
     [400, 'Failed to fetch status for payment test-payment-id, error 400'],
     [486, 'Failed to fetch status for payment test-payment-id, error 486'],
@@ -596,6 +739,7 @@ describe('recurring-payments-processor', () => {
     [512, 'Payment status API error for test-payment-id, error 512'],
     [599, 'Payment status API error for test-payment-id, error 599']
   ])('logs the correct message when getPaymentStatus rejects with HTTP %i', async (statusCode, expectedMessage) => {
+    jest.spyOn(console, 'error')
     const mockPaymentId = 'test-payment-id'
     const mockResponse = [
       { entity: { agreementId: 'agreement-1' }, expanded: { activePermission: { entity: { referenceNumber: 'ref-1' } } } }
@@ -613,10 +757,11 @@ describe('recurring-payments-processor', () => {
 
     await execute()
 
-    expect(debugLogger).toHaveBeenCalledWith(expectedMessage)
+    expect(console.error).toHaveBeenCalledWith(expectedMessage)
   })
 
   it('logs the generic unexpected-error message and still rejects', async () => {
+    jest.spyOn(console, 'error')
     const mockPaymentId = 'test-payment-id'
     salesApi.getDueRecurringPayments.mockResolvedValueOnce(getMockPaymentRequestResponse())
     salesApi.createTransaction.mockResolvedValueOnce({ id: mockPaymentId })
@@ -631,7 +776,7 @@ describe('recurring-payments-processor', () => {
 
     await execute()
 
-    expect(debugLogger).toHaveBeenCalledWith(`Unexpected error fetching payment status for ${mockPaymentId}.`)
+    expect(console.error).toHaveBeenCalledWith(`Unexpected error fetching payment status for ${mockPaymentId}.`)
   })
 
   it('should call setTimeout with correct delay when there are recurring payments', async () => {

package/src/recurring-payments-processor.js

@@ -70,7 +70,7 @@ const requestPayments = async dueRCPayments => {
   const payments = paymentRequestResults.filter(prr => prr.status === 'fulfilled').map(p => p.value)
   const failures = paymentRequestResults.filter(prr => prr.status === 'rejected').map(f => f.reason)
   if (failures.length) {
-    debug('Error requesting payments:', ...failures)
+    console.error('Error requesting payments:', ...failures)
   }
   return payments
 }
@@ -155,8 +155,13 @@ const processRecurringPaymentStatus = async payment => {
     debug(`Payment status for ${payment.paymentId}: ${status}`)
 
     if (status === PAYMENT_STATUS.Success) {
-      await salesApi.processRPResult(payment.transaction.id, payment.paymentId, payment.created_date)
-      debug(`Processed Recurring Payment for ${payment.transaction.id}`)
+      try {
+        await salesApi.processRPResult(payment.transaction.id, payment.paymentId, payment.created_date)
+        debug(`Processed Recurring Payment for ${payment.transaction.id}`)
+      } catch (err) {
+        console.error(`Failed to process Recurring Payment for ${payment.transaction.id}`, err)
+        throw err
+      }
     }
     if (status === PAYMENT_STATUS.Failure || status === PAYMENT_STATUS.Error) {
       console.error(
@@ -173,11 +178,11 @@ const processRecurringPaymentStatus = async payment => {
     const status = error.response?.status
 
     if (isClientError(status)) {
-      debug(`Failed to fetch status for payment ${payment.paymentId}, error ${status}`)
+      console.error(`Failed to fetch status for payment ${payment.paymentId}, error ${status}`)
     } else if (isServerError(status)) {
-      debug(`Payment status API error for ${payment.paymentId}, error ${status}`)
+      console.error(`Payment status API error for ${payment.paymentId}, error ${status}`)
     } else {
-      debug(`Unexpected error fetching payment status for ${payment.paymentId}.`)
+      console.error(`Unexpected error fetching payment status for ${payment.paymentId}.`)
     }
   }
 }

package/src/services/__tests__/govuk-pay-service.spec.js

@@ -57,19 +57,6 @@ describe('govuk-pay-service', () => {
       }
     })
 
-    it('should log error message when the GOV.UK Pay API raises an error', async () => {
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
-      govUkPayApi.createPayment.mockImplementationOnce(() => {
-        throw new Error()
-      })
-
-      try {
-        await sendPayment(preparedPayment)
-      } catch (error) {
-        expect(consoleSpy).toHaveBeenCalledWith('Error creating payment', preparedPayment.id)
-      }
-    })
-
     it('should throw an error when response is not ok', async () => {
       const mockFetchResponse = {
         ok: false,
@@ -92,43 +79,6 @@ describe('govuk-pay-service', () => {
         })
       ).rejects.toThrow('Unexpected response from GOV.UK Pay API')
     })
-
-    it('should log details when response is not ok', async () => {
-      const status = 400
-      const serviceResponseBody = {
-        code: 'P0102',
-        field: 'agreement_id',
-        description: 'Invalid attribute value: agreement_id. Agreement does not exist'
-      }
-      const transactionId = 'a50f0d51-295f-42b3-98f8-97c0641ede5a'
-      const preparedPayment = {
-        amount: 100,
-        description: 'The recurring card payment for your rod fishing licence',
-        id: transactionId,
-        authorisation_mode: 'agreement',
-        agreement_id: 'does_not_exist'
-      }
-      govUkPayApi.createPayment.mockResolvedValueOnce({
-        ok: false,
-        status,
-        json: jest.fn().mockResolvedValue(serviceResponseBody)
-      })
-      jest.spyOn(console, 'error')
-
-      try {
-        await sendPayment(preparedPayment)
-      } catch {}
-
-      expect(console.error).toHaveBeenCalledWith(
-        expect.objectContaining({
-          method: 'POST',
-          status,
-          response: serviceResponseBody,
-          transactionId,
-          payload: preparedPayment
-        })
-      )
-    })
   })
 
   describe('getPaymentStatus', () => {

package/src/services/govuk-pay-service.js

@@ -3,24 +3,15 @@ import db from 'debug'
 const debug = db('recurring-payments:gov.uk-pay-service')
 
 export const sendPayment = async preparedPayment => {
-  const createPayment = async () => {
-    try {
-      return await govUkPayApi.createPayment(preparedPayment, true)
-    } catch (e) {
-      console.error('Error creating payment', preparedPayment.id)
-      throw e
-    }
-  }
+  const createPayment = () => govUkPayApi.createPayment(preparedPayment, true)
   const response = await createPayment()
   if (!response.ok) {
-    console.error({
-      method: 'POST',
-      status: response.status,
-      response: await response.json(),
-      transactionId: preparedPayment.id,
-      payload: preparedPayment
-    })
-    throw new Error('Unexpected response from GOV.UK Pay API')
+    throw new Error(`Unexpected response from GOV.UK Pay API. 
+      Status: ${response.status}, 
+      Response: ${JSON.stringify(await response.json())}
+      Transaction ID: ${preparedPayment.id}
+      Payload: ${JSON.stringify(preparedPayment)}
+    `)
   }
   return response.json()
 }