@defra-fish/recurring-payments-job 1.59.0-rc.3 → 1.59.0-rc.4

package/package.json

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

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

@@ -1,6 +1,6 @@
 import { salesApi } from '@defra-fish/connectors-lib'
 import { processRecurringPayments } from '../recurring-payments-processor.js'
-import { sendPayment } from '../services/govuk-pay-service.js'
+import { getPaymentStatus, sendPayment } from '../services/govuk-pay-service.js'
 
 jest.mock('@defra-fish/business-rules-lib')
 jest.mock('@defra-fish/connectors-lib', () => ({
@@ -14,14 +14,19 @@ jest.mock('@defra-fish/connectors-lib', () => ({
     }))
   }
 }))
+
 jest.mock('../services/govuk-pay-service.js', () => ({
-  sendPayment: jest.fn()
+  sendPayment: jest.fn(),
+  getPaymentStatus: jest.fn()
 }))
 
+const PAYMENT_STATUS_DELAY = 60000
+
 describe('recurring-payments-processor', () => {
   beforeEach(() => {
     jest.clearAllMocks()
     process.env.RUN_RECURRING_PAYMENTS = 'true'
+    global.setTimeout = jest.fn((cb, ms) => cb())
   })
 
   it('console log displays "Recurring Payments job disabled" when env is false', async () => {
@@ -62,6 +67,7 @@ describe('recurring-payments-processor', () => {
     salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment(referenceNumber)])
     const mockPaymentResponse = { payment_id: 'test-payment-id' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     await processRecurringPayments()
 
@@ -110,8 +116,9 @@ describe('recurring-payments-processor', () => {
       ]
     }
 
-    const mockPaymentResponse = { payment_id: 'test-payment-id' }
+    const mockPaymentResponse = { payment_id: 'test-payment-id', agreementId: 'test-agreement-id' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     await processRecurringPayments()
 
@@ -136,6 +143,7 @@ describe('recurring-payments-processor', () => {
 
     const mockPaymentResponse = { payment_id: 'test-payment-id' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     await processRecurringPayments()
 
@@ -165,6 +173,7 @@ describe('recurring-payments-processor', () => {
 
     const mockPaymentResponse = { payment_id: 'test-payment-id' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     await processRecurringPayments()
 
@@ -185,6 +194,7 @@ describe('recurring-payments-processor', () => {
 
     const mockPaymentResponse = { payment_id: 'test-payment-id' }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     await processRecurringPayments()
 
@@ -207,7 +217,7 @@ describe('recurring-payments-processor', () => {
 
   it('prepares and sends the payment request', async () => {
     const agreementId = Symbol('agreementId')
-    const transactionId = Symbol('transactionId')
+    const transactionId = 'transactionId'
 
     salesApi.getDueRecurringPayments.mockReturnValueOnce([getMockDueRecurringPayment('foo', agreementId)])
 
@@ -220,8 +230,9 @@ describe('recurring-payments-processor', () => {
       id: transactionId
     })
 
-    const mockPaymentResponse = { payment_id: 'test-payment-id' }
+    const mockPaymentResponse = { payment_id: 'test-payment-id', agreementId }
     sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
 
     const expectedData = {
       amount: 5000,
@@ -236,6 +247,88 @@ describe('recurring-payments-processor', () => {
     expect(sendPayment).toHaveBeenCalledWith(expectedData)
   })
 
+  it('should call getPaymentStatus with payment id', async () => {
+    const mockResponse = [
+      {
+        entity: { agreementId: 'agreement-1' },
+        expanded: {
+          activePermission: {
+            entity: {
+              referenceNumber: 'ref-1'
+            }
+          }
+        }
+      }
+    ]
+    salesApi.getDueRecurringPayments.mockResolvedValue(mockResponse)
+    salesApi.createTransaction.mockResolvedValue({
+      id: 'payment-id-1'
+    })
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
+    const mockPaymentResponse = { payment_id: 'test-payment-id', agreementId: 'agreement-1' }
+    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+
+    await processRecurringPayments()
+    jest.advanceTimersByTime(60000)
+
+    expect(getPaymentStatus).toHaveBeenCalledWith('test-payment-id')
+  })
+
+  it('should log payment status for recurring payment', async () => {
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
+    const mockPaymentId = 'test-payment-id'
+    const mockResponse = [
+      {
+        entity: { agreementId: 'agreement-1' },
+        expanded: {
+          activePermission: {
+            entity: {
+              referenceNumber: 'ref-1'
+            }
+          }
+        }
+      }
+    ]
+    salesApi.getDueRecurringPayments.mockResolvedValue(mockResponse)
+    salesApi.createTransaction.mockResolvedValue({
+      id: mockPaymentId
+    })
+    const mockPaymentResponse = { payment_id: mockPaymentId, agreementId: 'agreement-1' }
+    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    const mockPaymentStatus = { state: { status: 'Success' } }
+    getPaymentStatus.mockResolvedValueOnce(mockPaymentStatus)
+    const mockStatus = JSON.stringify(mockPaymentStatus.state.status)
+
+    await processRecurringPayments()
+    jest.advanceTimersByTime(60000)
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(`Payment status for ${mockPaymentId}: ${mockStatus}`)
+  })
+
+  it('should call setTimeout with correct delay when there are recurring payments', async () => {
+    const referenceNumber = Symbol('reference')
+    salesApi.getDueRecurringPayments.mockResolvedValueOnce([getMockDueRecurringPayment(referenceNumber)])
+    const mockPaymentResponse = { payment_id: 'test-payment-id' }
+    sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+    getPaymentStatus.mockResolvedValueOnce({ state: { status: 'Success' } })
+
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
+
+    await processRecurringPayments()
+
+    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), PAYMENT_STATUS_DELAY)
+  })
+
+  it('should not call setTimeout when there are no recurring payments', async () => {
+    salesApi.getDueRecurringPayments.mockResolvedValueOnce([])
+
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(cb => cb())
+
+    await processRecurringPayments()
+
+    expect(setTimeoutSpy).not.toHaveBeenCalled()
+  })
+
   describe.each([2, 3, 10])('if there are %d recurring payments', count => {
     it('prepares the data for each one', async () => {
       const references = []
@@ -250,6 +343,8 @@ describe('recurring-payments-processor', () => {
       salesApi.getDueRecurringPayments.mockReturnValueOnce(mockGetDueRecurringPayments)
       const mockPaymentResponse = { payment_id: 'test-payment-id' }
       sendPayment.mockResolvedValue(mockPaymentResponse)
+      const mockPaymentStatus = { state: { status: 'Success' } }
+      getPaymentStatus.mockResolvedValue(mockPaymentStatus)
 
       const expectedData = []
       references.forEach(reference => {
@@ -337,10 +432,50 @@ describe('recurring-payments-processor', () => {
       await processRecurringPayments()
       expect(sendPayment.mock.calls).toEqual(expectedData)
     })
+
+    it('gets the payment status for each one', async () => {
+      const mockGetDueRecurringPayments = []
+      const agreementIds = []
+      for (let i = 0; i < count; i++) {
+        const agreementId = Symbol(`agreementId${1}`)
+        agreementIds.push(agreementId)
+        mockGetDueRecurringPayments.push(getMockDueRecurringPayment(i, agreementId))
+      }
+      salesApi.getDueRecurringPayments.mockReturnValueOnce(mockGetDueRecurringPayments)
+
+      const permits = []
+      for (let i = 0; i < count; i++) {
+        permits.push(Symbol(`permit${i}`))
+      }
+
+      permits.forEach((permit, i) => {
+        salesApi.preparePermissionDataForRenewal.mockReturnValueOnce({
+          licensee: { countryCode: 'GB-ENG' }
+        })
+
+        salesApi.createTransaction.mockReturnValueOnce({
+          cost: i,
+          id: permit
+        })
+      })
+
+      const expectedData = []
+      permits.forEach((_, index) => {
+        const paymentId = `payment-id-${index}`
+        expectedData.push(paymentId)
+        const mockPaymentResponse = { payment_id: paymentId }
+        sendPayment.mockResolvedValueOnce(mockPaymentResponse)
+      })
+
+      await processRecurringPayments()
+      expectedData.forEach(paymentId => {
+        expect(getPaymentStatus).toHaveBeenCalledWith(paymentId)
+      })
+    })
   })
 })
 
-const getMockDueRecurringPayment = (referenceNumber = '123', agreementId = '456') => ({
+const getMockDueRecurringPayment = (referenceNumber = '123', agreementId = 'test-agreement-id') => ({
   entity: { agreementId },
   expanded: { activePermission: { entity: { referenceNumber } } }
 })

package/src/recurring-payments-processor.js

@@ -1,8 +1,9 @@
 import moment from 'moment-timezone'
 import { SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
 import { salesApi } from '@defra-fish/connectors-lib'
-import { sendPayment } from './services/govuk-pay-service.js'
+import { getPaymentStatus, sendPayment } from './services/govuk-pay-service.js'
 
+const PAYMENT_STATUS_DELAY = 60000
 const payments = []
 
 export const processRecurringPayments = async () => {
@@ -12,7 +13,10 @@ export const processRecurringPayments = async () => {
     const response = await salesApi.getDueRecurringPayments(date)
     console.log('Recurring Payments found: ', response)
     await Promise.all(response.map(record => processRecurringPayment(record)))
-    console.log('Recurring Payments processed:', payments)
+    if (response.length > 0) {
+      await new Promise(resolve => setTimeout(resolve, PAYMENT_STATUS_DELAY))
+      await Promise.all(response.map(record => processRecurringPaymentStatus(record)))
+    }
   } else {
     console.log('Recurring Payments job disabled')
   }
@@ -89,3 +93,17 @@ 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)
+  console.log(`Payment status for ${paymentId}: ${JSON.stringify(status)}`)
+}
+
+const getPaymentId = agreementId => {
+  const payment = payments.find(p => p.agreementId === agreementId)
+  return payment.paymentId
+}

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

@@ -1,4 +1,4 @@
-import { sendPayment } from '../govuk-pay-service.js'
+import { getPaymentStatus, sendPayment } from '../govuk-pay-service.js'
 import { govUkPayApi } from '@defra-fish/connectors-lib'
 
 jest.mock('@defra-fish/connectors-lib')
@@ -32,7 +32,7 @@ describe('govuk-pay-service', () => {
         description: 'The recurring card payment for your rod fishing licence',
         reference: unique
       }
-      await sendPayment(payload)
+      sendPayment(payload)
       expect(govUkPayApi.createPayment).toHaveBeenCalledWith(payload, true)
     })
 
@@ -61,4 +61,60 @@ describe('govuk-pay-service', () => {
       }
     })
   })
+
+  describe('getPaymentStatus', () => {
+    it('should call fetchPaymentStatus with payment id and true for recurring payments', async () => {
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue({
+        ok: true,
+        json: jest.fn().mockResolvedValue({ code: 'P1234', description: 'Success' })
+      })
+      const paymentId = Symbol('transactionId')
+      await getPaymentStatus(paymentId)
+      expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledWith(paymentId, true)
+    })
+
+    it('should return the payment status on successful response', async () => {
+      const mockPaymentStatus = { code: 'P1234', description: 'Success' }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue({
+        ok: true,
+        json: jest.fn().mockResolvedValue(mockPaymentStatus)
+      })
+      const paymentId = 'valid-payment-id'
+      const result = await getPaymentStatus(paymentId)
+      expect(result).toEqual(mockPaymentStatus)
+    })
+
+    it('should throw an error when payment ID is not provided', async () => {
+      await expect(getPaymentStatus(null)).rejects.toThrow('Invalid payment ID')
+    })
+
+    it('should throw an error when response is not ok', async () => {
+      const mockErrorDetails = { error: 'Payment not found' }
+      const mockFetchResponse = {
+        ok: false,
+        json: jest.fn().mockResolvedValue(mockErrorDetails)
+      }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockFetchResponse)
+
+      await expect(getPaymentStatus('invalid-payment-id')).rejects.toThrow('Payment not found')
+    })
+
+    it('should throw an error when response is not ok but errorDetails has no value', async () => {
+      const mockErrorDetails = {}
+      const mockFetchResponse = {
+        ok: false,
+        json: jest.fn().mockResolvedValue(mockErrorDetails)
+      }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockFetchResponse)
+
+      await expect(getPaymentStatus('invalid-payment-id')).rejects.toThrow('Error fetching payment status')
+    })
+
+    it('should throw an error when fetchPaymentStatus fails', async () => {
+      const mockError = new Error('Network error')
+      govUkPayApi.fetchPaymentStatus.mockRejectedValue(mockError)
+
+      await expect(getPaymentStatus('test-payment-id')).rejects.toThrow('Network error')
+    })
+  })
 })

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

@@ -9,3 +9,25 @@ export const sendPayment = async preparedPayment => {
     throw e
   }
 }
+
+export const getPaymentStatus = async paymentId => {
+  if (!paymentId) {
+    throw new Error('Invalid payment ID')
+  }
+
+  try {
+    const response = await govUkPayApi.fetchPaymentStatus(paymentId, true)
+
+    if (!response.ok) {
+      const errorDetails = await response.json()
+      console.log(errorDetails)
+      throw new Error(errorDetails.error || 'Error fetching payment status')
+    }
+
+    const paymentStatus = await response.json()
+    return paymentStatus
+  } catch (error) {
+    console.error('Error in getPaymentStatus:', error)
+    throw error
+  }
+}