@defra-fish/gafl-webapp-service 1.64.0-rc.8 → 1.65.0-rc.0

package/src/pages/recurring-payments/cancel/identify/__tests__/route.spec.js

@@ -0,0 +1,174 @@
+import pageRoute from '../../../../../routes/page-route.js'
+import { CANCEL_RP_IDENTIFY } from '../../../../../uri.js'
+import { addLanguageCodeToUri } from '../../../../../processors/uri-helper.js'
+import { getData, validator } from '../route.js'
+import { dateOfBirthValidator, getDateErrorFlags } from '../../../../../schema/validators/validators.js'
+import { validation } from '@defra-fish/business-rules-lib'
+import GetDataRedirect from '../../../../../handlers/get-data-redirect.js'
+
+require('../route.js')
+
+jest.mock('../../../../../routes/page-route.js')
+jest.mock('../../../../../uri.js', () => ({
+  ...jest.requireActual('../../../../../uri.js'),
+  CANCEL_RP_IDENTIFY: { page: 'cancel-rp identify page', uri: Symbol('cancel-rp identify uri') },
+  CANCEL_RP_AUTHENTICATE: { uri: 'cancel-rp-authenticate uri' }
+}))
+jest.mock('../../../../../processors/uri-helper.js')
+jest.mock('../../../../../schema/validators/validators.js')
+
+describe('cancel recurring payment identify route', () => {
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('getData', () => {
+    const getMockRequest = (referenceNumber, pageGet = async () => ({})) => ({
+      cache: () => ({
+        helpers: {
+          transaction: {
+            getCurrentPermission: () => ({
+              referenceNumber
+            }),
+            setCurrentPermission: jest.fn()
+          },
+          page: {
+            getCurrentPermission: pageGet
+          }
+        }
+      }),
+      i18n: {
+        getCatalog: () => [],
+        getLocales: () => []
+      }
+    })
+
+    it('passes correct page name when getting page cache', async () => {
+      const pageGet = jest.fn(() => ({}))
+      await getData(getMockRequest(undefined, pageGet))
+      expect(pageGet).toHaveBeenCalledWith(CANCEL_RP_IDENTIFY.page)
+    })
+
+    it.each([['09F6VF'], ['013AH6'], ['LK563F']])('returns referenceNumber when permission includes %s', async referenceNumber => {
+      const result = await getData(getMockRequest(referenceNumber))
+      expect(result.referenceNumber).toEqual(referenceNumber)
+    })
+
+    it('throws redirect when permission number fails validation', async () => {
+      const spy = jest
+        .spyOn(validation.permission, 'permissionNumberUniqueComponentValidator')
+        .mockReturnValue({ validate: () => ({ error: true }) })
+      const request = getMockRequest('BAD123')
+      request.cache().helpers.transaction.setCurrentPermission = jest.fn()
+      await expect(getData(request)).rejects.toBeInstanceOf(GetDataRedirect)
+      spy.mockRestore()
+    })
+
+    it('adds return value of getErrorFlags to the page data', async () => {
+      const errorFlags = { unique: Symbol('error-flags') }
+      getDateErrorFlags.mockReturnValueOnce(errorFlags)
+      const result = await getData(getMockRequest())
+      expect(result).toEqual(expect.objectContaining(errorFlags))
+    })
+
+    it('passes error to getErrorFlags', async () => {
+      const error = Symbol('error')
+      await getData(getMockRequest(undefined, async () => ({ error })))
+      expect(getDateErrorFlags).toHaveBeenCalledWith(error)
+    })
+
+    it.each([
+      ['full-date', 'object.missing'],
+      ['day', 'any.required']
+    ])('adds error details (%s: %s) to the page data', async (errorKey, errorValue) => {
+      const pageGet = async () => ({
+        error: { [errorKey]: errorValue }
+      })
+      const result = await getData(getMockRequest(undefined, pageGet))
+      expect(result.error).toEqual({ errorKey, errorValue })
+    })
+
+    it('omits error if there is no error', async () => {
+      const result = await getData(getMockRequest())
+      expect(result.error).toBeUndefined()
+    })
+  })
+
+  describe('pageRoute', () => {
+    it('passes CANCEL_RP_IDENTIFY.page as the first argument to pageRoute', () => {
+      expect(pageRoute.mock.calls[0][0]).toBe(CANCEL_RP_IDENTIFY.page)
+    })
+
+    it('passes CANCEL_RP_IDENTIFY.uri as the second argument to pageRoute', () => {
+      expect(pageRoute.mock.calls[0][1]).toBe(CANCEL_RP_IDENTIFY.uri)
+    })
+
+    it('calls pageRoute with validator, nextPage function, and getData', () => {
+      expect(pageRoute).toBeCalledWith(CANCEL_RP_IDENTIFY.page, CANCEL_RP_IDENTIFY.uri, validator, expect.any(Function), getData)
+    })
+  })
+
+  describe('page route next', () => {
+    const getNextPage = () => pageRoute.mock.calls[0][3]
+
+    it('passes a function', () => {
+      const nextPage = getNextPage()
+      expect(typeof nextPage).toBe('function')
+    })
+
+    it('calls addLanguageCodeToUri', () => {
+      const nextPage = getNextPage()
+      nextPage()
+      expect(addLanguageCodeToUri).toHaveBeenCalled()
+    })
+
+    it('passes request to addLanguageCodeToUri', () => {
+      const request = Symbol('request')
+      const nextPage = getNextPage()
+      nextPage(request)
+      expect(addLanguageCodeToUri).toHaveBeenCalledWith(request, expect.anything())
+    })
+
+    it('returns result of addLanguageCodeToUri', () => {
+      const expectedResult = Symbol('add language code to uri')
+      const nextPage = getNextPage()
+      addLanguageCodeToUri.mockReturnValueOnce(expectedResult)
+      expect(nextPage()).toBe(expectedResult)
+    })
+  })
+
+  describe('validator', () => {
+    const getMockPayload = (postcode = 'AA1 1AA', referenceNumber = 'A1B2C3') => ({
+      postcode,
+      referenceNumber
+    })
+
+    it('fails if dateOfBirthValidator throws', () => {
+      const expectedError = new Error('expected error')
+      dateOfBirthValidator.mockImplementationOnce(() => {
+        throw expectedError
+      })
+      expect(() => validator(getMockPayload())).toThrow(expectedError)
+    })
+
+    it('passes if dateOfBirthValidator succeeds', () => {
+      expect(() => validator(getMockPayload())).not.toThrow()
+    })
+
+    it('passes payload to dateOfBirthValidator', () => {
+      const p = getMockPayload()
+      validator(p)
+      expect(dateOfBirthValidator).toHaveBeenCalledWith(p)
+    })
+
+    it('fails if permission number is invalid', () => {
+      jest.spyOn(validation.permission, 'permissionNumberUniqueComponentValidator').mockReturnValue({ validate: () => ({ error: 'bad' }) })
+      expect(() => validator({ referenceNumber: 'BAD', postcode: 'AA1 1AA' })).toThrow()
+    })
+
+    it('fails if postcode is invalid', () => {
+      jest.spyOn(validation.contact, 'createOverseasPostcodeValidator').mockReturnValue({ validate: () => ({ error: 'bad' }) })
+      expect(() => validator({ referenceNumber: 'ABC123', postcode: 'ZZZ' })).toThrow()
+    })
+  })
+})

package/src/pages/recurring-payments/cancel/identify/cancel-rp-identify.njk

@@ -1,15 +1,175 @@
 {% extends "layout.njk" %}
 
+{% from "fieldset/macro.njk" import govukFieldset %}
 {% from "button/macro.njk" import govukButton %}
 {% from "page-title.njk" import pageTitle %}
+{% from "date-input/macro.njk" import govukDateInput %}
+{% from "input/macro.njk" import govukInput %}
+{% from "error-summary.njk" import errorSummary %}
+
+{% set title = mssgs.cancel_rp_identify_title %}
 
-{% set title = mssgs.rp_cancel_identify_title %}
 {% block pageTitle %}{{ pageTitle(title, error, mssgs) }}{% endblock %}
 
+{%
+    set errorMap = {
+        'referenceNumber' : {
+            'string.empty': { text: mssgs.cancel_rp_identify_ref_number_error, ref: '#ref' },
+            'string.pattern.base': { text: mssgs.cancel_rp_identify_ref_pattern, ref: '#ref' }
+        },
+        'postcode': {
+            'string.empty': { ref: '#postcode', text: mssgs.cancel_rp_identify_postcode_error },
+            'string.pattern.base': { ref: '#postcode', text: mssgs.cancel_rp_identify_postcode_pattern }
+        },
+        'full-date': {
+            'object.missing': { ref: '#date-of-birth-day', text: mssgs.dob_error }
+        },
+        'day-and-month': {
+            'object.missing': { ref: '#date-of-birth-day', text: mssgs.dob_error_missing_day_and_month }
+        },
+        'day-and-year': {
+            'object.missing': { ref: '#date-of-birth-day', text: mssgs.dob_error_missing_day_and_year }
+        },
+        'month-and-year': {
+            'object.missing': { ref: '#date-of-birth-month', text: mssgs.dob_error_missing_month_and_year }
+        },
+        'day': {
+            'any.required': { ref: '#date-of-birth-day', text: mssgs.dob_error_missing_day }
+        },
+        'month': {
+            'any.required': { ref: '#date-of-birth-month', text: mssgs.dob_error_missing_month }
+        },
+        'year': {
+            'any.required': { ref: '#date-of-birth-year', text: mssgs.dob_error_missing_year }
+        },
+        'non-numeric': {
+            'number.base': { ref: '#date-of-birth-day', text: mssgs.dob_error_non_numeric }
+        },
+        'invalid-date': {
+            'any.custom': { ref: '#date-of-birth-day', text: mssgs.dob_error_date_real }
+        },
+        'date-range': {
+            'date.min': { ref: '#date-of-birth-day', text: mssgs.dob_error_year_min },
+            'date.max': { ref: '#date-of-birth-day', text: mssgs.dob_error_year_max }
+        }
+    }
+%}
+
+{% set dateInputItems = [
+    {
+      label: mssgs.date_day,
+      name: "day",
+      classes: "govuk-input--width-2 govuk-input--error" if data.isDayError else "govuk-input--width-2",
+      value: payload['date-of-birth-day'],
+      attributes: { maxlength : 2 }
+    },
+    {
+      label: mssgs.date_month,
+      name: "month",
+      classes: "govuk-input--width-2 govuk-input--error" if data.isMonthError else "govuk-input--width-2",
+      value: payload['date-of-birth-month'],
+      attributes: { maxlength : 2 }
+    },
+    {
+      label: mssgs.date_year,
+      name: "year",
+      classes: "govuk-input--width-4 govuk-input--error" if data.isYearError else "govuk-input--width-4",
+      value: payload['date-of-birth-year'],
+      attributes: { maxlength : 4 }
+    }
+  ]
+%}
+
 {% block content %}
 <div class="govuk-grid-row">
-    <div class="govuk-grid-column-two-thirds">
-        <form method="post" class="govuk-!-margin-bottom-6">
+  <div class="govuk-grid-column-two-thirds">
+    {{ errorSummary(error, errorMap, mssgs.there_is_a_problem) }}
+    <form method="post" class="govuk-!-margin-bottom-6">
+
+      {% set legendHtml %}
+        <span class="govuk-caption-l">{{ mssgs.cancel_rp_identify_caption }}</span>
+        {{ title }}
+      {% endset %}
+
+      {% call govukFieldset({
+        describedBy: "ref-hint date-of-birth-hint postcode-hint",
+        legend: {
+          html: legendHtml,
+          classes: "govuk-fieldset__legend--l govuk-!-margin-bottom-3",
+          isPageHeading: true
+        }
+      }) %}
+
+                <p class="govuk-body-m">{{ mssgs.cancel_rp_identify_body }}</p>
+
+                  {{ govukInput({
+                    id: "ref",
+                    name: "referenceNumber",
+                    type: "text",
+                    classes: "govuk-input--width-10",
+                    errorMessage: { text: mssgs.cancel_rp_identify_ref_number_error } if error['referenceNumber'],
+                    label: {
+                      text: mssgs.cancel_rp_identify_ref_number,
+                      classes: "govuk-!-font-weight-bold"
+                    },
+                    hint: {
+                        text: mssgs.cancel_rp_identify_ref_number_hint
+                    },
+                    attributes: {
+                      spellcheck: "false",
+                      maxlength: "6"
+                    },
+                    value: payload.referenceNumber
+                  }) }}
+
+                {{ govukDateInput({
+                  id: "date-of-birth",
+                  namePrefix: "date-of-birth",
+                  items: dateInputItems,
+                  fieldset: {
+                      legend: {
+                            text: mssgs.cancel_rp_identify_dob,
+                            isPageHeading: false,
+                            classes: "govuk-!-font-weight-bold govuk-label"
+                      }
+                  },
+                  errorMessage: ({
+                    text: errorMap[data.error.errorKey][data.error.errorValue].text }
+                    if data.error and data.error.errorKey in [
+                      'full-date',
+                      'day-and-month',
+                      'day-and-year',
+                      'month-and-year',
+                      'day',
+                      'month',
+                      'year',
+                      'non-numeric',
+                      'invalid-date',
+                      'date-range'
+                    ]
+                  ),
+                  hint: {
+                    text: mssgs.cancel_rp_identify_dob_hint
+                  }
+                }) }}
+
+                {{ govukInput({
+                  label: {
+                    text: mssgs.cancel_rp_identify_postcode,
+                    classes: "govuk-!-font-weight-bold"
+                  },
+                  id: "postcode",
+                  name: "postcode",
+                  hint: { text: mssgs.cancel_rp_identify_postcode_hint },
+                  value: payload['postcode'],
+                  autocomplete: 'postal-code',
+                  classes: "govuk-input--width-10",
+                  attributes: { maxlength: 10 },
+                  errorMessage: { text: mssgs.cancel_rp_identify_postcode_error } if error['postcode']
+                }) }}
+
+            {% endcall %}
+
           {{ govukButton({
             attributes: { id: 'continue' },
             preventDoubleClick: true,
@@ -21,4 +181,11 @@
         </form>
     </div>
 </div>
-{% endblock %}
+{% endblock %}
+
+{% block bodyEnd %}
+<script type="module" nonce="{{ nonce }}">
+  import { initAll } from '/public/javascript/govuk-frontend-min.js'
+  initAll()
+</script>
+{% endblock %}

package/src/pages/recurring-payments/cancel/identify/route.js

@@ -1,13 +1,58 @@
-import pageRoute from '../../../../routes/page-route.js'
 import { CANCEL_RP_AUTHENTICATE, CANCEL_RP_IDENTIFY } from '../../../../uri.js'
+import pageRoute from '../../../../routes/page-route.js'
+import Joi from 'joi'
+import { validation } from '@defra-fish/business-rules-lib'
 import { addLanguageCodeToUri } from '../../../../processors/uri-helper.js'
+import GetDataRedirect from '../../../../handlers/get-data-redirect.js'
+import { dateOfBirthValidator, getDateErrorFlags } from '../../../../schema/validators/validators.js'
+
+export const getData = async request => {
+  const permission = await request.cache().helpers.transaction.getCurrentPermission()
+  const page = await request.cache().helpers.page.getCurrentPermission(CANCEL_RP_IDENTIFY.page)
+
+  if (permission.referenceNumber) {
+    const validatePermissionNumber = validation.permission
+      .permissionNumberUniqueComponentValidator(Joi)
+      .validate(permission.referenceNumber)
+    if (validatePermissionNumber.error) {
+      await request.cache().helpers.transaction.setCurrentPermission({ referenceNumber: null })
+      throw new GetDataRedirect(addLanguageCodeToUri(request, CANCEL_RP_IDENTIFY.uri))
+    }
+  }
+
+  const pageData = {
+    referenceNumber: permission.referenceNumber,
+    ...getDateErrorFlags(page?.error)
+  }
+
+  if (page?.error) {
+    const [errorKey] = Object.keys(page.error)
+    const errorValue = page.error[errorKey]
+    pageData.error = { errorKey, errorValue }
+  }
+
+  return pageData
+}
+
+export const validator = payload => {
+  dateOfBirthValidator(payload)
+
+  Joi.assert(
+    {
+      postcode: payload.postcode,
+      referenceNumber: payload.referenceNumber
+    },
+    Joi.object({
+      referenceNumber: validation.permission.permissionNumberUniqueComponentValidator(Joi),
+      postcode: validation.contact.createOverseasPostcodeValidator(Joi)
+    }).options({ abortEarly: false })
+  )
+}
 
 export default pageRoute(
   CANCEL_RP_IDENTIFY.page,
   CANCEL_RP_IDENTIFY.uri,
-  () => {},
-  request => {
-    return addLanguageCodeToUri(request, CANCEL_RP_AUTHENTICATE.uri)
-  },
-  () => {}
+  validator,
+  request => addLanguageCodeToUri(request, CANCEL_RP_AUTHENTICATE.uri),
+  getData
 )

package/src/processors/__tests__/recurring-payments-write-cache.spec.js

@@ -0,0 +1,121 @@
+import { setupCancelRecurringPaymentCacheFromAuthResult } from '../recurring-payments-write-cache.js'
+
+describe('setUpCancelRecurringPaymentCacheFromAuthenticationResult', () => {
+  const getSampleAuthResult = overrides => {
+    const defaults = {
+      referenceNumber: '23270624-2WC3FSD-ABNCY4',
+      endDate: '2024-12-31',
+      licensee: { firstName: 'Brenin', lastName: 'Pysgotwr' },
+      permit: { description: 'Coarse 6 month 15 Rod Licence (Half)' },
+      recurringPayment: { lastDigitsCardNumbers: '5678' }
+    }
+
+    return {
+      permission: {
+        referenceNumber: overrides.referenceNumber || defaults.referenceNumber,
+        endDate: overrides.endDate || defaults.endDate,
+        licensee: {
+          ...defaults.licensee,
+          ...(overrides.licensee ? overrides.licensee : {})
+        },
+        permit: {
+          ...defaults.permit,
+          ...(overrides.permit ? overrides.permit : {})
+        }
+      },
+      recurringPayment: {
+        ...defaults.recurringPayment,
+        ...(overrides.recurringPayment ? overrides.recurringPayment : {})
+      }
+    }
+  }
+
+  const getSampleRequest = setCurrentPermission => ({
+    cache: () => ({
+      helpers: {
+        transaction: {
+          setCurrentPermission
+        }
+      }
+    })
+  })
+
+  describe('permission caching', () => {
+    it.each([
+      ['referenceNumber', '23270624-2WC3FSD-ABNCY4'],
+      ['endDate', '2024-12-31'],
+      ['licensee', { firstName: 'John', lastName: 'Bull' }],
+      ['permit', { description: 'Coarse 12 month 2 Rod Licence (Full)' }]
+    ])("Adds permission %s, value '%s', to transaction cache", async (fieldName, fieldValue) => {
+      const setCurrentPermission = jest.fn()
+      const mockRequest = getSampleRequest(setCurrentPermission)
+      const authResult = getSampleAuthResult({ [fieldName]: fieldValue })
+
+      await setupCancelRecurringPaymentCacheFromAuthResult(mockRequest, authResult)
+
+      expect(setCurrentPermission).toHaveBeenCalledWith(
+        expect.objectContaining({
+          permission: expect.objectContaining({
+            [fieldName]: fieldValue
+          })
+        })
+      )
+    })
+
+    it.each([
+      ['licensee', { anotherProperty: 'Should not be there' }],
+      ['permit', { altProp: 'Should not be here' }]
+    ])('Omits extraneous properties from permission %s', async (fieldName, fieldValue) => {
+      const setCurrentPermission = jest.fn()
+      const mockRequest = getSampleRequest(setCurrentPermission)
+
+      const authResult = getSampleAuthResult({ [fieldName]: fieldValue })
+
+      await setupCancelRecurringPaymentCacheFromAuthResult(mockRequest, authResult)
+
+      expect(setCurrentPermission).toHaveBeenCalledWith(
+        expect.objectContaining({
+          permission: expect.not.objectContaining({
+            [fieldName]: fieldValue
+          })
+        })
+      )
+    })
+  })
+
+  describe('recurring payment caching', () => {
+    it('adds recurring payment payment card number last digits to transaction cache', async () => {
+      const setCurrentPermission = jest.fn()
+      const mockRequest = getSampleRequest(setCurrentPermission)
+
+      const authResult = getSampleAuthResult({ recurringPayment: { lastDigitsCardNumbers: '1234' } })
+
+      await setupCancelRecurringPaymentCacheFromAuthResult(mockRequest, authResult)
+
+      expect(setCurrentPermission).toHaveBeenCalledWith(
+        expect.objectContaining({
+          recurringPayment: expect.objectContaining({
+            lastDigitsCardNumbers: '1234'
+          })
+        })
+      )
+    })
+
+    it('omits extraneous properties from recurring payment', async () => {
+      const setCurrentPermission = jest.fn()
+      const mockRequest = getSampleRequest(setCurrentPermission)
+
+      const authResult = getSampleAuthResult({ recurringPayment: { someOtherProp: 'Should not be here' } })
+
+      await setupCancelRecurringPaymentCacheFromAuthResult(mockRequest, authResult)
+
+      expect(setCurrentPermission).toHaveBeenCalledWith(
+        expect.objectContaining({
+          recurringPayment: expect.not.objectContaining({
+            someOtherProp: 'Should not be here'
+          })
+        })
+      )
+    })
+  })
+})

package/src/processors/recurring-payments-write-cache.js

@@ -0,0 +1,16 @@
+export const setupCancelRecurringPaymentCacheFromAuthResult = async (request, authenticationResult) => {
+  const { permission, recurringPayment } = authenticationResult
+  const { referenceNumber, endDate, licensee, permit } = permission
+
+  await request.cache().helpers.transaction.setCurrentPermission({
+    permission: {
+      referenceNumber,
+      endDate,
+      licensee: { firstName: licensee.firstName, lastName: licensee.lastName },
+      permit: { description: permit.description }
+    },
+    recurringPayment: {
+      lastDigitsCardNumbers: recurringPayment.lastDigitsCardNumbers
+    }
+  })
+}

package/src/routes/journey-definition.js

@@ -447,7 +447,8 @@ export default [
       [CommonResults.OK]: {
         page: CANCEL_RP_CONFIRM
       }
-    }
+    },
+    backLink: CANCEL_RP_IDENTIFY.uri
   },
   {
     current: CANCEL_RP_CONFIRM,

package/src/routes/misc-routes.js

@@ -33,7 +33,7 @@ import authenticationHandler from '../handlers/authentication-handler.js'
 import { addLanguageCodeToUri } from '../processors/uri-helper.js'
 import analytics, { checkAnalyticsCookiesPage } from '../handlers/analytics-handler.js'
 import { welshEnabledAndApplied } from '../processors/page-language-helper.js'
-import cancelRPAuthenticationhander from '../handlers/cancel-rp-authentication-handler.js'
+import cancelRPAuthenticationhander from '../handlers/cancel-recurring-payment-authentication-handler.js'
 
 const gtmContainerIdOrNull = () => process.env.GTM_CONTAINER_ID || false
 

package/src/handlers/__tests__/cancel-rp-authentication-handler.spec.js

@@ -1,18 +0,0 @@
-import cancelRpAuthenticationHandler from '../cancel-rp-authentication-handler'
-import { CONTROLLER } from '../../uri.js'
-
-jest.mock('../../uri.js', () => ({
-  CONTROLLER: { uri: Symbol('controller-uri') }
-}))
-
-const getSampleResponseToolkit = () => ({
-  redirectWithLanguageCode: jest.fn()
-})
-
-describe('Cancel RP Authentication Handler', () => {
-  it('redirects with language code to CONTROLLER.uri', () => {
-    const sampleResponseToolkit = getSampleResponseToolkit()
-    cancelRpAuthenticationHandler(undefined, sampleResponseToolkit)
-    expect(sampleResponseToolkit.redirectWithLanguageCode).toHaveBeenCalledWith(CONTROLLER.uri)
-  })
-})

package/src/handlers/cancel-rp-authentication-handler.js

@@ -1,6 +0,0 @@
-import { CONTROLLER } from '../uri.js'
-
-export default async (_request, h) => {
-  console.log('cancel rp authenticate handler', h.redirectWithLanguageCode)
-  return h.redirectWithLanguageCode(CONTROLLER.uri)
-}