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

package/src/pages/licence-details/licence-to-start/route.js

@@ -1,49 +1,31 @@
-import Joi from 'joi'
 import moment from 'moment-timezone'
-
-import JoiDate from '@hapi/joi-date'
 import { START_AFTER_PAYMENT_MINUTES, ADVANCED_PURCHASE_MAX_DAYS, SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
 import { LICENCE_TO_START } from '../../../uri.js'
 import pageRoute from '../../../routes/page-route.js'
-import { dateFormats } from '../../../constants.js'
 import { nextPage } from '../../../routes/next-page.js'
-
-const JoiX = Joi.extend(JoiDate)
-
-const validator = payload => {
-  const licenceStartDate = `${payload['licence-start-date-year']}-${payload['licence-start-date-month']}-${payload['licence-start-date-day']}`
-  Joi.assert(
-    {
-      'licence-start-date': licenceStartDate,
-      'licence-to-start': payload['licence-to-start']
-    },
-    Joi.object({
-      'licence-to-start': Joi.string().valid('after-payment', 'another-date').required(),
-      'licence-start-date': Joi.alternatives().conditional('licence-to-start', {
-        is: 'another-date',
-        then: JoiX.date()
-          .format(dateFormats)
-          .min(moment().tz(SERVICE_LOCAL_TIME).startOf('day'))
-          .max(moment().tz(SERVICE_LOCAL_TIME).add(ADVANCED_PURCHASE_MAX_DAYS, 'days'))
-          .required(),
-        otherwise: Joi.string().empty('')
-      })
-    }).options({ abortEarly: false, allowUnknown: true })
-  )
-}
+import { getDateErrorFlags, startDateValidator } from '../../../schema/validators/validators.js'
 
 export const getData = async request => {
   const fmt = 'DD MM YYYY'
   const { isLicenceForYou } = await request.cache().helpers.transaction.getCurrentPermission()
-
-  return {
+  const page = await request.cache().helpers.page.getCurrentPermission(LICENCE_TO_START.page)
+  const pageData = {
     isLicenceForYou,
     exampleStartDate: moment().tz(SERVICE_LOCAL_TIME).add(1, 'days').format(fmt),
     minStartDate: moment().tz(SERVICE_LOCAL_TIME).format(fmt),
     maxStartDate: moment().tz(SERVICE_LOCAL_TIME).add(ADVANCED_PURCHASE_MAX_DAYS, 'days').format(fmt),
     advancedPurchaseMaxDays: ADVANCED_PURCHASE_MAX_DAYS,
-    startAfterPaymentMinutes: START_AFTER_PAYMENT_MINUTES
+    startAfterPaymentMinutes: START_AFTER_PAYMENT_MINUTES,
+    ...getDateErrorFlags(page?.error)
+  }
+
+  if (page?.error) {
+    const [errorKey] = Object.keys(page.error)
+    const errorValue = page.error[errorKey]
+    pageData.error = { errorKey, errorValue }
   }
+
+  return pageData
 }
 
-export default pageRoute(LICENCE_TO_START.page, LICENCE_TO_START.uri, validator, nextPage, getData)
+export default pageRoute(LICENCE_TO_START.page, LICENCE_TO_START.uri, startDateValidator, nextPage, getData)

package/src/pages/renewals/identify/__tests__/identity.spec.js

@@ -116,6 +116,9 @@ describe('The easy renewal identification page', () => {
               referenceNumber: 'ABC123'
             }),
             setCurrentPermission: () => {}
+          },
+          page: {
+            getCurrentPermission: async () => ({})
           }
         }
       })

package/src/pages/renewals/identify/__tests__/route.spec.js

@@ -0,0 +1,126 @@
+import pageRoute from '../../../../routes/page-route.js'
+import { addLanguageCodeToUri } from '../../../../processors/uri-helper.js'
+import { getData, validator } from '../route.js'
+import { IDENTIFY, NEW_TRANSACTION } from '../../../../uri.js'
+import { dateOfBirthValidator, getDateErrorFlags } from '../../../../schema/validators/validators.js'
+
+jest.mock('../../../../routes/page-route.js', () => jest.fn())
+jest.mock('../../../../uri.js', () => ({
+  IDENTIFY: { page: 'identify page', uri: 'identify uri' },
+  AUTHENTICATE: { uri: Symbol('authenticate uri') },
+  NEW_TRANSACTION: { uri: Symbol('new transaction uri') }
+}))
+jest.mock('../../../../processors/uri-helper.js')
+jest.mock('../../../../schema/validators/validators.js')
+
+describe('getData', () => {
+  const getMockRequest = (referenceNumber, pageGet = async () => ({})) => ({
+    cache: () => ({
+      helpers: {
+        status: {
+          getCurrentPermission: () => ({
+            referenceNumber: referenceNumber
+          })
+        },
+        page: {
+          getCurrentPermission: pageGet
+        }
+      }
+    })
+  })
+
+  it('addLanguageCodeToUri is called with the expected arguments', async () => {
+    const request = getMockRequest('013AH6')
+    await getData(request)
+    expect(addLanguageCodeToUri).toHaveBeenCalledWith(request, NEW_TRANSACTION.uri)
+  })
+
+  it('getData returns correct URI', async () => {
+    const expectedUri = Symbol('decorated uri')
+    addLanguageCodeToUri.mockReturnValueOnce(expectedUri)
+
+    const result = await getData(getMockRequest('013AH6'))
+    expect(result.uri.new).toEqual(expectedUri)
+  })
+
+  it.each([['09F6VF'], ['013AH6'], ['LK563F']])('getData returns referenceNumber', async referenceNumber => {
+    const result = await getData(getMockRequest(referenceNumber))
+    expect(result.referenceNumber).toEqual(referenceNumber)
+  })
+
+  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('passes correct page name when getting page cache', async () => {
+    const pageGet = jest.fn(() => ({}))
+    await getData(getMockRequest(undefined, pageGet))
+    expect(pageGet).toHaveBeenCalledWith(IDENTIFY.page)
+  })
+})
+
+describe('default', () => {
+  it('should call the pageRoute with date-of-birth, /buy/date-of-birth, dateOfBirthValidator and nextPage', async () => {
+    expect(pageRoute).toBeCalledWith(IDENTIFY.page, IDENTIFY.uri, validator, expect.any(Function), getData)
+  })
+})
+
+describe('page route next', () => {
+  const nextPage = pageRoute.mock.calls[0][3]
+  beforeEach(jest.clearAllMocks)
+
+  it('passes a function as the nextPage argument', () => {
+    expect(typeof nextPage).toBe('function')
+  })
+
+  it('calls addLanguageCodeToUri', () => {
+    nextPage()
+    expect(addLanguageCodeToUri).toHaveBeenCalled()
+  })
+
+  it('passes request to addLanguageCodeToUri', () => {
+    const request = Symbol('request')
+    nextPage(request)
+    expect(addLanguageCodeToUri).toHaveBeenCalledWith(request, expect.anything())
+  })
+
+  it('next page returns result of addLanguageCodeToUri', () => {
+    const expectedResult = Symbol('add language code to uri')
+    addLanguageCodeToUri.mockReturnValueOnce(expectedResult)
+    expect(nextPage()).toBe(expectedResult)
+  })
+})
+
+describe('validator', () => {
+  const getMockRequest = (postcode = 'AA1 1AA', referenceNumber = 'A1B2C3') => ({
+    postcode,
+    referenceNumber
+  })
+
+  it('fails if dateOfBirth validator fails', () => {
+    const expectedError = new Error('expected error')
+    dateOfBirthValidator.mockImplementationOnce(() => {
+      throw expectedError
+    })
+    expect(() => validator(getMockRequest)).toThrow(expectedError)
+  })
+
+  it('passes if dateOfBirth validator passes', () => {
+    expect(() => validator(getMockRequest())).not.toThrow()
+  })
+
+  it('passes payload to dateOfBirth validator', () => {
+    const payload = getMockRequest()
+    validator(payload)
+    expect(dateOfBirthValidator).toHaveBeenCalledWith(payload)
+  })
+})

package/src/pages/renewals/identify/identify.njk

@@ -21,14 +21,40 @@
                 ref: "#ref"
             }
         },
-        'date-of-birth': {
-            'date.format': { ref: '#date-of-birth-day', text: mssgs.identify_error_enter_bday },
-            'date.max': { ref: '#date-of-birth-day', text: mssgs.identify_error_enter_bday_max },
-            'date.min': { ref: '#date-of-birth-day', text: mssgs.identify_error_enter_bday_min }
-        },
         'postcode': {
             'string.empty': { ref: '#postcode', text: mssgs.identify_error_empty_postcode },
             'string.pattern.base': { ref: '#postcode', text: mssgs.identify_error_pattern_postcode }
+        },
+        '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 }
         }
     }
 %}
@@ -37,21 +63,21 @@
     {
       label: mssgs.dob_day,
       name: "day",
-      classes: "govuk-input--width-2",
+      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.dob_month,
       name: "month",
-      classes: "govuk-input--width-2",
+      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.dob_year,
       name: "year",
-      classes: "govuk-input--width-4",
+      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 }
     }

package/src/pages/renewals/identify/route.js

@@ -4,10 +4,12 @@ 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 => {
   // If we are supplied a permission number, validate it or throw 400
   const permission = await request.cache().helpers.status.getCurrentPermission()
+  const page = await request.cache().helpers.page.getCurrentPermission(IDENTIFY.page)
 
   if (permission.referenceNumber) {
     const validatePermissionNumber = validation.permission
@@ -23,25 +25,23 @@ export const getData = async request => {
     referenceNumber: permission.referenceNumber,
     uri: {
       new: addLanguageCodeToUri(request, NEW_TRANSACTION.uri)
-    }
+    },
+    ...getDateErrorFlags(page?.error)
   }
 }
 
-const schema = Joi.object({
-  referenceNumber: validation.permission.permissionNumberUniqueComponentValidator(Joi),
-  'date-of-birth': validation.contact.createBirthDateValidator(Joi),
-  postcode: validation.contact.createOverseasPostcodeValidator(Joi)
-}).options({ abortEarly: false, allowUnknown: true })
+export const validator = payload => {
+  dateOfBirthValidator(payload)
 
-const validator = async payload => {
-  const dateOfBirth = `${payload['date-of-birth-year']}-${payload['date-of-birth-month']}-${payload['date-of-birth-day']}`
   Joi.assert(
     {
-      'date-of-birth': dateOfBirth,
       postcode: payload.postcode,
       referenceNumber: payload.referenceNumber
     },
-    schema
+    Joi.object({
+      referenceNumber: validation.permission.permissionNumberUniqueComponentValidator(Joi),
+      postcode: validation.contact.createOverseasPostcodeValidator(Joi)
+    }).options({ abortEarly: false })
   )
 }
 

package/src/schema/__tests__/__snapshots__/date.schema.test.js.snap

@@ -0,0 +1,32 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`dateSchemaInput matches expected format 1`] = `
+Object {
+  "day": "1",
+  "day-and-month": Object {
+    "day": "1",
+    "month": "2",
+  },
+  "day-and-year": Object {
+    "day": "1",
+    "year": "2023",
+  },
+  "full-date": Object {
+    "day": "1",
+    "month": "2",
+    "year": "2023",
+  },
+  "invalid-date": "2023-02-01",
+  "month": "2",
+  "month-and-year": Object {
+    "month": "2",
+    "year": "2023",
+  },
+  "non-numeric": Object {
+    "day": "1",
+    "month": "2",
+    "year": "2023",
+  },
+  "year": "2023",
+}
+`;

package/src/schema/__tests__/date.schema.test.js

@@ -0,0 +1,64 @@
+import Joi from 'joi'
+import { dateSchemaInput, dateSchema } from '../date.schema.js'
+
+describe('dateSchemaInput', () => {
+  it('matches expected format', () => {
+    expect(dateSchemaInput('1', '2', '2023')).toMatchSnapshot()
+  })
+
+  it.each`
+    desc                      | day     | month   | year      | result
+    ${'all empty'}            | ${''}   | ${''}   | ${''}     | ${{ 'full-date': { day: undefined, month: undefined, year: undefined } }}
+    ${'day and month empty'}  | ${''}   | ${''}   | ${'2020'} | ${{ 'day-and-month': { day: undefined, month: undefined } }}
+    ${'day and year empty'}   | ${''}   | ${'11'} | ${''}     | ${{ 'day-and-year': { day: undefined, year: undefined } }}
+    ${'month and year empty'} | ${'12'} | ${''}   | ${''}     | ${{ 'month-and-year': { month: undefined, year: undefined } }}
+    ${'day empty'}            | ${''}   | ${'3'}  | ${'2021'} | ${{ day: undefined }}
+    ${'month empty'}          | ${'4'}  | ${''}   | ${'2003'} | ${{ month: undefined }}
+    ${'year empty'}           | ${'15'} | ${'11'} | ${''}     | ${{ year: undefined }}
+  `('maps empty strings to undefined values when $desc', ({ day, month, year, result }) => {
+    expect(dateSchemaInput(day, month, year)).toEqual(expect.objectContaining(result))
+  })
+})
+
+describe('dateSchema', () => {
+  it.each`
+    payload                                                     | expectedError          | payloadDesc
+    ${{}}                                                       | ${'full-date'}         | ${'empty day, month and year'}
+    ${{ year: '1' }}                                            | ${'day-and-month'}     | ${'empty day and month'}
+    ${{ month: '2' }}                                           | ${'day-and-year'}      | ${'empty day and year'}
+    ${{ day: '3' }}                                             | ${'month-and-year'}    | ${'empty month and year'}
+    ${{ month: '5', year: '2023' }}                             | ${'day'}               | ${'empty day'}
+    ${{ day: '12', year: '2024' }}                              | ${'month'}             | ${'empty month'}
+    ${{ day: '15', month: '3' }}                                | ${'year'}              | ${'empty year'}
+    ${{ day: 'Ides', month: 'March', year: '44 B.C.' }}         | ${'non-numeric.day'}   | ${'non-numerics entered'}
+    ${{ day: 'Thirteenth', month: '11', year: '1978' }}         | ${'non-numeric.day'}   | ${'non-numeric day'}
+    ${{ day: '29', month: 'MAR', year: '2002' }}                | ${'non-numeric.month'} | ${'non-numeric month '}
+    ${{ day: '13', month: '1', year: 'Two thousand and five' }} | ${'non-numeric.year'}  | ${'non-numeric year'}
+    ${{ day: '30', month: '2', year: '1994' }}                  | ${'invalid-date'}      | ${'an invalid date - 1994-02-40'}
+    ${{ day: '1', month: '13', year: '2022' }}                  | ${'invalid-date'}      | ${'an invalid date - 2022-13-01'}
+    ${{ day: '29', month: '2', year: '2023' }}                  | ${'invalid-date'}      | ${'an invalid date - 1994-02-40'}
+    ${{ day: '-1.15', month: '18', year: '22.2222' }}           | ${'invalid-date'}      | ${'an invalid date - 22.2222-18-1.15'}
+  `('Error has $expectedError in details when payload has $payloadDesc', ({ payload: { day, month, year }, expectedError }) => {
+    expect(() => {
+      Joi.assert(dateSchemaInput(day, month, year), dateSchema)
+    }).toThrow(
+      expect.objectContaining({
+        details: expect.arrayContaining([
+          expect.objectContaining({
+            path: expectedError.split('.'),
+            context: expect.objectContaining({
+              label: expectedError,
+              key: expectedError.split('.').pop()
+            })
+          })
+        ])
+      })
+    )
+  })
+
+  it('valid date passes validation', () => {
+    expect(() => {
+      Joi.assert(dateSchemaInput('12', '10', '1987'), dateSchema)
+    }).not.toThrow()
+  })
+})

package/src/schema/date.schema.js

@@ -0,0 +1,63 @@
+'use strict'
+import Joi from 'joi'
+
+export const dateSchemaInput = (unparsedDay, unparsedMonth, unparsedYear) => {
+  const day = unparsedDay === '' ? undefined : unparsedDay
+  const month = unparsedMonth === '' ? undefined : unparsedMonth
+  const year = unparsedYear === '' ? undefined : unparsedYear
+
+  return {
+    'full-date': { day, month, year },
+    'day-and-month': { day, month },
+    'day-and-year': { day, year },
+    'month-and-year': { month, year },
+    day,
+    month,
+    year,
+    'non-numeric': { day, month, year },
+    'invalid-date': `${year}-${(month || '').padStart(2, '0')}-${(day || '').padStart(2, '0')}`
+  }
+}
+
+export const dateSchema = Joi.object({
+  'full-date': Joi.object()
+    .keys({
+      day: Joi.any(),
+      month: Joi.any(),
+      year: Joi.any()
+    })
+    .or('day', 'month', 'year'),
+  'day-and-month': Joi.object()
+    .keys({
+      day: Joi.any(),
+      month: Joi.any()
+    })
+    .or('day', 'month'),
+  'day-and-year': Joi.object()
+    .keys({
+      day: Joi.any(),
+      year: Joi.any()
+    })
+    .or('day', 'year'),
+  'month-and-year': Joi.object()
+    .keys({
+      month: Joi.any(),
+      year: Joi.any()
+    })
+    .or('month', 'year'),
+  day: Joi.any().required(),
+  month: Joi.any().required(),
+  year: Joi.any().required(),
+  'non-numeric': Joi.object().keys({
+    day: Joi.number(),
+    month: Joi.number(),
+    year: Joi.number()
+  }),
+  'invalid-date': Joi.custom((dateToValidate, helpers) => {
+    if (new Date(dateToValidate).toISOString() !== `${dateToValidate}T00:00:00.000Z`) {
+      throw helpers.error('invalid-date')
+    }
+
+    return dateToValidate
+  })
+}).options({ abortEarly: true })