@defra-fish/gafl-webapp-service 1.19.0 → 1.20.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/gafl-webapp-service",
-  "version": "1.19.0",
+  "version": "1.20.0-rc.3",
   "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.19.0",
-    "@defra-fish/connectors-lib": "1.19.0",
+    "@defra-fish/business-rules-lib": "1.20.0-rc.3",
+    "@defra-fish/connectors-lib": "1.20.0-rc.3",
     "@defra/hapi-gapi": "^1.1.0",
     "@hapi/boom": "^9.1.2",
     "@hapi/catbox-redis": "^6.0.2",
@@ -75,5 +75,5 @@
     "gulp-sourcemaps": "^3.0.0",
     "node-sass": "^6.0.0"
   },
-  "gitHead": "c2bc10bed757a3d6dc8934285b3a483303e0bcfb"
+  "gitHead": "23fb6c7823dfc065b8e305230e32ae8b095c1fd5"
 }

package/src/pages/concessions/date-of-birth/__tests__/update-transaction.spec.js

@@ -17,11 +17,11 @@ const VALID_PAYLOAD = {
   'date-of-birth-day': '1'
 }
 
-const transactionHelperMock = ({
+const transactionHelperMock = {
   get: jest.fn(),
   getCurrentPermission: jest.fn(() => ({ licensee: {} })),
   setCurrentPermission: jest.fn()
-})
+}
 
 describe('updateTransaction', () => {
   beforeEach(jest.clearAllMocks)
@@ -64,24 +64,26 @@ describe('updateTransaction', () => {
     })
 
     it('logs an error if page cache does not match payload', async () => {
-      expect(consoleErrorSpy).toBeCalledWith(
-        'DOB page cache payload does not match current permission payload',
-        { dobPageCache: { payload: VALID_PAYLOAD }, payload: { test: 'payload' } }
-      )
+      expect(consoleErrorSpy).toBeCalledWith('DOB page cache payload does not match current permission payload', {
+        dobPageCache: { payload: VALID_PAYLOAD },
+        payload: { test: 'payload' }
+      })
     })
   })
 })
 
-const createRequestMock = (payload) => ({
+const createRequestMock = payload => ({
   cache: jest.fn(() => ({
     helpers: {
       page: {
         get: jest.fn(() => ({
-          permissions: [{
-            [DATE_OF_BIRTH.page]: {
-              payload: VALID_PAYLOAD
+          permissions: [
+            {
+              [DATE_OF_BIRTH.page]: {
+                payload: VALID_PAYLOAD
+              }
             }
-          }]
+          ]
         })),
         getCurrentPermission: jest.fn(() => ({ payload: payload || { test: 'payload' } }))
       },

package/src/pages/concessions/date-of-birth/update-transaction.js

@@ -4,8 +4,7 @@ import { ageConcessionHelper } from '../../../processors/concession-helper.js'
 import { cacheDateFormat } from '../../../processors/date-and-time-display.js'
 import { onLengthChange } from '../../licence-details/licence-length/update-transaction.js'
 
-const pageCacheMatchesPayload = (pageCache, payload) =>
-  JSON.stringify(pageCache[DATE_OF_BIRTH.page].payload) === JSON.stringify(payload)
+const pageCacheMatchesPayload = (pageCache, payload) => JSON.stringify(pageCache[DATE_OF_BIRTH.page].payload) === JSON.stringify(payload)
 
 /**
  * Transfer the validated page object
@@ -25,7 +24,10 @@ export default async request => {
   const dobPageCache = pageCache.permissions.find(perm => !!perm[DATE_OF_BIRTH.page])
 
   if (!pageCacheMatchesPayload(dobPageCache, payload)) {
-    console.error('DOB page cache payload does not match current permission payload', { dobPageCache: dobPageCache[DATE_OF_BIRTH.page], payload })
+    console.error('DOB page cache payload does not match current permission payload', {
+      dobPageCache: dobPageCache[DATE_OF_BIRTH.page],
+      payload
+    })
     console.log('page cache', JSON.stringify(await request.cache().helpers.page.get()))
     console.log('transaction cache', JSON.stringify(await request.cache().helpers.transaction.get()))
     console.log('status cache', JSON.stringify(await request.cache().helpers.status.get()))

package/src/pages/contact/contact/result-function.js

@@ -2,5 +2,6 @@ import { CONTACT_SUMMARY_SEEN, CommonResults } from '../../../constants.js'
 
 export default async request => {
   const status = await request.cache().helpers.status.getCurrentPermission()
-  return status.fromSummary === CONTACT_SUMMARY_SEEN ? CommonResults.SUMMARY : CommonResults.OK
+
+  return status.fromSummary === CONTACT_SUMMARY_SEEN || status.renewal ? CommonResults.SUMMARY : CommonResults.OK
 }

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

@@ -43,12 +43,15 @@ mockSalesApi()
 salesApi.countries.getAll = jest.fn(() => Promise.resolve(mockDefraCountries))
 
 describe('The easy renewal identification page', () => {
-  it('returns a failure when called with an invalid permission reference ', async () => {
+  it('redirects to identify page when called with an invalid permission reference', async () => {
     const data = await injectWithCookies('GET', RENEWAL_PUBLIC.uri.replace('{referenceNumber}', 'not-a-valid-reference-number'))
     expect(data.statusCode).toBe(302)
     expect(data.headers.location).toBe(IDENTIFY.uri)
     const data2 = await injectWithCookies('GET', IDENTIFY.uri)
-    expect(data2.statusCode).toBe(403)
+    expect(data2.statusCode).toBe(302)
+    expect(data2.headers.location).toBe(IDENTIFY.uri)
+    const data3 = await injectWithCookies('GET', IDENTIFY.uri)
+    expect(data3.statusCode).toBe(200)
   })
 
   it('returns successfully when called with a valid reference ', async () => {

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

@@ -2,7 +2,8 @@ import { IDENTIFY, AUTHENTICATE } from '../../../uri.js'
 import pageRoute from '../../../routes/page-route.js'
 import Joi from 'joi'
 import { validation } from '@defra-fish/business-rules-lib'
-import Boom from '@hapi/boom'
+
+import GetDataRedirect from '../../../handlers/get-data-redirect.js'
 
 const getData = async request => {
   // If we are supplied a permission number, validate it or throw 400
@@ -13,7 +14,8 @@ const getData = async request => {
       .permissionNumberUniqueComponentValidator(Joi)
       .validate(permission.referenceNumber)
     if (validatePermissionNumber.error) {
-      throw Boom.forbidden('Attempt to access the authentication page with an invalid permission number')
+      await request.cache().helpers.status.setCurrentPermission({ referenceNumber: null })
+      throw new GetDataRedirect(IDENTIFY.uri)
     }
   }
 

package/src/pages/summary/licence-summary/__tests__/result-function.spec.js

@@ -33,6 +33,18 @@ describe('licence-summary > result-function', () => {
       expect(result).toBe(showDigitalLicencePages.YES)
     })
 
+    it('should return the summary screen, if licence is in renewal, is 12 months and postal fulfilment is false', async () => {
+      mockStatusCacheGet.mockImplementationOnce(() => ({ renewal: true }))
+      mockTransactionPageGet.mockImplementationOnce(() => ({
+        licenceLength: '12M',
+        licensee: {
+          postalFulfilment: false
+        }
+      }))
+      const result = await resultFunction(mockRequest)
+      expect(result).toBe(CommonResults.SUMMARY)
+    })
+
     it('should return ok, if licence is 12 months and postal fulfilment is true', async () => {
       mockStatusCacheGet.mockImplementationOnce(() => ({}))
       mockTransactionPageGet.mockImplementationOnce(() => ({

package/src/pages/summary/licence-summary/result-function.js

@@ -5,8 +5,12 @@ export default async request => {
   const status = await request.cache().helpers.status.getCurrentPermission()
   const permission = await request.cache().helpers.transaction.getCurrentPermission()
 
-  if (status.renewal && isPhysical(permission) && permission.licensee.postalFulfilment !== false) {
-    return showDigitalLicencePages.YES
+  if (status.renewal) {
+    if (isPhysical(permission) && permission.licensee.postalFulfilment !== false) {
+      return showDigitalLicencePages.YES
+    } else {
+      return CommonResults.SUMMARY
+    }
   }
 
   return status.fromSummary === CONTACT_SUMMARY_SEEN ? CommonResults.SUMMARY : CommonResults.OK

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

@@ -5,7 +5,6 @@ import findPermit from '../find-permit.js'
 import { displayStartTime, cacheDateFormat } from '../../../processors/date-and-time-display.js'
 import * as concessionHelper from '../../../processors/concession-helper.js'
 import { licenceTypeDisplay } from '../../../processors/licence-type-display.js'
-import { getTrackingProductDetailsFromTransaction } from '../../../processors/analytics.js'
 import {
   LICENCE_SUMMARY,
   LICENCE_LENGTH,

package/src/pages/terms-and-conditions/route.js

@@ -1,6 +1,5 @@
 import pageRoute from '../../routes/page-route.js'
 import * as mappings from '../../processors/mapping-constants.js'
-import { getTrackingProductDetailsFromTransaction } from '../../processors/analytics.js'
 import Joi from 'joi'
 import { TERMS_AND_CONDITIONS, CONTACT_SUMMARY, LICENCE_SUMMARY } from '../../uri.js'
 import { nextPage } from '../../routes/next-page.js'

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

@@ -39,7 +39,7 @@ describe('preparePayment', () => {
   })
 
   describe('provides the correct return url', () => {
-    it.each(['http', 'https'])(`uses SSL when 'x-forwarded-proto' header is present, proto '%s'`, proto => {
+    it.each(['http', 'https'])('uses SSL when "x-forwarded-proto" header is present, proto "%s"', proto => {
       const request = createRequest({ headers: { 'x-forwarded-proto': proto } })
       result = preparePayment(request, transaction)
       expect(result.return_url).toBe(`${proto}://localhost:1234/buy/agreed`)
@@ -49,7 +49,7 @@ describe('preparePayment', () => {
       ['http', 'localhost:4321'],
       ['https', 'otherhost:8888'],
       ['http', 'samplehost:4444']
-    ])(`uses request data when 'x-forwarded-proto' header is not present, protocol '%s', host '%s'`, (protocol, host) => {
+    ])('uses request data when "x-forwarded-proto" header is not present, protocol "%s", host "%s"', (protocol, host) => {
       const request = createRequest({ headers: {}, protocol, host })
       result = preparePayment(request, transaction)
       expect(result.return_url).toBe(`${protocol}://${host}/buy/agreed`)

package/src/processors/__tests__/renewals-write-cache.spec.js

@@ -1,15 +1,14 @@
 import { salesApi } from '@defra-fish/connectors-lib'
 import moment from 'moment'
 
-import { setUpCacheFromAuthenticationResult } from '../renewals-write-cache'
+import { setUpCacheFromAuthenticationResult, setUpPayloads } from '../renewals-write-cache'
 import mockConcessions from '../../__mocks__/data/concessions'
+import { ADDRESS_LOOKUP, CONTACT, LICENCE_TYPE, NAME } from '../../uri'
 
 jest.mock('@defra-fish/connectors-lib')
 salesApi.concessions.getAll.mockResolvedValue(mockConcessions)
 
 describe('renewals-write-cache', () => {
-  beforeEach(jest.clearAllMocks)
-
   describe('setUpCacheFromAuthenticationResult', () => {
     const mockStatusCacheSet = jest.fn()
     const mockTransactionCacheGet = jest.fn()
@@ -73,6 +72,7 @@ describe('renewals-write-cache', () => {
 
     beforeEach(() => {
       mockTransactionCacheGet.mockImplementationOnce(() => ({}))
+      jest.clearAllMocks()
     })
 
     it('should set licence length to 12M, as only 12 month licences can be renewed', async () => {
@@ -230,14 +230,149 @@ describe('renewals-write-cache', () => {
       )
     })
 
-    it('should set renewal and fromSummary on the status cache', async () => {
+    it('should set renewal on the status cache', async () => {
       await setUpCacheFromAuthenticationResult(mockRequest, authenticationResult)
       expect(mockStatusCacheSet).toHaveBeenCalledWith(
         expect.objectContaining({
-          renewal: true,
-          fromSummary: 'contact-summary'
+          renewal: true
         })
       )
     })
   })
+
+  describe('setupPayloads', () => {
+    const mockTransactionCacheGet = jest.fn()
+    const mockPageCacheSet = jest.fn()
+
+    const mockRequest = {
+      cache: () => ({
+        helpers: {
+          transaction: {
+            getCurrentPermission: mockTransactionCacheGet
+          },
+          page: {
+            setCurrentPermission: mockPageCacheSet
+          }
+        }
+      })
+    }
+
+    const permission = {
+      licenceType: 'salmon-and-sea-trout',
+      licensee: {
+        birthDate: '2004-01-13',
+        email: 'email@gmail.com',
+        firstName: 'First',
+        lastName: 'Last',
+        postcode: 'SN15 3PG',
+        premises: '1',
+        preferredMethodOfConfirmation: 'Email'
+      }
+    }
+
+    beforeEach(jest.clearAllMocks)
+
+    it('should set the licence-type on the licence-type page to salmon-and-sea-trout in the cache, if licenceType is Salmon and sea trout', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => permission)
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(LICENCE_TYPE.page, {
+        payload: {
+          'licence-type': 'salmon-and-sea-trout'
+        }
+      })
+    })
+
+    it('should set the licence-type on the licence-type page to trout-and-coarse-2-rod in the cache, if licenceType is Trout and coarse and numberOfRods is 2', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => ({
+        ...permission,
+        licenceType: 'Trout and coarse',
+        numberOfRods: '2'
+      }))
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(LICENCE_TYPE.page, {
+        payload: {
+          'licence-type': 'trout-and-coarse-2-rod'
+        }
+      })
+    })
+
+    it('should set the licence-type on the licence-type page to trout-and-coarse-3-rod in the cache, if licenceType is Trout and coarse and numberOfRods is 3', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => ({
+        ...permission,
+        licenceType: 'Trout and coarse',
+        numberOfRods: '3'
+      }))
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(LICENCE_TYPE.page, {
+        payload: {
+          'licence-type': 'trout-and-coarse-3-rod'
+        }
+      })
+    })
+
+    it('should set the first-name and last-name on the name page in the cache', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => permission)
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(NAME.page, {
+        payload: {
+          'first-name': 'First',
+          'last-name': 'Last'
+        }
+      })
+    })
+
+    it('should set the premises and postcode on the address-lookup page in the cache', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => permission)
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(ADDRESS_LOOKUP.page, {
+        payload: {
+          premises: '1',
+          postcode: 'SN15 3PG'
+        }
+      })
+    })
+
+    it('should set the how-contacted to email with an email on the contact page in the cache, if preferredMethodOfConfirmation is Email', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => permission)
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(CONTACT.page, {
+        payload: {
+          'how-contacted': 'email',
+          email: 'email@gmail.com'
+        }
+      })
+    })
+
+    it('should set the how-contacted to text with a phone number on the contact page in the cache, if preferredMethodOfConfirmation is Text', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => ({
+        ...permission,
+        licensee: {
+          preferredMethodOfConfirmation: 'Text',
+          mobilePhone: '07700900900'
+        }
+      }))
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(CONTACT.page, {
+        payload: {
+          'how-contacted': 'text',
+          text: '07700900900'
+        }
+      })
+    })
+
+    it('should set the how-contacted to none on the contact page in the cache, if preferredMethodOfConfirmation is Letter', async () => {
+      mockTransactionCacheGet.mockImplementationOnce(() => ({
+        ...permission,
+        licensee: {
+          preferredMethodOfConfirmation: 'Letter'
+        }
+      }))
+      await setUpPayloads(mockRequest)
+      expect(mockPageCacheSet).toBeCalledWith(CONTACT.page, {
+        payload: {
+          'how-contacted': 'none'
+        }
+      })
+    })
+  })
 })

package/src/processors/renewals-write-cache.js

@@ -1,10 +1,9 @@
 import moment from 'moment-timezone'
 import db from 'debug'
-import { LICENCE_TYPE, NAME, ADDRESS_ENTRY, CONTACT } from '../uri.js'
+import { LICENCE_TYPE, NAME, ADDRESS_LOOKUP, CONTACT } from '../uri.js'
 import { SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
 import * as constants from './mapping-constants.js'
 import { ageConcessionHelper, addDisabled } from './concession-helper.js'
-import { CONTACT_SUMMARY_SEEN } from '../constants.js'
 import { licenceToStart } from '../pages/licence-details/licence-to-start/update-transaction.js'
 import { licenseTypes } from '../pages/licence-details/licence-type/route.js'
 import { salesApi } from '@defra-fish/connectors-lib'
@@ -66,7 +65,7 @@ export const setUpCacheFromAuthenticationResult = async (request, authentication
   // Add appropriate age concessions
   ageConcessionHelper(permission)
   await request.cache().helpers.transaction.setCurrentPermission(permission)
-  await request.cache().helpers.status.setCurrentPermission({ renewal: true, fromSummary: CONTACT_SUMMARY_SEEN })
+  await request.cache().helpers.status.setCurrentPermission({ renewal: true })
 }
 
 export const setUpPayloads = async request => {
@@ -96,14 +95,10 @@ export const setUpPayloads = async request => {
     }
   })
 
-  await request.cache().helpers.page.setCurrentPermission(ADDRESS_ENTRY.page, {
+  await request.cache().helpers.page.setCurrentPermission(ADDRESS_LOOKUP.page, {
     payload: {
       premises: permission.licensee.premises,
-      street: permission.licensee.street,
-      locality: permission.licensee.locality,
-      town: permission.licensee.town,
-      postcode: permission.licensee.postcode,
-      'country-code': permission.licensee.countryCode
+      postcode: permission.licensee.postcode
     }
   })
 

package/src/routes/__tests__/back-links.spec.js

@@ -120,6 +120,10 @@ describe('The licence-fulfilment page', () => {
     const n = journeyDefinition.find(n => n.current.page === LICENCE_FULFILMENT.page)
     expect(n.backLink({ fromSummary: CONTACT_SUMMARY_SEEN })).toBe(CONTACT_SUMMARY.uri)
   })
+  it('has a back-link to the licence-summary page if in renewal', () => {
+    const n = journeyDefinition.find(n => n.current.page === LICENCE_FULFILMENT.page)
+    expect(n.backLink({ renewal: true })).toBe(LICENCE_SUMMARY.uri)
+  })
 })
 
 describe('The licence-confirmation page', () => {

package/src/routes/journey-definition.js

@@ -239,7 +239,15 @@ export default [
         page: LICENCE_CONFIRMATION_METHOD
       }
     },
-    backLink: s => (s.fromSummary === CONTACT_SUMMARY_SEEN ? CONTACT_SUMMARY.uri : ADDRESS_LOOKUP.uri)
+    backLink: status => {
+      if (status.fromSummary === CONTACT_SUMMARY_SEEN) {
+        return CONTACT_SUMMARY.uri
+      } else if (status.renewal) {
+        return LICENCE_SUMMARY.uri
+      } else {
+        return ADDRESS_LOOKUP.uri
+      }
+    }
   },
   {
     current: LICENCE_CONFIRMATION_METHOD,

package/src/session-cache/__tests__/session-manager.spec.js

@@ -28,20 +28,17 @@ describe('isStaticResource', () => {
 })
 
 describe('includesRegex', () => {
-  const regexArray = [/^\/buy\/renew\/identify$/, /^\/renew\/[a-zA-Z0-9]{6}$/]
-  it.each(['/buy/renew/identify', '/renew/ABC123', '/renew/123123', '/renew/ABCDEF'])(
+  const regexArray = [/^\/buy\/renew\/identify$/, /^\/renew\/.*$/]
+  it.each(['/buy/renew/identify', '/renew/ABC123', '/renew/123123', '/renew/ABCDEF', '/renew/anytext'])(
     'returns true if one of the regexes is matched %s',
     async path => {
       expect(includesRegex(path, regexArray)).toBeTruthy()
     }
   )
 
-  it.each(['/buy/renew', '/buy', '/renew/123', '/buy/order-complete'])(
-    'returns false if one of the regexes is not matched %s',
-    async path => {
-      expect(includesRegex(path, regexArray)).toBeFalsy()
-    }
-  )
+  it.each(['/buy/renew', '/buy', '/rene', '/buy/order-complete'])('returns false if one of the regexes is not matched %s', async path => {
+    expect(includesRegex(path, regexArray)).toBeFalsy()
+  })
 })
 
 describe('Use session cookie', () => {

package/src/session-cache/session-manager.js

@@ -38,7 +38,7 @@ const agreedHandlerProtectionExemptSet = [
 ]
 
 // regex for /renew/{referenceNumber?} and /buy/renew/identify
-const startProtectionExemptSet = [/^\/renew\/[a-zA-Z0-9]{6}$/, /^\/buy\/renew\/identify$/]
+const startProtectionExemptSet = [/^\/renew\/.*$/, /^\/buy\/renew\/identify$/]
 
 const staticMatcherPublic = /^(?:\/public\/.*|\/robots.txt|\/favicon.ico)/
 const staticMatcherOidc = /^\/oidc\/.*/
@@ -46,9 +46,7 @@ const staticMatcherOidc = /^\/oidc\/.*/
 export const isStaticResource = request => staticMatcherPublic.test(request.path)
 export const useSessionCookie = request => !isStaticResource(request) && !staticMatcherOidc.test(request.path)
 
-export const includesRegex = (str, regexArray) => {
-  return regexArray.some(regex => regex.test(str))
-}
+export const includesRegex = (str, regexArray) => regexArray.some(regex => regex.test(str))
 
 /**
  * If there is no session cookie create it and initialize user cache contexts