@defra-fish/gafl-webapp-service 1.55.0 → 1.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/gafl-webapp-service",
-  "version": "1.55.0",
+  "version": "1.56.0",
   "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",
-    "@defra-fish/connectors-lib": "1.55.0",
+    "@defra-fish/business-rules-lib": "1.56.0",
+    "@defra-fish/connectors-lib": "1.56.0",
     "@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": "3405322b81a2016ba22e530de8d096a49be0bea4"
+  "gitHead": "4edcdd349b077ad0bdb3e7b4029df3aba7c04b49"
 }

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/locales/cy.json

@@ -466,11 +466,11 @@
   "licence_type_payment_edge_case": "Mae’n rhaid i chi gwblhau eich taliad cyn 11:30pm ar 31 Mawrth 2024 i dalu’r pris a ddangosir",
   "licence_type_radio_salmon_hint": "Mae'n cynnwys brithyllod a physgod bras (hyd at 3 gwialen)",
   "licence_type_radio_salmon": "Eogiaid a brithyllod y môr",
-  "licence_type_radio_salmon_payment_summary": "eogiaid a brithyllod y môr",
+  "licence_type_radio_salmon_payment_summary": "Eogiaid a brithyllod y môr",
   "licence_type_radio_trout_three_rod": "Brithyllod a physgod bras (hyd at 3 gwialen)",
-  "licence_type_radio_trout_three_rod_payment_summary": "brithyllod a physgod bras (hyd at 3 gwialen)",
+  "licence_type_radio_trout_three_rod_payment_summary": "Brithyllod a physgod bras (hyd at 3 gwialen)",
   "licence_type_radio_trout_two_rod": "Brithyllod a physgod bras (hyd at 2 wialen)",
-  "licence_type_radio_trout_two_rod_payment_summary": "brithyllod a physgod bras (hyd at 2 wialen)",
+  "licence_type_radio_trout_two_rod_payment_summary": "Brithyllod a physgod bras (hyd at 2 wialen)",
   "licence_type_rules": "rheolau pysgota â gwialen (yn agor ar dudalen newydd)",
   "licence_type_salmon_acr_note_1": "Yn ôl y gyfraith, mae'n rhaid i chi roi gwybod am ",
   "licence_type_salmon_acr_note_2": " ffurflen daliadau (yn agor ar dudalen newydd)",

package/src/locales/en.json

@@ -466,11 +466,11 @@
   "licence_type_payment_edge_case": "You must complete payment before 11:30pm on 31 March 2024 to get the price shown",
   "licence_type_radio_salmon_hint": "Includes trout and coarse (up to 3 rods)",
   "licence_type_radio_salmon": "Salmon and sea trout",
-  "licence_type_radio_salmon_payment_summary": "salmon and sea trout",
+  "licence_type_radio_salmon_payment_summary": "Salmon and sea trout",
   "licence_type_radio_trout_three_rod": "Trout and coarse (up to 3 rods)",
-  "licence_type_radio_trout_three_rod_payment_summary": "trout and coarse (up to 3 rods)",
+  "licence_type_radio_trout_three_rod_payment_summary": "Trout and coarse (up to 3 rods)",
   "licence_type_radio_trout_two_rod": "Trout and coarse (up to 2 rods)",
-  "licence_type_radio_trout_two_rod_payment_summary": "trout and coarse (up to 2 rods)",
+  "licence_type_radio_trout_two_rod_payment_summary": "Trout and coarse (up to 2 rods)",
   "licence_type_rules": "rod fishing rules (opens in new tab)",
   "licence_type_salmon_acr_note_1": "Licence holders must by law ",
   "licence_type_salmon_acr_note_2": " report a catch return (opens in new tab)",

package/src/pages/summary/licence-summary/__tests__/__snapshots__/route.spec.js.snap

@@ -246,6 +246,127 @@ Array [
 ]
 `;
 
+exports[`licence-summary > route licence summary rows creates licence summary name rows for 1 year new three rod licence  1`] = `
+Array [
+  Object {
+    "actions": Object {
+      "items": Array [
+        Object {
+          "attributes": Object {
+            "id": "change-name",
+          },
+          "href": "/buy/name",
+          "text": "contact_summary_change",
+          "visuallyHiddenText": "licence_summary_name",
+        },
+      ],
+    },
+    "key": Object {
+      "text": "licence_summary_name",
+    },
+    "value": Object {
+      "html": "Brenin Pysgotwr",
+    },
+  },
+  Object {
+    "actions": Object {
+      "items": Array [
+        Object {
+          "attributes": Object {
+            "id": "change-birth-date",
+          },
+          "href": "/buy/date-of-birth",
+          "text": "contact_summary_change",
+          "visuallyHiddenText": "licence_summary_dob",
+        },
+      ],
+    },
+    "key": Object {
+      "text": "licence_summary_dob",
+    },
+    "value": Object {
+      "html": "1st January 1946",
+    },
+  },
+  Object {
+    "actions": Object {
+      "items": Array [
+        Object {
+          "attributes": Object {
+            "id": "change-licence-type",
+          },
+          "href": "/buy/licence-type",
+          "text": "contact_summary_change",
+          "visuallyHiddenText": "licence_summary_type",
+        },
+      ],
+    },
+    "key": Object {
+      "text": "licence_summary_type",
+    },
+    "value": Object {
+      "html": "Special Canal Licence, Shopping Trollies and Old Wellies",
+    },
+  },
+  Object {
+    "key": Object {
+      "text": "licence_summary_length",
+    },
+    "value": Object {
+      "html": "licence_type_12m",
+    },
+  },
+  Object {
+    "actions": Object {
+      "items": Array [
+        Object {
+          "attributes": Object {
+            "id": "change-licence-to-start",
+          },
+          "href": "/buy/start-kind",
+          "text": "contact_summary_change",
+          "visuallyHiddenText": "licence_summary_start_date",
+        },
+      ],
+    },
+    "key": Object {
+      "text": "licence_summary_start_date",
+    },
+    "value": Object {
+      "html": "30licence_summary_minutes_after_payment",
+    },
+  },
+  Object {
+    "actions": Object {
+      "items": Array [
+        Object {
+          "attributes": Object {
+            "id": "change-benefit-check",
+          },
+          "href": "/buy/disability-concession",
+          "text": "contact_summary_change",
+          "visuallyHiddenText": "licence_summary_ni_num",
+        },
+      ],
+    },
+    "key": Object {
+      "text": "licence_summary_ni_num",
+    },
+    "value": Object {
+      "html": "AB 12 34 56 A",
+    },
+  },
+  Object {
+    "key": Object {
+      "text": "damage",
+    },
+    "value": Object {
+      "html": "#6",
+    },
+  },
+]
+`;
+
 exports[`licence-summary > route licence summary rows creates licence summary name rows for 1 year renewal 1`] = `
 Array [
   Object {

package/src/pages/summary/licence-summary/__tests__/route.spec.js

@@ -116,7 +116,7 @@ const getMockPermission = (licenseeOverrides = {}) => ({
   licenceToStart: 'after-payment',
   licenceStartDate: '2022-11-10',
   licenceType: 'Trout and coarse',
-  numberOfRods: '3',
+  numberOfRods: '2',
   permit: { cost: 6 }
 })
 
@@ -372,16 +372,17 @@ describe('licence-summary > route', () => {
 
   describe('licence summary rows', () => {
     it.each`
-      desc                         | currentPermission
-      ${'1 year renewal'}          | ${getMockPermission()}
-      ${'1 year new licence'}      | ${getMockNewPermission()}
-      ${'1 year senior renewal'}   | ${getMockSeniorPermission()}
-      ${'8 day licence'}           | ${{ ...getMockNewPermission(), licenceLength: '8D' }}
-      ${'1 day licence'}           | ${{ ...getMockNewPermission(), licenceLength: '1D' }}
-      ${'Junior licence'}          | ${getMockJuniorPermission()}
-      ${'Blue badge concession'}   | ${getMockBlueBadgePermission()}
-      ${'Continuing permission'}   | ${getMockContinuingPermission()}
-      ${'Another date permission'} | ${{ ...getMockPermission(), licenceToStart: 'another-date' }}
+      desc                               | currentPermission
+      ${'1 year renewal'}                | ${getMockPermission()}
+      ${'1 year new licence'}            | ${getMockNewPermission()}
+      ${'1 year senior renewal'}         | ${getMockSeniorPermission()}
+      ${'8 day licence'}                 | ${{ ...getMockNewPermission(), licenceLength: '8D' }}
+      ${'1 day licence'}                 | ${{ ...getMockNewPermission(), licenceLength: '1D' }}
+      ${'Junior licence'}                | ${getMockJuniorPermission()}
+      ${'Blue badge concession'}         | ${getMockBlueBadgePermission()}
+      ${'Continuing permission'}         | ${getMockContinuingPermission()}
+      ${'Another date permission'}       | ${{ ...getMockPermission(), licenceToStart: 'another-date' }}
+      ${'1 year new three rod licence '} | ${{ ...getMockNewPermission(), numberOfRods: '3' }}
     `('creates licence summary name rows for $desc', async ({ currentPermission }) => {
       const mockRequest = getMockRequest({ currentPermission })
       const data = await getData(mockRequest)

package/src/pages/summary/licence-summary/route.js

@@ -113,12 +113,13 @@ class RowGenerator {
   }
 
   generateLicenceLengthRow () {
-    return this.generateStandardRow(
-      'licence_summary_length',
-      this.labels[`licence_type_${this.permission.licenceLength.toLowerCase()}`],
-      LICENCE_LENGTH.uri,
-      'change-licence-length'
-    )
+    const args = ['licence_summary_length', this.labels[`licence_type_${this.permission.licenceLength.toLowerCase()}`]]
+
+    if (this.permission.numberOfRods !== '3') {
+      args.push(LICENCE_LENGTH.uri, 'change-licence-length')
+    }
+
+    return this.generateStandardRow(...args)
   }
 }
 

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