@defra-fish/gafl-webapp-service 1.55.0-rc.3 → 1.55.0-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/gafl-webapp-service",
-  "version": "1.55.0-rc.3",
+  "version": "1.55.0-rc.4",
   "description": "The websales frontend for the GAFL service",
   "type": "module",
   "engines": {
@@ -36,8 +36,8 @@
     "prepare": "gulp --gulpfile build/gulpfile.cjs"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.55.0-rc.3",
-    "@defra-fish/connectors-lib": "1.55.0-rc.3",
+    "@defra-fish/business-rules-lib": "1.55.0-rc.4",
+    "@defra-fish/connectors-lib": "1.55.0-rc.4",
     "@defra/hapi-gapi": "^2.0.0",
     "@hapi/boom": "^9.1.2",
     "@hapi/catbox-redis": "^6.0.2",
@@ -80,5 +80,5 @@
       "./gafl-jest-matchers.js"
     ]
   },
-  "gitHead": "93ee935785b753646c8547323a3faa88f4374dee"
+  "gitHead": "621875e02b13ff01b77fbc16271c15d38f1900f5"
 }

package/src/handlers/__tests__/agreed-handler-recurring-payments.spec.js

@@ -1,8 +1,8 @@
 import { salesApi } from '@defra-fish/connectors-lib'
 import { COMPLETION_STATUS, RECURRING_PAYMENT } from '../../constants.js'
 import agreedHandler from '../agreed-handler.js'
-import { prepareRecurringPayment } from '../../processors/payment.js'
-import { sendRecurringPayment } from '../../services/payment/govuk-pay-service.js'
+import { preparePayment, prepareRecurringPaymentAgreement } from '../../processors/payment.js'
+import { sendPayment, sendRecurringPayment, getPaymentStatus } from '../../services/payment/govuk-pay-service.js'
 import { prepareApiTransactionPayload } from '../../processors/api-transaction.js'
 import { v4 as uuidv4 } from 'uuid'
 import db from 'debug'
@@ -10,7 +10,13 @@ import db from 'debug'
 jest.mock('@defra-fish/connectors-lib')
 jest.mock('../../processors/payment.js')
 jest.mock('../../services/payment/govuk-pay-service.js', () => ({
-  sendPayment: jest.fn(),
+  sendPayment: jest.fn(() => ({
+    payment_id: 'payment-id-1',
+    _links: {
+      next_url: { href: 'next-url' },
+      self: { href: 'self-url' }
+    }
+  })),
   getPaymentStatus: jest.fn(),
   sendRecurringPayment: jest.fn(() => ({ agreementId: 'agr-eem-ent-id1' }))
 }))
@@ -32,12 +38,12 @@ describe('The agreed handler', () => {
   })
   beforeEach(jest.clearAllMocks)
 
-  const getMockRequest = (overrides = {}) => ({
+  const getMockRequest = ({ overrides = {}, transactionSet = () => {} } = {}) => ({
     cache: () => ({
       helpers: {
         transaction: {
           get: async () => ({ cost: 0 }),
-          set: async () => {}
+          set: transactionSet
         },
         status: {
           get: async () => ({
@@ -54,6 +60,7 @@ describe('The agreed handler', () => {
   })
 
   const getRequestToolkit = () => ({
+    redirect: jest.fn(),
     redirectWithLanguageCode: jest.fn()
   })
 
@@ -61,18 +68,20 @@ describe('The agreed handler', () => {
     it('sends the request and transaction to prepare the recurring payment', async () => {
       const transaction = { cost: 0 }
       const mockRequest = getMockRequest({
-        transaction: {
-          get: async () => transaction,
-          set: () => {}
+        overrides: {
+          transaction: {
+            get: async () => transaction,
+            set: () => {}
+          }
         }
       })
       await agreedHandler(mockRequest, getRequestToolkit())
-      expect(prepareRecurringPayment).toHaveBeenCalledWith(mockRequest, transaction)
+      expect(prepareRecurringPaymentAgreement).toHaveBeenCalledWith(mockRequest, transaction)
     })
 
     it('adds a v4 guid to the transaction as an id', async () => {
       let transactionPayload = null
-      prepareRecurringPayment.mockImplementationOnce((_p1, tp) => {
+      prepareRecurringPaymentAgreement.mockImplementationOnce((_p1, tp) => {
         transactionPayload = { ...tp }
       })
       const v4guid = Symbol('v4guid')
@@ -90,46 +99,73 @@ describe('The agreed handler', () => {
       expect(transactionPayload.id).toBe(v4guid)
     })
 
-    it("doesn't overwrite transaction id if one is already set", async () => {
-      const setTransaction = jest.fn()
-      const transactionId = 'abc-123-def-456'
-      uuidv4.mockReturnValue('def-789-ghi-012')
-      salesApi.finaliseTransaction.mockReturnValueOnce({
-        permissions: []
+    it('sends a recurring payment agreement creation request to Gov.UK Pay', async () => {
+      const preparedPayment = Symbol('preparedPayment')
+      prepareRecurringPaymentAgreement.mockResolvedValueOnce(preparedPayment)
+      await agreedHandler(getMockRequest(), getRequestToolkit())
+      expect(sendRecurringPayment).toHaveBeenCalledWith(preparedPayment)
+    })
+
+    describe('when there is a cost and recurringAgreement status is set to true', () => {
+      beforeEach(() => {
+        salesApi.createTransaction.mockResolvedValueOnce({
+          id: 'transaction-id-1',
+          cost: 100
+        })
+      })
+
+      it('calls preparePayment', async () => {
+        const transaction = { id: Symbol('transaction') }
+        const request = getMockRequest({
+          overrides: {
+            transaction: {
+              get: async () => transaction,
+              set: () => {}
+            }
+          }
+        })
+        const toolkit = getRequestToolkit()
+
+        await agreedHandler(request, toolkit)
+        expect(preparePayment).toHaveBeenCalledWith(request, transaction)
+      })
+
+      it('calls sendPayment with recurring as true', async () => {
+        const preparedPayment = Symbol('preparedPayment')
+        preparePayment.mockReturnValueOnce(preparedPayment)
+
+        await agreedHandler(getMockRequest(), getRequestToolkit())
+        expect(sendPayment).toHaveBeenCalledWith(preparedPayment, true)
       })
-      const mockRequest = {
-        cache: () => ({
-          helpers: {
+
+      it('calls getPaymentStatus with recurring as true', async () => {
+        const id = Symbol('paymentId')
+        const transaction = { id: '123', payment: { payment_id: id } }
+        const request = getMockRequest({
+          overrides: {
+            transaction: {
+              get: async () => transaction,
+              set: () => {}
+            },
             status: {
               get: async () => ({
                 [COMPLETION_STATUS.agreed]: true,
-                [COMPLETION_STATUS.posted]: true,
-                [COMPLETION_STATUS.finalised]: false,
-                [RECURRING_PAYMENT]: false
+                [COMPLETION_STATUS.posted]: false,
+                [COMPLETION_STATUS.finalised]: true,
+                [RECURRING_PAYMENT]: true,
+                [COMPLETION_STATUS.paymentCreated]: true
               }),
               set: () => {}
-            },
-            transaction: {
-              get: async () => ({ cost: 0, id: transactionId }),
-              set: setTransaction
             }
           }
         })
-      }
+        const toolkit = getRequestToolkit()
 
-      await agreedHandler(mockRequest, getRequestToolkit())
+        getPaymentStatus.mockReturnValueOnce({ state: { finished: true, status: 'success' } })
 
-      expect(salesApi.finaliseTransaction).toHaveBeenCalledWith(
-        transactionId,
-        undefined // prepareApiFinalisationPayload has no mocked return value
-      )
-    })
-
-    it('sends a recurring payment creation request to Gov.UK Pay', async () => {
-      const preparedPayment = Symbol('preparedPayment')
-      prepareRecurringPayment.mockResolvedValueOnce(preparedPayment)
-      await agreedHandler(getMockRequest(), getRequestToolkit())
-      expect(sendRecurringPayment).toHaveBeenCalledWith(preparedPayment)
+        await agreedHandler(request, toolkit)
+        expect(getPaymentStatus).toHaveBeenCalledWith(id, true)
+      })
     })
 
     // this doesn't really belong here, but until the other agreed handler tests are refactored to
@@ -140,7 +176,7 @@ describe('The agreed handler', () => {
 
       await agreedHandler(getMockRequest(), getRequestToolkit())
 
-      expect(prepareApiTransactionPayload).toHaveBeenCalledWith(expect.any(Object), v4guid)
+      expect(prepareApiTransactionPayload).toHaveBeenCalledWith(expect.any(Object), v4guid, undefined)
     })
 
     it.each(['zxy-098-wvu-765', '467482f1-099d-403d-b6b3-8db7e70d19e3'])(
@@ -158,5 +194,23 @@ describe('The agreed handler', () => {
         expect(debugMock).toHaveBeenCalledWith(`Created agreement with id ${agreement_id}`)
       }
     )
+
+    it.each(['zxy-098-wvu-765', '467482f1-099d-403d-b6b3-8db7e70d19e3'])(
+      "assigns agreement id '%s' to the transaction when recurring payment agreement created",
+      async agreementId => {
+        const mockTransactionCacheSet = jest.fn()
+        sendRecurringPayment.mockResolvedValueOnce({
+          agreement_id: agreementId
+        })
+
+        await agreedHandler(getMockRequest({ transactionSet: mockTransactionCacheSet }), getRequestToolkit())
+
+        expect(mockTransactionCacheSet).toHaveBeenCalledWith(
+          expect.objectContaining({
+            agreementId
+          })
+        )
+      }
+    )
   })
 })

package/src/handlers/agreed-handler.js

@@ -14,7 +14,7 @@ import db from 'debug'
 import { salesApi } from '@defra-fish/connectors-lib'
 import { prepareApiTransactionPayload, prepareApiFinalisationPayload } from '../processors/api-transaction.js'
 import { sendPayment, getPaymentStatus, sendRecurringPayment } from '../services/payment/govuk-pay-service.js'
-import { preparePayment, prepareRecurringPayment } from '../processors/payment.js'
+import { preparePayment, prepareRecurringPaymentAgreement } from '../processors/payment.js'
 import { COMPLETION_STATUS, RECURRING_PAYMENT } from '../constants.js'
 import { ORDER_COMPLETE, PAYMENT_CANCELLED, PAYMENT_FAILED } from '../uri.js'
 import { PAYMENT_JOURNAL_STATUS_CODES, GOVUK_PAY_ERROR_STATUS_CODES } from '@defra-fish/business-rules-lib'
@@ -29,7 +29,7 @@ const debug = db('webapp:agreed-handler')
  * @returns {Promise<*>}
  */
 const sendToSalesApi = async (request, transaction, status) => {
-  const apiTransactionPayload = await prepareApiTransactionPayload(request, transaction.id)
+  const apiTransactionPayload = await prepareApiTransactionPayload(request, transaction.id, transaction.agreementId)
   let response
   try {
     response = await salesApi.createTransaction(apiTransactionPayload)
@@ -63,7 +63,7 @@ const createRecurringPayment = async (request, transaction, status) => {
   /*
    * Prepare the payment payload
    */
-  const preparedPayment = await prepareRecurringPayment(request, transaction)
+  const preparedPayment = await prepareRecurringPaymentAgreement(request, transaction)
 
   /*
    * Send the prepared payment to the GOV.UK pay API using the connector
@@ -72,7 +72,11 @@ const createRecurringPayment = async (request, transaction, status) => {
 
   debug(`Created agreement with id ${paymentResponse.agreement_id}`)
   status[COMPLETION_STATUS.recurringAgreement] = true
+
+  transaction.agreementId = paymentResponse.agreement_id
+
   await request.cache().helpers.status.set(status)
+  await request.cache().helpers.transaction.set(transaction)
 }
 
 /**
@@ -88,6 +92,8 @@ const createRecurringPayment = async (request, transaction, status) => {
  * @returns {Promise<void>}
  */
 const createPayment = async (request, transaction, status) => {
+  const recurring = status && status[COMPLETION_STATUS.recurringAgreement] === true
+
   /*
    * Prepare the payment payload
    */
@@ -96,7 +102,7 @@ const createPayment = async (request, transaction, status) => {
   /*
    * Send the prepared payment to the GOV.UK pay API using the connector
    */
-  const paymentResponse = await sendPayment(preparedPayment)
+  const paymentResponse = await sendPayment(preparedPayment, recurring)
 
   /*
    * Used by the payment mop up job, create the payment journal entry which is removed when the user completes the journey
@@ -143,10 +149,12 @@ const createPayment = async (request, transaction, status) => {
  * @returns {Promise<void>}
  */
 const processPayment = async (request, transaction, status) => {
+  const recurring = status && status[COMPLETION_STATUS.recurringAgreement] === true
+
   /*
    * Get the payment status
    */
-  const { state } = await getPaymentStatus(transaction.payment.payment_id)
+  const { state } = await getPaymentStatus(transaction.payment.payment_id, recurring)
 
   if (!state.finished) {
     throw Boom.forbidden('Attempt to access the agreed handler during payment journey')

package/src/processors/__tests__/api-transaction.spec.js

@@ -63,7 +63,7 @@ describe('prepareApiTransactionPayload', () => {
     })
   })
 
-  it('adds transaction id to payload', async () => {
+  it('adds transactionId to payload', async () => {
     const transactionId = Symbol('transactionId')
 
     const payload = await prepareApiTransactionPayload(getMockRequest(), transactionId)
@@ -71,6 +71,14 @@ describe('prepareApiTransactionPayload', () => {
     expect(payload.transactionId).toBe(transactionId)
   })
 
+  it('adds agreementId to payload', async () => {
+    const agreementId = Symbol('agreementId')
+
+    const payload = await prepareApiTransactionPayload(getMockRequest(), 'transaction_id', agreementId)
+
+    expect(payload.agreementId).toBe(agreementId)
+  })
+
   const getMockRequest = (overrides = {}, state = {}) => ({
     cache: () => ({
       helpers: {

package/src/processors/__tests__/payment.spec.js

@@ -1,4 +1,4 @@
-import { preparePayment, prepareRecurringPayment } from '../payment.js'
+import { preparePayment, prepareRecurringPaymentAgreement } from '../payment.js'
 import { licenceTypeAndLengthDisplay } from '../licence-type-display.js'
 import { addLanguageCodeToUri } from '../uri-helper.js'
 import { AGREED } from '../../uri.js'
@@ -20,9 +20,16 @@ const createRequest = (opts = {}, catalog = {}) => ({
   server: { info: { protocol: opts.protocol || '' } }
 })
 
-const createTransaction = ({ isLicenceForYou = true, additionalPermissions = [], cost = 12, licenseeOverrides = {} } = {}) => ({
+const createTransaction = ({
+  isLicenceForYou = true,
+  additionalPermissions = [],
+  cost = 12,
+  licenseeOverrides = {},
+  agreementId
+} = {}) => ({
   id: 'transaction-id',
   cost,
+  agreementId,
   permissions: [
     {
       id: 'permission-id',
@@ -49,7 +56,7 @@ describe('preparePayment', () => {
     it.each(['http', 'https'])('uses SSL when "x-forwarded-proto" header is present, proto "%s"', proto => {
       addLanguageCodeToUri.mockReturnValue(proto + '://localhost:1234/buy/agreed')
       const request = createRequest({ headers: { 'x-forwarded-proto': proto } })
-      const result = preparePayment(request, createTransaction())
+      const result = preparePayment(request, createTransaction(), false)
 
       expect(result.return_url).toBe(`${proto}://localhost:1234/buy/agreed`)
     })
@@ -211,12 +218,30 @@ describe('preparePayment', () => {
       expect(result.email).toBe(undefined)
     })
   })
+
+  describe('if agreementId is not present', () => {
+    it('does not include set_up_agreement', () => {
+      const result = preparePayment(createRequest(), createTransaction())
+      expect(result.set_up_agreement).toBe(undefined)
+    })
+  })
+
+  describe('if agreementId is present', () => {
+    it('set_up_agreement is set to agreementId', () => {
+      const agreementId = 'foo'
+      const recurringPaymentTransaction = createTransaction({ agreementId })
+
+      const result = preparePayment(createRequest(), recurringPaymentTransaction)
+
+      expect(result.set_up_agreement).toBe(agreementId)
+    })
+  })
 })
 
-describe('prepareRecurringPayment', () => {
+describe('prepareRecurringPaymentAgreement', () => {
   it('reference equals transaction.id', async () => {
     const transaction = createTransaction()
-    const result = await prepareRecurringPayment(createRequest(), transaction)
+    const result = await prepareRecurringPaymentAgreement(createRequest(), transaction)
     expect(result.reference).toBe(transaction.id)
   })
 
@@ -227,7 +252,7 @@ describe('prepareRecurringPayment', () => {
     const request = createRequest({}, mockCatalog)
     const transaction = createTransaction()
 
-    const result = await prepareRecurringPayment(request, transaction)
+    const result = await prepareRecurringPaymentAgreement(request, transaction)
     expect(result.description).toBe(mockCatalog.recurring_payment_description)
   })
 
@@ -235,7 +260,7 @@ describe('prepareRecurringPayment', () => {
     const transaction = createTransaction()
     const request = createRequest()
 
-    const result = await prepareRecurringPayment(request, transaction)
-    expect(debug).toHaveBeenCalledWith('Creating prepared recurring payment %o', result)
+    const result = await prepareRecurringPaymentAgreement(request, transaction)
+    expect(debug).toHaveBeenCalledWith('Creating prepared recurring payment agreement %o', result)
   })
 })

package/src/processors/api-transaction.js

@@ -7,7 +7,7 @@ import { countries } from './refdata-helper.js'
 import { salesApi } from '@defra-fish/connectors-lib'
 import { licenceToStart } from '../pages/licence-details/licence-to-start/update-transaction.js'
 
-export const prepareApiTransactionPayload = async (request, transactionId) => {
+export const prepareApiTransactionPayload = async (request, transactionId, agreementId) => {
   const transactionCache = await request.cache().helpers.transaction.get()
   const concessions = await salesApi.concessions.getAll()
   const countryList = await countries.getAll()
@@ -63,7 +63,8 @@ export const prepareApiTransactionPayload = async (request, transactionId) => {
       request.state && request.state[process.env.OIDC_SESSION_COOKIE_NAME]
         ? request.state[process.env.OIDC_SESSION_COOKIE_NAME].oid
         : undefined,
-    transactionId
+    transactionId,
+    agreementId
   }
 }
 

package/src/processors/payment.js

@@ -50,17 +50,21 @@ export const preparePayment = (request, transaction) => {
     }
   }
 
+  if (transaction.agreementId) {
+    result.set_up_agreement = transaction.agreementId
+  }
+
   debug('Creating prepared payment %o', result)
   return result
 }
 
-export const prepareRecurringPayment = async (request, transaction) => {
+export const prepareRecurringPaymentAgreement = async (request, transaction) => {
   debug('Preparing recurring payment %s', JSON.stringify(transaction, undefined, '\t'))
-  // The recurring card payment for your rod fishing licence
+  // The recurring card payment agreement for your rod fishing licence
   const result = {
     reference: transaction.id,
     description: request.i18n.getCatalog().recurring_payment_description
   }
-  debug('Creating prepared recurring payment %o', result)
+  debug('Creating prepared recurring payment agreement %o', result)
   return result
 }

package/src/services/payment/__test__/govuk-pay-service.spec.js

@@ -2,7 +2,7 @@ import mockTransaction from './data/mock-transaction.js'
 import { preparePayment } from '../../../processors/payment.js'
 import { AGREED } from '../../../uri.js'
 import { addLanguageCodeToUri } from '../../../processors/uri-helper.js'
-import { sendRecurringPayment } from '../govuk-pay-service.js'
+import { sendPayment, sendRecurringPayment, getPaymentStatus } from '../govuk-pay-service.js'
 import { govUkPayApi } from '@defra-fish/connectors-lib'
 import db from 'debug'
 const { value: debug } = db.mock.results[db.mock.calls.findIndex(c => c[0] === 'webapp:govuk-pay-service')]
@@ -158,6 +158,142 @@ describe('The govuk-pay-service', () => {
     console.log(preparedPayment)
   })
 
+  describe('sendPayment', () => {
+    const preparedPayment = {
+      id: '1234',
+      user_identifier: 'test-user'
+    }
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it.each([
+      [true, true],
+      [false, false],
+      [false, undefined]
+    ])('should call the govUkPayApi with recurring as %s if the argument is %s', async (expected, value) => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
+      }
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+      const unique = Symbol('payload')
+      const payload = { unique }
+      await sendPayment(payload, value)
+      expect(govUkPayApi.createPayment).toHaveBeenCalledWith(payload, expected)
+    })
+
+    it('should send provided payload data to Gov.UK Pay', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
+      }
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+      const unique = Symbol('payload')
+      const payload = {
+        reference: 'd81f1a2b-6508-468f-8342-b6770f60f7cd',
+        description: 'Fishing permission',
+        user_identifier: '1218c1c5-38e4-4bf3-81ea-9cbce3994d30',
+        unique
+      }
+      await sendPayment(payload)
+      expect(govUkPayApi.createPayment).toHaveBeenCalledWith(payload, false)
+    })
+
+    it('should return response body when payment creation is successful', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
+      }
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+
+      const result = await sendPayment(preparedPayment)
+
+      expect(result).toEqual({ success: true, paymentId: 'abc123' })
+    })
+
+    it('should log debug message when response.ok is true', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
+      }
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+
+      await sendPayment(preparedPayment)
+
+      expect(debug).toHaveBeenCalledWith('Successful payment creation response: %o', { success: true, paymentId: 'abc123' })
+    })
+
+    it('should log error message when response.ok is false', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        json: jest.fn().mockResolvedValue({ message: 'Server error' })
+      }
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+
+      try {
+        await sendPayment(preparedPayment)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Failure creating payment in the GOV.UK API service', {
+          transactionId: preparedPayment.id,
+          method: 'POST',
+          payload: preparedPayment,
+          status: mockResponse.status,
+          response: { message: 'Server error' }
+        })
+      }
+    })
+
+    it('should throw error when API call fails with network issue', async () => {
+      const mockError = new Error('Network error')
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
+      govUkPayApi.createPayment.mockRejectedValue(mockError)
+
+      try {
+        await sendPayment(preparedPayment)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+          `Error creating payment in the GOV.UK API service - tid: ${preparedPayment.id}`,
+          mockError
+        )
+      }
+    })
+
+    it('should throw error for when rate limit is breached', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 429,
+        json: jest.fn().mockResolvedValue({ message: 'Rate limit exceeded' })
+      }
+      const consoleErrorSpy = jest.spyOn(console, 'info').mockImplementation(jest.fn())
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+
+      try {
+        await sendPayment(preparedPayment)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith(`GOV.UK Pay API rate limit breach - tid: ${preparedPayment.id}`)
+      }
+    })
+
+    it('should throw error for unexpected response status', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        json: jest.fn().mockResolvedValue({ message: 'Server error' })
+      }
+      govUkPayApi.createPayment.mockResolvedValue(mockResponse)
+
+      try {
+        await sendPayment(preparedPayment)
+      } catch (error) {
+        expect(error.message).toBe('Unexpected response from GOV.UK pay API')
+      }
+    })
+  })
+
   describe('sendRecurringPayment', () => {
     const preparedPayment = {
       id: '1234',
@@ -277,4 +413,120 @@ describe('The govuk-pay-service', () => {
       }
     })
   })
+
+  describe('getPaymentStatus', () => {
+    const paymentId = '1234'
+
+    beforeEach(() => {
+      jest.clearAllMocks()
+    })
+
+    it.each([
+      [true, true],
+      [false, false],
+      [false, undefined]
+    ])('should call the govUkPayApi with recurring as %s if the argument is %s', async (expected, value) => {
+      const mockResponse = { ok: true, status: 200, json: () => {} }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+      await getPaymentStatus(paymentId, value)
+      expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledWith(paymentId, expected)
+    })
+
+    it('should send provided paymentId to Gov.UK Pay', async () => {
+      const mockResponse = { ok: true, status: 200, json: () => {} }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+      await getPaymentStatus(paymentId)
+      expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledWith(paymentId, false)
+    })
+
+    it('should return response body when payment status check is successful', async () => {
+      const resBody = Symbol('body')
+      const mockResponse = { ok: true, status: 200, json: jest.fn().mockResolvedValue(resBody) }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+
+      const result = await getPaymentStatus(paymentId)
+
+      expect(result).toEqual(resBody)
+    })
+
+    it('should log debug message when response.ok is true', async () => {
+      const resBody = Symbol('body')
+      const mockResponse = { ok: true, status: 200, json: jest.fn().mockResolvedValue(resBody) }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+
+      await getPaymentStatus(paymentId)
+
+      expect(debug).toHaveBeenCalledWith('Payment status response: %o', resBody)
+    })
+
+    it('should log error message when response.ok is false', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        json: jest.fn().mockResolvedValue({ message: 'Server error' })
+      }
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+
+      try {
+        await getPaymentStatus(paymentId)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+          `Error retrieving the payment status from the GOV.UK API service - tid: ${paymentId}`,
+          {
+            method: 'GET',
+            paymentId: paymentId,
+            status: mockResponse.status,
+            response: { message: 'Server error' }
+          }
+        )
+      }
+    })
+
+    it('should throw error when API call fails with network issue', async () => {
+      const mockError = new Error('Network error')
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
+      govUkPayApi.fetchPaymentStatus.mockRejectedValue(mockError)
+
+      try {
+        await getPaymentStatus(paymentId)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith(
+          `Error retrieving the payment status from the GOV.UK API service - paymentId: ${paymentId}`,
+          mockError
+        )
+      }
+    })
+
+    it('should throw error for when rate limit is breached', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 429,
+        json: jest.fn().mockResolvedValue({ message: 'Rate limit exceeded' })
+      }
+      const consoleErrorSpy = jest.spyOn(console, 'info').mockImplementation(jest.fn())
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+
+      try {
+        await getPaymentStatus(paymentId)
+      } catch (error) {
+        expect(consoleErrorSpy).toHaveBeenCalledWith(`GOV.UK Pay API rate limit breach - paymentId: ${paymentId}`)
+      }
+    })
+
+    it('should throw error for unexpected response status', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        json: jest.fn().mockResolvedValue({ message: 'Server error' })
+      }
+      govUkPayApi.fetchPaymentStatus.mockResolvedValue(mockResponse)
+
+      try {
+        await getPaymentStatus(paymentId)
+      } catch (error) {
+        expect(error.message).toBe('Unexpected response from GOV.UK pay API')
+      }
+    })
+  })
 })

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

@@ -46,10 +46,10 @@ const getTransactionErrorMessage = async (transactionId, payload, response) => (
  * @param preparedPayment - the prepared payload for the payment. See in processors/payment.js
  * @returns {Promise<*>}
  */
-export const sendPayment = async preparedPayment => {
+export const sendPayment = async (preparedPayment, recurring = false) => {
   let response
   try {
-    response = await govUkPayApi.createPayment(preparedPayment)
+    response = await govUkPayApi.createPayment(preparedPayment, recurring)
   } catch (err) {
     /*
      * Potentially errors caught here (unreachable, timeouts) may be retried - set origin on the error to indicate
@@ -78,11 +78,11 @@ export const sendPayment = async preparedPayment => {
  * @param paymentId - the paymentId
  * @returns {Promise<any>}
  */
-export const getPaymentStatus = async paymentId => {
+export const getPaymentStatus = async (paymentId, recurring = false) => {
   debug(`Get payment status for paymentId: ${paymentId}`)
   let response
   try {
-    response = await govUkPayApi.fetchPaymentStatus(paymentId)
+    response = await govUkPayApi.fetchPaymentStatus(paymentId, recurring)
   } catch (err) {
     /*
      * Errors caught here (unreachable, timeouts) may be retried - set origin on the error to indicate