@defra-fish/recurring-payments-job 1.62.0-rc.0 → 1.62.0-rc.10

package/README.md

@@ -9,7 +9,7 @@ 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 |                               |                                                                                   |
@@ -22,7 +22,7 @@ When the RP job runs, all RP entries with an nextDueDate of the current date, a
 | 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    |                     |                               |
+| 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.62.0-rc.0",
+  "version": "1.62.0-rc.10",
   "description": "Rod Licensing Recurring Payments Job",
   "type": "module",
   "engines": {
@@ -36,10 +36,11 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.62.0-rc.0",
-    "@defra-fish/connectors-lib": "1.62.0-rc.0",
+    "@defra-fish/business-rules-lib": "1.62.0-rc.10",
+    "@defra-fish/connectors-lib": "1.62.0-rc.10",
     "commander": "^7.2.0",
+    "debug": "^4.3.3",
     "moment-timezone": "^0.5.34"
   },
-  "gitHead": "d56e1a0d0f4b22f1dded800c0ed511b737cb91a7"
+  "gitHead": "7be5ffd5ab38a7b7690cb2b7f7c711c5d8473860"
 }

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

@@ -1,9 +1,23 @@
 import { salesApi } from '@defra-fish/connectors-lib'
+import { PAYMENT_STATUS, PAYMENT_JOURNAL_STATUS_CODES } from '@defra-fish/business-rules-lib'
 import { processRecurringPayments } from '../recurring-payments-processor.js'
-import { getPaymentStatus, sendPayment } from '../services/govuk-pay-service.js'
+import { getPaymentStatus, isGovPayUp, sendPayment } from '../services/govuk-pay-service.js'
 import db from 'debug'
 
-jest.mock('@defra-fish/business-rules-lib')
+jest.mock('@defra-fish/business-rules-lib', () => ({
+  PAYMENT_STATUS: {
+    Success: 'payment status success',
+    Failure: 'payment status failure',
+    Error: 'payment status error'
+  },
+  PAYMENT_JOURNAL_STATUS_CODES: {
+    InProgress: 'in progress payment',
+    Cancelled: 'cancelled payment',
+    Failed: 'failed payment',
+    Expired: 'expired payment',
+    Completed: 'completed payment'
+  }
+}))
 jest.mock('@defra-fish/connectors-lib', () => ({
   salesApi: {
     getDueRecurringPayments: jest.fn(() => []),
@@ -14,18 +28,24 @@ jest.mock('@defra-fish/connectors-lib', () => ({
       id: 'test-transaction-id',
       cost: 30
     })),
-    processRPResult: jest.fn()
+    processRPResult: jest.fn(),
+    updatePaymentJournal: jest.fn(),
+    getPaymentJournal: jest.fn()
   }
 }))
+
 jest.mock('../services/govuk-pay-service.js', () => ({
-  sendPayment: jest.fn(),
-  getPaymentStatus: jest.fn()
+  sendPayment: jest.fn(() => ({ payment_id: 'payment_id', created_date: '2025-07-18T09:00:00.000Z' })),
+  getPaymentStatus: jest.fn(),
+  isGovPayUp: jest.fn(() => true)
 }))
+
 jest.mock('debug', () => jest.fn(() => jest.fn()))
 
-const debugMock = db.mock.results[0].value
 const PAYMENT_STATUS_DELAY = 60000
-const getPaymentStatusSuccess = () => ({ state: { status: 'success' } })
+const getPaymentStatusSuccess = () => ({ state: { status: 'payment status success' } })
+const getPaymentStatusFailure = () => ({ state: { status: 'payment status failure' } })
+const getPaymentStatusError = () => ({ state: { status: 'payment status error' } })
 const getMockPaymentRequestResponse = () => [
   {
     entity: { agreementId: 'agreement-1' },
@@ -39,25 +59,37 @@ const getMockPaymentRequestResponse = () => [
   }
 ]
 
+const getMockDueRecurringPayment = (referenceNumber = '123', agreementId = 'test-agreement-id') => ({
+  entity: { agreementId },
+  expanded: { activePermission: { entity: { referenceNumber } } }
+})
+
 describe('recurring-payments-processor', () => {
+  const [{ value: debugLogger }] = db.mock.results
+
   beforeEach(() => {
     jest.clearAllMocks()
     process.env.RUN_RECURRING_PAYMENTS = 'true'
     global.setTimeout = jest.fn((cb, ms) => cb())
   })
 
-  it('debug displays "Recurring Payments job disabled" when env is false', async () => {
+  it('debug log displays "Recurring Payments job disabled" when env is false', async () => {
     process.env.RUN_RECURRING_PAYMENTS = 'false'
 
     await processRecurringPayments()
 
-    expect(debugMock).toHaveBeenCalledWith('Recurring Payments job disabled')
+    expect(debugLogger).toHaveBeenCalledWith('Recurring Payments job disabled')
   })
 
-  it('debug displays "Recurring Payments job enabled" when env is true', async () => {
+  it('debug log displays "Recurring Payments job enabled" when env is true', async () => {
     await processRecurringPayments()
 
-    expect(debugMock).toHaveBeenCalledWith('Recurring Payments job enabled')
+    expect(debugLogger).toHaveBeenCalledWith('Recurring Payments job enabled')
+  })
+
+  it('throws if Gov.UK Pay is not healthy', async () => {
+    isGovPayUp.mockResolvedValueOnce(false)
+    await expect(() => processRecurringPayments()).rejects.toThrow('Run aborted, Gov.UK Pay health endpoint is reporting problems.')
   })
 
   it('get recurring payments is called when env is true', async () => {
@@ -68,10 +100,143 @@ describe('recurring-payments-processor', () => {
     expect(salesApi.getDueRecurringPayments).toHaveBeenCalledWith(date)
   })
 
-  it('debug displays "Recurring Payments found: " when env is true', async () => {
+  it('debug log displays "Recurring Payments found:" when env is true', async () => {
     await processRecurringPayments()
 
-    expect(debugMock).toHaveBeenCalledWith('Recurring Payments found: ', [])
+    expect(debugLogger).toHaveBeenNthCalledWith(2, 'Recurring Payments found:', [])
+  })
+
+  describe('When RP fetch throws an error...', () => {
+    it('processRecurringPayments re-throws the error', async () => {
+      const error = new Error('Test error')
+      salesApi.getDueRecurringPayments.mockImplementationOnce(() => {
+        throw error
+      })
+
+      await expect(processRecurringPayments()).rejects.toThrowError(error)
+    })
+
+    it('calls console.error with error message', async () => {
+      const errorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
+      const error = new Error('Test error')
+      salesApi.getDueRecurringPayments.mockImplementationOnce(() => {
+        throw error
+      })
+
+      try {
+        await processRecurringPayments()
+      } catch {}
+
+      expect(errorSpy).toHaveBeenCalledWith('Run aborted. Error fetching due recurring payments:', error)
+    })
+  })
+
+  describe('When payment request throws an error...', () => {
+    it('debug is called with error message', async () => {
+      salesApi.getDueRecurringPayments.mockReturnValueOnce(getMockPaymentRequestResponse())
+      const oopsie = new Error('payment gate down')
+      sendPayment.mockRejectedValueOnce(oopsie)
+
+      try {
+        await processRecurringPayments()
+      } catch {}
+
+      expect(debugLogger).toHaveBeenCalledWith(expect.any(String), oopsie)
+    })
+
+    it('prepares and sends all payment requests, even if some fail', async () => {
+      const agreementIds = [Symbol('agreementId1'), Symbol('agreementId2'), Symbol('agreementId3'), Symbol('agreementId4')]
+      salesApi.getDueRecurringPayments.mockReturnValueOnce([
+        getMockDueRecurringPayment('fee', agreementIds[0]),
+        getMockDueRecurringPayment('fi', agreementIds[1]),
+        getMockDueRecurringPayment('foe', agreementIds[2]),
+        getMockDueRecurringPayment('fum', agreementIds[3])
+      ])
+
+      const permissionData = { licensee: { countryCode: 'GB-ENG' } }
+      for (let x = 0; x < agreementIds.length; x++) {
+        salesApi.preparePermissionDataForRenewal.mockReturnValueOnce(permissionData)
+        salesApi.createTransaction.mockReturnValueOnce({
+          cost: 50,
+          id: `transaction-id-${x + 1}`
+        })
+
+        if (x === 1) {
+          const err = new Error('Payment request failed')
+          sendPayment.mockRejectedValueOnce(err)
+        } else {
+          sendPayment.mockResolvedValueOnce({ payment_id: `test-payment-id-${x + 1}`, agreementId: agreementIds[x] })
+        }
+        if (x < 3) {
+          getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess())
+        }
+      }
+      const expectedData = {
+        amount: 5000,
+        description: 'The recurring card payment for your rod fishing licence',
+        reference: 'transactionId',
+        authorisation_mode: 'agreement'
+      }
+
+      await processRecurringPayments()
+
+      expect(sendPayment).toHaveBeenCalledTimes(4)
+      expect(sendPayment).toHaveBeenNthCalledWith(
+        1,
+        expect.objectContaining({ ...expectedData, reference: 'transaction-id-1', agreement_id: agreementIds[0] })
+      )
+      expect(sendPayment).toHaveBeenNthCalledWith(
+        2,
+        expect.objectContaining({ ...expectedData, reference: 'transaction-id-2', agreement_id: agreementIds[1] })
+      )
+      expect(sendPayment).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({ ...expectedData, reference: 'transaction-id-3', agreement_id: agreementIds[2] })
+      )
+      expect(sendPayment).toHaveBeenNthCalledWith(
+        4,
+        expect.objectContaining({ ...expectedData, reference: 'transaction-id-4', agreement_id: agreementIds[3] })
+      )
+    })
+
+    it('logs an error for every failure', async () => {
+      const errors = [new Error('error 1'), new Error('error 2'), new Error('error 3')]
+      salesApi.getDueRecurringPayments.mockReturnValueOnce([
+        getMockDueRecurringPayment('fee', 'a1'),
+        getMockDueRecurringPayment('fi', 'a2'),
+        getMockDueRecurringPayment('foe', 'a3')
+      ])
+      const permissionData = { licensee: { countryCode: 'GB-ENG' } }
+      salesApi.preparePermissionDataForRenewal
+        .mockRejectedValueOnce(errors[0])
+        .mockReturnValueOnce(permissionData)
+        .mockReturnValueOnce(permissionData)
+      salesApi.createTransaction.mockRejectedValueOnce(errors[1]).mockReturnValueOnce({ cost: 50, id: 'transaction-id-3' })
+      sendPayment.mockRejectedValueOnce(errors[2])
+
+      await processRecurringPayments()
+
+      expect(debugLogger).toHaveBeenCalledWith(expect.any(String), ...errors)
+    })
+  })
+
+  describe('When payment status request throws an error...', () => {
+    it('processRecurringPayments requests payment status for all payments, even if some throw errors', async () => {
+      const dueRecurringPayments = []
+      for (let x = 0; x < 6; x++) {
+        dueRecurringPayments.push(getMockDueRecurringPayment())
+        if ([1, 3].includes(x)) {
+          getPaymentStatus.mockRejectedValueOnce(new Error(`status failure ${x}`))
+        } else {
+          getPaymentStatus.mockReturnValueOnce(getPaymentStatusSuccess())
+        }
+      }
+      salesApi.getDueRecurringPayments.mockReturnValueOnce(dueRecurringPayments)
+
+      await processRecurringPayments()
+
+      expect(getPaymentStatus).toHaveBeenCalledTimes(6)
+    })
   })
 
   it('prepares the data for found recurring payments', async () => {
@@ -218,16 +383,6 @@ describe('recurring-payments-processor', () => {
     )
   })
 
-  it('raises an error if createTransaction fails', async () => {
-    salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment()])
-    const error = 'Wuh-oh!'
-    salesApi.createTransaction.mockImplementationOnce(() => {
-      throw new Error(error)
-    })
-
-    await expect(processRecurringPayments()).rejects.toThrowError(error)
-  })
-
   it('prepares and sends the payment request', async () => {
     const agreementId = Symbol('agreementId')
     const transactionId = 'transactionId'
@@ -286,7 +441,7 @@ describe('recurring-payments-processor', () => {
     expect(getPaymentStatus).toHaveBeenCalledWith('test-payment-id')
   })
 
-  it('debug should log payment status for recurring payment', async () => {
+  it('should log payment status for recurring payment', async () => {
     const mockPaymentId = 'test-payment-id'
     const mockResponse = [
       {
@@ -300,48 +455,76 @@ describe('recurring-payments-processor', () => {
         }
       }
     ]
-    const mockStatus = getPaymentStatusSuccess()
     salesApi.getDueRecurringPayments.mockResolvedValueOnce(mockResponse)
     salesApi.createTransaction.mockResolvedValueOnce({
       id: mockPaymentId
     })
     const mockPaymentResponse = { payment_id: mockPaymentId, agreementId: 'agreement-1' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
-    getPaymentStatus.mockResolvedValueOnce(mockStatus)
+    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess())
 
     await processRecurringPayments()
 
-    expect(debugMock).toHaveBeenCalledWith(`Payment status for ${mockPaymentId}: ${mockStatus.state.status}`)
+    console.log(debugLogger.mock.calls)
+    expect(debugLogger).toHaveBeenCalledWith(`Payment status for ${mockPaymentId}: ${PAYMENT_STATUS.Success}`)
   })
 
-  it('debug should inform that the recurring payment has been processed', async () => {
-    const mockTransactionId = 'test-transaction-id'
-    salesApi.createTransaction.mockReturnValueOnce({
-      cost: 50
+  it('logs an error if createTransaction fails', async () => {
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment()])
+    const error = new Error('Wuh-oh!')
+    salesApi.createTransaction.mockImplementationOnce(() => {
+      throw error
     })
+
+    await processRecurringPayments()
+
+    expect(debugLogger).toHaveBeenCalledWith(expect.any(String), error)
+  })
+
+  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'],
+    [499, 'Failed to fetch status for payment test-payment-id, error 499'],
+    [500, 'Payment status API error for test-payment-id, error 500'],
+    [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) => {
+    const mockPaymentId = 'test-payment-id'
     const mockResponse = [
-      {
-        entity: { agreementId: 'agreement-1' },
-        expanded: {
-          activePermission: {
-            entity: {
-              referenceNumber: 'ref-1'
-            }
-          }
-        }
-      }
+      { entity: { agreementId: 'agreement-1' }, expanded: { activePermission: { entity: { referenceNumber: 'ref-1' } } } }
     ]
     salesApi.getDueRecurringPayments.mockResolvedValueOnce(mockResponse)
-    salesApi.createTransaction.mockResolvedValueOnce({
-      id: mockTransactionId
+    salesApi.createTransaction.mockResolvedValueOnce({ id: mockPaymentId })
+    sendPayment.mockResolvedValueOnce({
+      payment_id: mockPaymentId,
+      agreementId: 'agreement-1',
+      created_date: '2025-04-30T12:00:00Z'
+    })
+
+    const apiError = { response: { status: statusCode, data: 'boom' } }
+    getPaymentStatus.mockRejectedValueOnce(apiError)
+
+    await processRecurringPayments()
+
+    expect(debugLogger).toHaveBeenCalledWith(expectedMessage)
+  })
+
+  it('logs the generic unexpected-error message and still rejects', async () => {
+    const mockPaymentId = 'test-payment-id'
+    salesApi.getDueRecurringPayments.mockResolvedValueOnce(getMockPaymentRequestResponse())
+    salesApi.createTransaction.mockResolvedValueOnce({ id: mockPaymentId })
+    sendPayment.mockResolvedValueOnce({
+      payment_id: mockPaymentId,
+      agreementId: 'agreement-1',
+      created_date: '2025-04-30T12:00:00.000Z'
     })
-    const mockPaymentResponse = { payment_id: 'payment-id', agreementId: 'agreement-1' }
-    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
-    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusSuccess())
+
+    const networkError = new Error('network meltdown')
+    getPaymentStatus.mockRejectedValueOnce(networkError)
 
     await processRecurringPayments()
 
-    expect(debugMock).toHaveBeenCalledWith(`Processed Recurring Payment for ${mockTransactionId}`)
+    expect(debugLogger).toHaveBeenCalledWith(`Unexpected error fetching payment status for ${mockPaymentId}.`)
   })
 
   it('should call setTimeout with correct delay when there are recurring payments', async () => {
@@ -369,6 +552,9 @@ describe('recurring-payments-processor', () => {
   })
 
   it('calls processRPResult with transaction id, payment id and created date when payment is successful', async () => {
+    debugLogger.mockImplementation(function () {
+      console.log(...arguments)
+    })
     const mockTransactionId = 'test-transaction-id'
     const mockPaymentId = 'test-payment-id'
     const mockPaymentCreatedDate = '2025-01-01T00:00:00.000Z'
@@ -379,6 +565,7 @@ describe('recurring-payments-processor', () => {
 
     await processRecurringPayments()
 
+    console.log(salesApi.processRPResult.mock.calls, mockTransactionId, mockPaymentId, mockPaymentCreatedDate)
     expect(salesApi.processRPResult).toHaveBeenCalledWith(mockTransactionId, mockPaymentId, mockPaymentCreatedDate)
   })
 
@@ -387,11 +574,69 @@ describe('recurring-payments-processor', () => {
     salesApi.getDueRecurringPayments.mockResolvedValueOnce(getMockPaymentRequestResponse())
     salesApi.createTransaction.mockResolvedValueOnce({ id: mockPaymentId, cost: 30 })
     sendPayment.mockResolvedValueOnce({ payment_id: mockPaymentId, agreementId: 'agreement-1' })
-    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Pending' } })
+    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusFailure())
+
+    await processRecurringPayments()
+
+    expect(salesApi.processRPResult).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    ['agreement-id', getPaymentStatusFailure(), 'failure'],
+    ['test-agreement-id', getPaymentStatusFailure(), 'failure'],
+    ['another-agreement-id', getPaymentStatusFailure(), 'failure'],
+    ['agreement-id', getPaymentStatusError(), 'error'],
+    ['test-agreement-id', getPaymentStatusError(), 'error'],
+    ['another-agreement-id', getPaymentStatusError(), 'error']
+  ])(
+    'console error displays "Payment failed. Recurring payment agreement for: %s set to be cancelled" when payment is a %status',
+    async (agreementId, mockStatus, status) => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
+      salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment('reference', agreementId)])
+      const mockPaymentResponse = { payment_id: 'test-payment-id', created_date: '2025-01-01T00:00:00.000Z' }
+      sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+      getPaymentStatus.mockResolvedValueOnce(mockStatus)
+
+      await processRecurringPayments()
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        `Payment failed. Recurring payment agreement for: ${agreementId} set to be cancelled. Updating payment journal.`
+      )
+    }
+  )
+
+  it('updatePaymentJournal is called with transaction id and failed status code payment is not succesful and payment journal exists', async () => {
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment()])
+    const transactionId = 'test-transaction-id'
+    salesApi.createTransaction.mockReturnValueOnce({
+      cost: 50,
+      id: transactionId
+    })
+    const mockPaymentResponse = { payment_id: 'test-payment-id', created_date: '2025-01-01T00:00:00.000Z' }
+    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusFailure())
+    salesApi.getPaymentJournal.mockResolvedValueOnce(true)
+
+    await processRecurringPayments()
+
+    expect(salesApi.updatePaymentJournal).toHaveBeenCalledWith(transactionId, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Failed })
+  })
+
+  it('updatePaymentJournal is not called when failed status code payment is not succesful but payment journal does not exist', async () => {
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment()])
+    const transactionId = 'test-transaction-id'
+    salesApi.createTransaction.mockReturnValueOnce({
+      cost: 50,
+      id: transactionId
+    })
+    const mockPaymentResponse = { payment_id: 'test-payment-id', created_date: '2025-01-01T00:00:00.000Z' }
+    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce(getPaymentStatusFailure())
+    salesApi.getPaymentJournal.mockResolvedValueOnce(undefined)
 
     await processRecurringPayments()
 
-    expect(salesApi.processRPResult).not.toHaveBeenCalledWith()
+    expect(salesApi.updatePaymentJournal).not.toHaveBeenCalled()
   })
 
   describe.each([2, 3, 10])('if there are %d recurring payments', count => {
@@ -400,7 +645,6 @@ describe('recurring-payments-processor', () => {
       for (let i = 0; i < count; i++) {
         references.push(Symbol('reference' + i))
       }
-
       const mockGetDueRecurringPayments = []
       references.forEach(reference => {
         mockGetDueRecurringPayments.push(getMockDueRecurringPayment(reference))
@@ -511,7 +755,7 @@ describe('recurring-payments-processor', () => {
 
       const permits = []
       for (let i = 0; i < count; i++) {
-        permits.push(`permit${i}`)
+        permits.push(Symbol(`permit${i}`))
       }
 
       permits.forEach((permit, i) => {
@@ -540,8 +784,3 @@ describe('recurring-payments-processor', () => {
     })
   })
 })
-
-const getMockDueRecurringPayment = (referenceNumber = '123', agreementId = 'test-agreement-id') => ({
-  entity: { agreementId },
-  expanded: { activePermission: { entity: { referenceNumber } } }
-})

package/src/recurring-payments-processor.js

@@ -1,64 +1,91 @@
 import moment from 'moment-timezone'
-import { SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
+import { PAYMENT_STATUS, SERVICE_LOCAL_TIME, PAYMENT_JOURNAL_STATUS_CODES } from '@defra-fish/business-rules-lib'
 import { salesApi } from '@defra-fish/connectors-lib'
-import { getPaymentStatus, sendPayment } from './services/govuk-pay-service.js'
+import { getPaymentStatus, sendPayment, isGovPayUp } from './services/govuk-pay-service.js'
 import db from 'debug'
+
 const debug = db('recurring-payments:processor')
 
 const PAYMENT_STATUS_DELAY = 60000
-const payments = []
-const PAYMENT_STATUS_SUCCESS = 'success'
+const MIN_CLIENT_ERROR = 400
+const MAX_CLIENT_ERROR = 499
+const MIN_SERVER_ERROR = 500
+const MAX_SERVER_ERROR = 599
+
+const isClientError = code => code >= MIN_CLIENT_ERROR && code <= MAX_CLIENT_ERROR
+const isServerError = code => code >= MIN_SERVER_ERROR && code <= MAX_SERVER_ERROR
+
+const fetchDueRecurringPayments = async date => {
+  try {
+    const duePayments = await salesApi.getDueRecurringPayments(date)
+    debug('Recurring Payments found:', duePayments)
+    return duePayments
+  } catch (error) {
+    console.error('Run aborted. Error fetching due recurring payments:', error)
+    throw error
+  }
+}
 
 export const processRecurringPayments = async () => {
-  if (process.env.RUN_RECURRING_PAYMENTS?.toLowerCase() === 'true') {
-    debug('Recurring Payments job enabled')
-    const date = new Date().toISOString().split('T')[0]
-    const response = await salesApi.getDueRecurringPayments(date)
-    debug('Recurring Payments found: ', response)
-    await Promise.all(response.map(record => processRecurringPayment(record)))
-    if (response.length > 0) {
-      await new Promise(resolve => setTimeout(resolve, PAYMENT_STATUS_DELAY))
-      await Promise.all(response.map(record => processRecurringPaymentStatus(record)))
-    }
-  } else {
+  if (process.env.RUN_RECURRING_PAYMENTS?.toLowerCase() !== 'true') {
     debug('Recurring Payments job disabled')
+    return
+  }
+
+  if (!(await isGovPayUp())) {
+    debug('Gov.UK Pay reporting unhealthy, aborting run')
+    throw new Error('Run aborted, Gov.UK Pay health endpoint is reporting problems.')
   }
+
+  debug('Recurring Payments job enabled')
+  const date = new Date().toISOString().split('T')[0]
+
+  const dueRCPayments = await fetchDueRecurringPayments(date)
+  if (dueRCPayments.length === 0) {
+    return
+  }
+
+  const payments = await requestPayments(dueRCPayments)
+
+  await new Promise(resolve => setTimeout(resolve, PAYMENT_STATUS_DELAY))
+
+  await Promise.allSettled(payments.map(p => processRecurringPaymentStatus(p)))
+}
+
+const requestPayments = async dueRCPayments => {
+  const paymentRequestResults = await Promise.allSettled(dueRCPayments.map(processRecurringPayment))
+  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)
+  }
+  return payments
 }
 
 const processRecurringPayment = async record => {
   const referenceNumber = record.expanded.activePermission.entity.referenceNumber
   const agreementId = record.entity.agreementId
   const transaction = await createNewTransaction(referenceNumber, agreementId)
-  await takeRecurringPayment(agreementId, transaction)
+  return takeRecurringPayment(agreementId, transaction)
 }
 
 const createNewTransaction = async (referenceNumber, agreementId) => {
   const transactionData = await processPermissionData(referenceNumber, agreementId)
-  debug('Creating new transaction based on: ', referenceNumber, 'with agreementId: ', agreementId)
-  try {
-    const response = await salesApi.createTransaction(transactionData)
-    debug('New transaction created:', response)
-    return response
-  } catch (e) {
-    console.error('Error creating transaction', JSON.stringify(transactionData))
-    throw e
-  }
+  return salesApi.createTransaction(transactionData)
 }
 
 const takeRecurringPayment = async (agreementId, transaction) => {
   const preparedPayment = preparePayment(agreementId, transaction)
-  debug('Requesting payment:', preparedPayment)
   const payment = await sendPayment(preparedPayment)
-  payments.push({
+  return {
     agreementId,
     paymentId: payment.payment_id,
     created_date: payment.created_date,
     transaction
-  })
+  }
 }
 
 const processPermissionData = async (referenceNumber, agreementId) => {
-  debug('Preparing data based on', referenceNumber, 'with agreementId', agreementId)
   const data = await salesApi.preparePermissionDataForRenewal(referenceNumber)
   const licenseeWithoutCountryCode = Object.assign((({ countryCode: _countryCode, ...l }) => l)(data.licensee))
   return {
@@ -100,20 +127,37 @@ const preparePayment = (agreementId, transaction) => {
   return result
 }
 
-const processRecurringPaymentStatus = async record => {
-  const agreementId = record.entity.agreementId
-  const paymentId = getPaymentId(agreementId)
-  const {
-    state: { status }
-  } = await getPaymentStatus(paymentId)
-  debug(`Payment status for ${paymentId}: ${status}`)
-  if (status === PAYMENT_STATUS_SUCCESS) {
-    const payment = payments.find(p => p.paymentId === paymentId)
-    await salesApi.processRPResult(payment.transaction.id, paymentId, payment.created_date)
-    debug(`Processed Recurring Payment for ${payment.transaction.id}`)
-  }
-}
+const processRecurringPaymentStatus = async payment => {
+  try {
+    const {
+      state: { status }
+    } = await getPaymentStatus(payment.paymentId)
+
+    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}`)
+    }
+    if (status === PAYMENT_STATUS.Failure || status === PAYMENT_STATUS.Error) {
+      console.error(
+        `Payment failed. Recurring payment agreement for: ${payment.agreementId} set to be cancelled. Updating payment journal.`
+      )
+      if (await salesApi.getPaymentJournal(payment.transaction.id)) {
+        await salesApi.updatePaymentJournal(payment.transaction.id, {
+          paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Failed
+        })
+      }
+    }
+  } catch (error) {
+    const status = error.response?.status
 
-const getPaymentId = agreementId => {
-  return payments.find(p => p.agreementId === agreementId).paymentId
+    if (isClientError(status)) {
+      debug(`Failed to fetch status for payment ${payment.paymentId}, error ${status}`)
+    } else if (isServerError(status)) {
+      debug(`Payment status API error for ${payment.paymentId}, error ${status}`)
+    } else {
+      debug(`Unexpected error fetching payment status for ${payment.paymentId}.`)
+    }
+  }
 }

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

@@ -1,9 +1,16 @@
-import { getPaymentStatus, sendPayment } from '../govuk-pay-service.js'
+import { getPaymentStatus, sendPayment, isGovPayUp } from '../govuk-pay-service.js'
 import { govUkPayApi } from '@defra-fish/connectors-lib'
+import db from 'debug'
 
 jest.mock('@defra-fish/connectors-lib')
+jest.mock('debug', () => jest.fn(() => jest.fn()))
+const mockDebug = db.mock.results[0].value
 
 describe('govuk-pay-service', () => {
+  it('initialises logger', () => {
+    expect(db).toHaveBeenCalledWith('recurring-payments:gov.uk-pay-service')
+  })
+
   describe('sendPayment', () => {
     const preparedPayment = { id: '1234' }
 
@@ -117,4 +124,34 @@ describe('govuk-pay-service', () => {
       await expect(getPaymentStatus('test-payment-id')).rejects.toThrow('Network error')
     })
   })
+
+  describe('isGovPayUp', () => {
+    it.each([
+      [true, 'true', 'true'],
+      [false, 'true', 'false'],
+      [false, 'false', 'true'],
+      [false, 'false', 'false']
+    ])('resolves to %p if healthy is %s and deadlocks is %s', async (expectedResult, pingHealthy, deadlocksHealthy) => {
+      govUkPayApi.isGovPayUp.mockResolvedValueOnce({
+        ok: true,
+        text: async () => `{"ping":{"healthy":${pingHealthy}},"deadlocks":{"healthy":${deadlocksHealthy}}}`
+      })
+      expect(await isGovPayUp()).toBe(expectedResult)
+    })
+
+    it("resolves to false if we don't receive a 2xx response", async () => {
+      govUkPayApi.isGovPayUp.mockResolvedValueOnce({
+        ok: false
+      })
+      expect(await isGovPayUp()).toBe(false)
+    })
+
+    it("logs if we don't receive a 2xx response", async () => {
+      govUkPayApi.isGovPayUp.mockResolvedValueOnce({
+        ok: false
+      })
+      await isGovPayUp()
+      expect(mockDebug).toHaveBeenCalledWith('Health endpoint unavailable')
+    })
+  })
 })

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

@@ -1,4 +1,6 @@
 import { govUkPayApi } from '@defra-fish/connectors-lib'
+import db from 'debug'
+const debug = db('recurring-payments:gov.uk-pay-service')
 
 export const sendPayment = async preparedPayment => {
   try {
@@ -31,3 +33,13 @@ export const getPaymentStatus = async paymentId => {
     throw error
   }
 }
+
+export const isGovPayUp = async () => {
+  const response = await govUkPayApi.isGovPayUp()
+  if (response.ok) {
+    const isHealthy = JSON.parse(await response.text())
+    return isHealthy.ping.healthy && isHealthy.deadlocks.healthy
+  }
+  debug('Health endpoint unavailable')
+  return false
+}