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

package/src/schema/validators/__tests__/validators.spec.js

@@ -0,0 +1,208 @@
+import Joi from 'joi'
+import { dateOfBirthValidator, startDateValidator, getDateErrorFlags } from '../validators.js'
+import moment from 'moment-timezone'
+const dateSchema = require('../../date.schema.js')
+
+const setupMocks = () => {
+  Joi.originalAssert = Joi.assert
+  dateSchema.originalDateSchema = dateSchema.dateSchema
+  dateSchema.originalDateSchemaInput = dateSchema.dateSchemaInput
+
+  Joi.assert = jest.fn()
+  dateSchema.dateSchema = Symbol('dateSchema')
+  dateSchema.dateSchemaInput = jest.fn()
+}
+
+const tearDownMocks = () => {
+  Joi.assert = Joi.originalAssert
+  dateSchema.dateSchema = dateSchema.originalDateSchema
+  dateSchema.dateSchemaInput = dateSchema.originalDateSchemaInput
+}
+
+describe('dateOfBirth validator', () => {
+  beforeEach(jest.clearAllMocks)
+
+  const getSamplePayload = ({ day = '', month = '', year = '' } = {}) => ({
+    'date-of-birth-day': day,
+    'date-of-birth-month': month,
+    'date-of-birth-year': year
+  })
+
+  it('throws an error for anyone over 120 years old', () => {
+    const invalidDoB = moment().subtract(120, 'years').subtract(1, 'day')
+    const samplePayload = getSamplePayload({
+      day: invalidDoB.format('DD'),
+      month: invalidDoB.format('MM'),
+      year: invalidDoB.format('YYYY')
+    })
+    expect(() => dateOfBirthValidator(samplePayload)).toThrow()
+  })
+
+  it('validates for anyone 120 years old', () => {
+    const validDoB = moment().subtract(120, 'years')
+    const samplePayload = getSamplePayload({
+      day: validDoB.format('DD'),
+      month: validDoB.format('MM'),
+      year: validDoB.format('YYYY')
+    })
+    expect(() => dateOfBirthValidator(samplePayload)).not.toThrow()
+  })
+
+  it.each([
+    ['today', moment()],
+    ['tomorrow', moment().add(1, 'day')],
+    ['in the future', moment().add(1, 'month')]
+  ])('throws an error for a date of birth %s', (_desc, invalidDoB) => {
+    const samplePayload = getSamplePayload({
+      day: invalidDoB.format('DD'),
+      month: invalidDoB.format('MM'),
+      year: invalidDoB.format('YYYY')
+    })
+    expect(() => dateOfBirthValidator(samplePayload)).toThrow()
+  })
+
+  it.each([
+    ['1-3-2004', '1', '3', '2004'],
+    ['12-1-1999', '12', '1', '1999'],
+    ['1-12-2006', '1', '12', '2006']
+  ])('handles single digit date %s', (_desc, day, month, year) => {
+    const samplePayload = getSamplePayload({
+      day,
+      month,
+      year
+    })
+    expect(() => dateOfBirthValidator(samplePayload)).not.toThrow()
+  })
+
+  it.each([
+    ['01', '03', '1994'],
+    ['10', '12', '2004']
+  ])('passes date of birth day (%s), month (%s) and year (%s) to dateSchemaInput', (day, month, year) => {
+    setupMocks()
+    dateOfBirthValidator(getSamplePayload({ day, month, year }))
+    expect(dateSchema.dateSchemaInput).toHaveBeenCalledWith(day, month, year)
+    tearDownMocks()
+  })
+
+  it('passes dateSchemaInput output and dateSchema  to Joi.assert', () => {
+    setupMocks()
+    const dsi = Symbol('dsi')
+    dateSchema.dateSchemaInput.mockReturnValueOnce(dsi)
+    dateOfBirthValidator(getSamplePayload())
+    expect(Joi.assert).toHaveBeenCalledWith(dsi, dateSchema.dateSchema)
+    tearDownMocks()
+  })
+})
+
+describe('startDate validator', () => {
+  beforeEach(jest.clearAllMocks)
+
+  const getSamplePayload = ({ day = '', month = '', year = '' } = {}) => ({
+    'licence-start-date-day': day,
+    'licence-start-date-month': month,
+    'licence-start-date-year': year,
+    'licence-to-start': 'another-date'
+  })
+
+  it('throws an error for a licence starting before today', () => {
+    const invalidStartDate = moment().subtract(1, 'day')
+    const samplePayload = getSamplePayload({
+      day: invalidStartDate.format('DD'),
+      month: invalidStartDate.format('MM'),
+      year: invalidStartDate.format('YYYY')
+    })
+    expect(() => startDateValidator(samplePayload)).toThrow()
+  })
+
+  it('throws an error for a licence starting more than 30 days hence', () => {
+    const invalidStartDate = moment().add(31, 'days')
+    const samplePayload = getSamplePayload({
+      day: invalidStartDate.format('DD'),
+      month: invalidStartDate.format('MM'),
+      year: invalidStartDate.format('YYYY')
+    })
+    expect(() => startDateValidator(samplePayload)).toThrow()
+  })
+
+  it('validates for a date within the next 30 days', () => {
+    const validStartDate = moment().add(4, 'days')
+    const samplePayload = getSamplePayload({
+      day: validStartDate.format('DD'),
+      month: validStartDate.format('MM'),
+      year: validStartDate.format('YYYY')
+    })
+    expect(() => startDateValidator(samplePayload)).not.toThrow()
+  })
+
+  it.each([
+    ['1-3-2024', moment('2024-02-28')],
+    ['9-7-2024', moment('2024-07-08')]
+  ])('handles single digit date %s', (date, now) => {
+    jest.useFakeTimers()
+    jest.setSystemTime(now.toDate())
+
+    const [day, month, year] = date.split('-')
+    const samplePayload = getSamplePayload({
+      day,
+      month,
+      year
+    })
+    expect(() => startDateValidator(samplePayload)).not.toThrow()
+    jest.useRealTimers()
+  })
+
+  it.each([
+    ['01', '03', '1994'],
+    ['10', '12', '2004']
+  ])('passes start date day (%s), month (%s) and year (%s) to dateSchemaInput', (day, month, year) => {
+    setupMocks()
+    startDateValidator(getSamplePayload({ day, month, year }))
+    expect(dateSchema.dateSchemaInput).toHaveBeenCalledWith(day, month, year)
+    tearDownMocks()
+  })
+
+  it('passes dateSchemaInput output and dateSchema to Joi.assert', () => {
+    setupMocks()
+    const dsi = Symbol('dsi')
+    dateSchema.dateSchemaInput.mockReturnValueOnce(dsi)
+    startDateValidator(getSamplePayload())
+    expect(Joi.assert).toHaveBeenCalledWith(dsi, dateSchema.dateSchema)
+    tearDownMocks()
+  })
+
+  it('passes validation if licence is set to start after payment', () => {
+    const samplePayload = { 'licence-to-start': 'after-payment' }
+    expect(() => startDateValidator(samplePayload)).not.toThrow()
+  })
+
+  it('throws an error if licence-to-start is set to an invalid value', () => {
+    const samplePayload = { 'licence-to-start': '12th-of-never' }
+    expect(() => startDateValidator(samplePayload)).toThrow()
+  })
+})
+
+describe('getErrorFlags', () => {
+  it('sets all error flags to be false when there are no errors', () => {
+    const result = getDateErrorFlags()
+    expect(result).toEqual({ isDayError: false, isMonthError: false, isYearError: false })
+  })
+
+  it.each([
+    ['full-date', { isDayError: true, isMonthError: true, isYearError: true }],
+    ['day-and-month', { isDayError: true, isMonthError: true, isYearError: false }],
+    ['month-and-year', { isDayError: false, isMonthError: true, isYearError: true }],
+    ['day-and-year', { isDayError: true, isMonthError: false, isYearError: true }],
+    ['day', { isDayError: true, isMonthError: false, isYearError: false }],
+    ['month', { isDayError: false, isMonthError: true, isYearError: false }],
+    ['year', { isDayError: false, isMonthError: false, isYearError: true }],
+    ['invalid-date', { isDayError: true, isMonthError: true, isYearError: true }],
+    ['date-range', { isDayError: true, isMonthError: true, isYearError: true }],
+    ['non-numeric', { isDayError: true, isMonthError: true, isYearError: true }]
+  ])('when error is %s, should set %o in flags', (errorKey, expected) => {
+    const error = { [errorKey]: 'anything.at.all' }
+
+    const result = getDateErrorFlags(error)
+
+    expect(result).toEqual(expect.objectContaining(expected))
+  })
+})

package/src/schema/validators/validators.js

@@ -0,0 +1,65 @@
+import Joi from 'joi'
+import moment from 'moment'
+import { ADVANCED_PURCHASE_MAX_DAYS, SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
+import { dateSchema, dateSchemaInput } from '../date.schema.js'
+
+const MAX_AGE = 120
+const LICENCE_TO_START_FIELD = 'licence-to-start'
+const AFTER_PAYMENT = 'after-payment'
+const ANOTHER_DATE = 'another-date'
+
+const validateDate = (day, month, year, minDate, maxDate) => {
+  Joi.assert(dateSchemaInput(day, month, year), dateSchema)
+  const dateRange = moment(`${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`, 'YYYY-MM-DD')
+    .tz(SERVICE_LOCAL_TIME)
+    .startOf('day')
+    .toDate()
+  Joi.assert({ 'date-range': dateRange }, Joi.object({ 'date-range': Joi.date().min(minDate).max(maxDate) }))
+}
+
+export const dateOfBirthValidator = payload => {
+  const day = payload['date-of-birth-day']
+  const month = payload['date-of-birth-month']
+  const year = payload['date-of-birth-year']
+
+  const minDate = moment().tz(SERVICE_LOCAL_TIME).subtract(MAX_AGE, 'years').startOf('day').toDate()
+  const maxDate = moment().tz(SERVICE_LOCAL_TIME).subtract(1, 'day').startOf('day').toDate()
+  validateDate(day, month, year, minDate, maxDate)
+}
+
+export const startDateValidator = payload => {
+  Joi.assert(
+    { 'licence-to-start': payload[LICENCE_TO_START_FIELD] },
+    Joi.object({ 'licence-to-start': Joi.string().valid(AFTER_PAYMENT, ANOTHER_DATE).required() })
+  )
+  if (payload[LICENCE_TO_START_FIELD] === ANOTHER_DATE) {
+    const day = payload['licence-start-date-day']
+    const month = payload['licence-start-date-month']
+    const year = payload['licence-start-date-year']
+
+    const minDate = moment().tz(SERVICE_LOCAL_TIME).startOf('day').toDate()
+    const maxDate = moment().tz(SERVICE_LOCAL_TIME).add(ADVANCED_PURCHASE_MAX_DAYS, 'days').toDate()
+    validateDate(day, month, year, minDate, maxDate)
+  }
+}
+
+export const getDateErrorFlags = error => {
+  const errorFlags = { isDayError: false, isMonthError: false, isYearError: false }
+  const commonErrors = ['full-date', 'invalid-date', 'date-range', 'non-numeric']
+
+  if (error) {
+    const [errorKey] = Object.keys(error)
+
+    if (['day-and-month', 'day-and-year', 'day', ...commonErrors].includes(errorKey)) {
+      errorFlags.isDayError = true
+    }
+    if (['day-and-month', 'month-and-year', 'month', ...commonErrors].includes(errorKey)) {
+      errorFlags.isMonthError = true
+    }
+    if (['day-and-year', 'month-and-year', 'year', ...commonErrors].includes(errorKey)) {
+      errorFlags.isYearError = true
+    }
+  }
+
+  return errorFlags
+}

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

@@ -309,7 +309,7 @@ describe('The govuk-pay-service', () => {
         ok: true,
         json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
       }
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
       const unique = Symbol('payload')
       const payload = {
         reference: 'd81f1a2b-6508-468f-8342-b6770f60f7cd',
@@ -318,7 +318,7 @@ describe('The govuk-pay-service', () => {
         unique
       }
       await sendRecurringPayment(payload)
-      expect(govUkPayApi.createRecurringPayment).toHaveBeenCalledWith(payload)
+      expect(govUkPayApi.createRecurringPaymentAgreement).toHaveBeenCalledWith(payload)
     })
 
     it('should return response body when payment creation is successful', async () => {
@@ -326,7 +326,7 @@ describe('The govuk-pay-service', () => {
         ok: true,
         json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
       }
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
 
       const result = await sendRecurringPayment(preparedPayment)
 
@@ -338,7 +338,7 @@ describe('The govuk-pay-service', () => {
         ok: true,
         json: jest.fn().mockResolvedValue({ success: true, paymentId: 'abc123' })
       }
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
 
       await sendRecurringPayment(preparedPayment)
 
@@ -352,7 +352,7 @@ describe('The govuk-pay-service', () => {
         json: jest.fn().mockResolvedValue({ message: 'Server error' })
       }
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
 
       try {
         await sendRecurringPayment(preparedPayment)
@@ -370,7 +370,7 @@ describe('The govuk-pay-service', () => {
     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.createRecurringPayment.mockRejectedValue(mockError)
+      govUkPayApi.createRecurringPaymentAgreement.mockRejectedValue(mockError)
 
       try {
         await sendRecurringPayment(preparedPayment)
@@ -389,7 +389,7 @@ describe('The govuk-pay-service', () => {
         json: jest.fn().mockResolvedValue({ message: 'Rate limit exceeded' })
       }
       const consoleErrorSpy = jest.spyOn(console, 'info').mockImplementation(jest.fn())
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
 
       try {
         await sendRecurringPayment(preparedPayment)
@@ -404,7 +404,7 @@ describe('The govuk-pay-service', () => {
         status: 500,
         json: jest.fn().mockResolvedValue({ message: 'Server error' })
       }
-      govUkPayApi.createRecurringPayment.mockResolvedValue(mockResponse)
+      govUkPayApi.createRecurringPaymentAgreement.mockResolvedValue(mockResponse)
 
       try {
         await sendRecurringPayment(preparedPayment)

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

@@ -109,9 +109,9 @@ export const getPaymentStatus = async (paymentId, recurring = false) => {
   }
 }
 
-const createRecurringPayment = async preparedPayment => {
+const createRecurringPaymentAgreement = async preparedPayment => {
   try {
-    return await govUkPayApi.createRecurringPayment(preparedPayment)
+    return await govUkPayApi.createRecurringPaymentAgreement(preparedPayment)
   } catch (err) {
     /*
      * Potentially errors caught here (unreachable, timeouts) may be retried - set origin on the error to indicate
@@ -122,7 +122,7 @@ const createRecurringPayment = async preparedPayment => {
 }
 
 export const sendRecurringPayment = async preparedPayment => {
-  const response = await createRecurringPayment(preparedPayment)
+  const response = await createRecurringPaymentAgreement(preparedPayment)
 
   if (response.ok) {
     const resBody = await response.json()

package/src/pages/renewals/identify/__tests__/identity.next-page.spec.js

@@ -1,36 +0,0 @@
-import pageRoute from '../../../../routes/page-route.js'
-import { addLanguageCodeToUri } from '../../../../processors/uri-helper.js'
-require('../route.js') // require rather than import to avoid lint error with unused variable
-
-jest.mock('../../../../routes/page-route.js', () => jest.fn())
-jest.mock('../../../../uri.js', () => ({
-  IDENTIFY: { page: 'identify page', uri: 'identify uri' },
-  AUTHENTICATE: { uri: Symbol('authenticate uri') }
-}))
-jest.mock('../../../../processors/uri-helper.js')
-
-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)
-  })
-})

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

@@ -1,38 +0,0 @@
-import { addLanguageCodeToUri } from '../../../../processors/uri-helper.js'
-import { getData } from '../route.js'
-import { NEW_TRANSACTION } from '../../../../uri.js'
-
-jest.mock('../../../../processors/uri-helper.js')
-
-const getMockRequest = referenceNumber => ({
-  cache: () => ({
-    helpers: {
-      status: {
-        getCurrentPermission: () => ({
-          referenceNumber: referenceNumber
-        })
-      }
-    }
-  })
-})
-
-describe('getData', () => {
-  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)
-  })
-})