@defra-fish/gafl-webapp-service 1.76.0 → 1.77.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/gafl-webapp-service",
-  "version": "1.76.0",
+  "version": "1.77.0-rc.10",
   "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.76.0",
-    "@defra-fish/connectors-lib": "1.76.0",
+    "@defra-fish/business-rules-lib": "1.77.0-rc.10",
+    "@defra-fish/connectors-lib": "1.77.0-rc.10",
     "@defra/hapi-gapi": "2.0.0",
     "@hapi/boom": "9.1.2",
     "@hapi/catbox-redis": "6.0.2",
@@ -79,5 +79,5 @@
       "./gafl-jest-matchers.js"
     ]
   },
-  "gitHead": "2287ca0defd4b61d66cbea6f0df84568265b036f"
+  "gitHead": "b41c703037390290c9403cafc2e0252ef63e149e"
 }

package/src/pages/contact/address/entry/__tests__/update-transaction.spec.js

@@ -0,0 +1,77 @@
+import updateTransaction from '../update-transaction.js'
+import { licenceDetailsService } from '../../../../../services/licence-details/licence-details-service.js'
+
+jest.mock('../../../../../services/licence-details/licence-details-service.js', () => ({ licenceDetailsService: jest.fn(() => []) }))
+describe('update-transaction', () => {
+  const generateMockRequest = ({
+    licensee = {},
+    licenceLength = '12M',
+    premises = '',
+    postcode = '',
+    setExistingPermissions = () => {}
+  } = {}) => ({
+    cache: () => ({
+      helpers: {
+        page: { getCurrentPermission: () => ({ payload: { premises, postcode } }) },
+        transaction: { getCurrentPermission: () => ({ licensee, licenceLength }), setCurrentPermission: () => {} },
+        existingPermissions: { set: setExistingPermissions }
+      }
+    })
+  })
+
+  beforeEach(jest.clearAllMocks)
+
+  it('sends correct parameters to look up existing permissions', async () => {
+    const sampleLicensee = {
+      firstName: 'Brenin',
+      lastName: 'Pysgotwr',
+      birthDate: '1987-07-10'
+    }
+    const premises = '59'
+    const postcode = 'YO99 9AA'
+
+    await updateTransaction(generateMockRequest({ licensee: sampleLicensee, premises, postcode }))
+    expect(licenceDetailsService).toHaveBeenCalledWith(
+      expect.objectContaining({
+        firstName: sampleLicensee.firstName,
+        lastName: sampleLicensee.lastName,
+        birthDate: sampleLicensee.birthDate,
+        premises,
+        postcode
+      })
+    )
+  })
+
+  it('saves retrieved permissions in existingPermissions cache', async () => {
+    const setExistingPermissions = jest.fn()
+    const sampleRequest = generateMockRequest({ setExistingPermissions })
+    const existingPermissions = Symbol('existingPermissions')
+    licenceDetailsService.mockReturnValueOnce(existingPermissions)
+
+    await updateTransaction(sampleRequest)
+
+    expect(setExistingPermissions).toHaveBeenCalledWith({ permissions: existingPermissions })
+  })
+
+  describe.each([
+    ['one day', '1D'],
+    ['eight days', '8D']
+  ])('for licence duration %s', (_d, licenceLength) => {
+    it("doesn't look up existingPermissions", async () => {
+      const sampleRequest = generateMockRequest({ licenceLength })
+
+      await updateTransaction(sampleRequest)
+
+      expect(licenceDetailsService).not.toHaveBeenCalled()
+    })
+
+    it("doesn't set existingPermissions cache", async () => {
+      const setExistingPermissions = jest.fn()
+      const sampleRequest = generateMockRequest({ licenceLength, setExistingPermissions })
+
+      await updateTransaction(sampleRequest)
+
+      expect(setExistingPermissions).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/pages/contact/address/entry/update-transaction.js

@@ -1,4 +1,5 @@
 import { ADDRESS_ENTRY } from '../../../../uri.js'
+import { licenceDetailsService } from '../../../../services/licence-details/licence-details-service.js'
 
 /**
  * In this case the result of the address search is placed into the page data of the select address page
@@ -7,8 +8,14 @@ import { ADDRESS_ENTRY } from '../../../../uri.js'
  */
 export default async request => {
   const { payload } = await request.cache().helpers.page.getCurrentPermission(ADDRESS_ENTRY.page)
-  const { licensee } = await request.cache().helpers.transaction.getCurrentPermission()
+  const { licensee, licenceLength } = await request.cache().helpers.transaction.getCurrentPermission()
+
   const { premises, street, locality, town, postcode, 'country-code': countryCode } = payload
   Object.assign(licensee, { premises, street, locality, town, postcode, countryCode, organisation: null })
   await request.cache().helpers.transaction.setCurrentPermission({ licensee })
+  if (licenceLength === '12M') {
+    const { firstName, lastName, birthDate } = licensee
+    const existingPermissions = await licenceDetailsService({ firstName, lastName, birthDate, premises, postcode })
+    await request.cache().helpers.existingPermissions.set({ permissions: existingPermissions })
+  }
 }

package/src/pages/contact/address/select/__tests__/update-transaction.spec.js

@@ -0,0 +1,79 @@
+import updateTransaction from '../update-transaction.js'
+import { licenceDetailsService } from '../../../../../services/licence-details/licence-details-service.js'
+
+jest.mock('../../../../../services/licence-details/licence-details-service.js', () => ({ licenceDetailsService: jest.fn(() => []) }))
+
+describe('update-transaction', () => {
+  const generateMockRequest = ({
+    licensee = {},
+    licenceLength = '12M',
+    premises,
+    postcode = '',
+    setExistingPermissions = () => {}
+  } = {}) => ({
+    cache: () => ({
+      helpers: {
+        page: { getCurrentPermission: () => ({ payload: { address: 'a1' } }) },
+        transaction: { getCurrentPermission: () => ({ licensee, licenceLength }), setCurrentPermission: () => {} },
+        addressLookup: { getCurrentPermission: () => ({ addresses: [{ id: 'a1', premises, postcode }] }) },
+        existingPermissions: { set: setExistingPermissions }
+      }
+    })
+  })
+
+  beforeEach(jest.clearAllMocks)
+
+  it('sends correct parameters to look up existing permissions', async () => {
+    const sampleLicensee = {
+      firstName: 'Brenin',
+      lastName: 'Pysgotwr',
+      birthDate: '1987-07-10'
+    }
+    const premises = '27'
+    const postcode = 'YO99 9AA'
+
+    await updateTransaction(generateMockRequest({ licensee: sampleLicensee, premises, postcode }))
+    expect(licenceDetailsService).toHaveBeenCalledWith(
+      expect.objectContaining({
+        firstName: sampleLicensee.firstName,
+        lastName: sampleLicensee.lastName,
+        birthDate: sampleLicensee.birthDate,
+        premises,
+        postcode
+      })
+    )
+  })
+
+  it('saves retrieved permissions in existingPermissions cache', async () => {
+    const setExistingPermissions = jest.fn()
+    const sampleRequest = generateMockRequest({ setExistingPermissions })
+    const existingPermissions = Symbol('existingPermissions')
+    licenceDetailsService.mockReturnValueOnce(existingPermissions)
+
+    await updateTransaction(sampleRequest)
+
+    expect(setExistingPermissions).toHaveBeenCalledWith({ permissions: existingPermissions })
+  })
+
+  describe.each([
+    ['one day', '1D'],
+    ['eight days', '8D']
+  ])('for licence duration %s', (_d, licenceLength) => {
+    it("doesn't look up existingPermissions", async () => {
+      const sampleRequest = generateMockRequest({ licenceLength })
+
+      await updateTransaction(sampleRequest)
+
+      expect(licenceDetailsService).not.toHaveBeenCalled()
+    })
+
+    it("doesn't set existingPermissions cache", async () => {
+      const setExistingPermissions = jest.fn()
+      const sampleRequest = generateMockRequest({ licenceLength, setExistingPermissions })
+
+      await updateTransaction(sampleRequest)
+
+      expect(setExistingPermissions).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/pages/contact/address/select/update-transaction.js

@@ -1,4 +1,5 @@
 import { ADDRESS_SELECT } from '../../../../uri.js'
+import { licenceDetailsService } from '../../../../services/licence-details/licence-details-service.js'
 
 /**
  * In this case the result of the address search is placed into the page data of the select address page
@@ -7,7 +8,7 @@ import { ADDRESS_SELECT } from '../../../../uri.js'
  */
 export default async request => {
   const { payload } = await request.cache().helpers.page.getCurrentPermission(ADDRESS_SELECT.page)
-  const { licensee } = await request.cache().helpers.transaction.getCurrentPermission()
+  const { licensee, licenceLength } = await request.cache().helpers.transaction.getCurrentPermission()
   const { addresses } = await request.cache().helpers.addressLookup.getCurrentPermission()
   const { premises, street, locality, town, postcode } = addresses.find(a => a.id === payload.address)
   // All UK addresses from lookup default to GB
@@ -27,4 +28,10 @@ export default async request => {
   }
 
   await request.cache().helpers.transaction.setCurrentPermission({ licensee })
+  if (licenceLength === '12M') {
+    const { firstName, lastName, birthDate } = licensee
+    const existingPermissions = await licenceDetailsService({ firstName, lastName, birthDate, premises, postcode })
+    console.log('existingPermissions', JSON.stringify(existingPermissions))
+    await request.cache().helpers.existingPermissions.set({ permissions: existingPermissions })
+  }
 }

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

@@ -125,7 +125,7 @@
                                             classes: "govuk-!-font-weight-bold govuk-label"
                                 }
                         },
-                        errorMessage: dobErrorMessage,
+                        errorMessage: data.dobErrorMessage,
                         hint: {
                             text: mssgs.enter_dob_example
                         }
@@ -202,4 +202,4 @@
             })
         })()
     </script>
-{% endblock %}
+{% endblock %}

package/src/services/licence-details/__test__/licence-details-service.spec.js

@@ -0,0 +1,72 @@
+import { salesApi } from '@defra-fish/connectors-lib'
+import { licenceDetailsService } from '../licence-details-service'
+jest.mock('@defra-fish/connectors-lib', () => ({
+  salesApi: {
+    getLicenceDetails: jest.fn(() => ({ licences: [] }))
+  }
+}))
+
+const getParams = () => ({
+  firstName: 'Fishy',
+  lastName: 'McFishface',
+  birthDate: '2000-01-01',
+  premises: '22',
+  postcode: 'TE1 1ST'
+})
+
+describe('licence-details-service', () => {
+  it('calls getLicenceDetails with the correct params', async () => {
+    const params = getParams()
+    await licenceDetailsService(params)
+
+    expect(salesApi.getLicenceDetails).toHaveBeenCalledWith(params)
+  })
+
+  it.each([
+    ['there are no matches', { licences: [] }],
+    ['there is one match', { licences: [{ referenceNumber: 'AAAAAA-1' }] }],
+    ['there are multiple matches', { licences: [{ referenceNumber: 'AAAAAA-1' }, { referenceNumber: 'AAAAAA-2' }] }]
+  ])('returns the correct result when %s', async (_description, responseBody) => {
+    salesApi.getLicenceDetails.mockResolvedValueOnce(responseBody)
+
+    const result = await licenceDetailsService(getParams())
+    expect(result).toBe(responseBody.licences)
+  })
+
+  it('returns an empty array when there is no licences object in the result', async () => {
+    salesApi.getLicenceDetails.mockResolvedValueOnce({})
+
+    const result = await licenceDetailsService(getParams())
+    expect(result).toEqual([])
+  })
+
+  describe('if getLicenceDetails throws an error', () => {
+    it('catches the error', async () => {
+      const error = new Error('Something went wrong')
+      salesApi.getLicenceDetails.mockRejectedValueOnce(error)
+
+      await expect(licenceDetailsService(getParams())).resolves.toBeDefined()
+    })
+
+    it('calls console.error with the details', async () => {
+      const error = new Error('Something went wrong')
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
+      salesApi.getLicenceDetails.mockRejectedValueOnce(error)
+      const params = getParams()
+
+      await licenceDetailsService(params)
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(`Error retrieving licence details for ${JSON.stringify(params)}`, error)
+      consoleErrorSpy.mockRestore()
+    })
+
+    it('returns an empty array', async () => {
+      const error = new Error('Something went wrong')
+      salesApi.getLicenceDetails.mockRejectedValueOnce(error)
+
+      const results = await licenceDetailsService(getParams())
+
+      expect(results).toEqual([])
+    })
+  })
+})

package/src/services/licence-details/licence-details-service.js

@@ -0,0 +1,15 @@
+import { salesApi } from '@defra-fish/connectors-lib'
+
+const matchingLicences = async contactInfo => {
+  try {
+    return await salesApi.getLicenceDetails(contactInfo)
+  } catch (err) {
+    console.error(`Error retrieving licence details for ${JSON.stringify(contactInfo)}`, err)
+    return {}
+  }
+}
+
+export const licenceDetailsService = async ({ firstName, lastName, birthDate, premises, postcode }) => {
+  const response = await matchingLicences({ firstName, lastName, birthDate, premises, postcode })
+  return response?.licences || []
+}

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

@@ -0,0 +1,44 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`contexts has expected contexts 1`] = `
+Object {
+  "addressLookup": Object {
+    "identifier": "address-lookup-context",
+    "initializer": Object {
+      "permissions": Array [],
+    },
+  },
+  "analytics": Object {
+    "identifier": "analytics-context",
+    "initializer": Object {
+      "permissions": Array [],
+    },
+  },
+  "existingPermissions": Object {
+    "identifier": "existing-permissions-context",
+    "initializer": Object {
+      "permissions": Array [],
+    },
+  },
+  "page": Object {
+    "identifier": "page-context",
+    "initializer": Object {
+      "permissions": Array [],
+    },
+  },
+  "status": Object {
+    "identifier": "status-context",
+    "initializer": Object {
+      "currentPermissionIdx": -1,
+      "permissions": Array [],
+    },
+  },
+  "transaction": Object {
+    "identifier": "transaction-context",
+    "initializer": Object {
+      "payment": Object {},
+      "permissions": Array [],
+    },
+  },
+}
+`;

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

@@ -1,6 +1,8 @@
-import { CacheError } from '../cache-manager.js'
+import { CacheError, contextCache } from '../cache-manager.js'
 import { cacheDecorator } from '../cache-decorator.js'
 
+jest.mock('../cache-manager.js')
+
 describe('Cache decorator', () => {
   it('gets id from state', () => {
     const sessionId = 'abc123'
@@ -31,14 +33,66 @@ describe('Cache decorator', () => {
     expect(error instanceof CacheError).toBeTruthy()
   })
 
-  // it.each([
-  //   [{ state: {} }, false],
-  //   [{ state: { bourbon: { id: 'abc123' } } }, true]
-  // ])('hasSession flags whether cache is available', (state, expectedHasSession) => {
-  //   const context = getCacheDecoratorContext(state)
+  describe('existingPermissions', () => {
+    beforeEach(jest.clearAllMocks)
+
+    const getSampleCache = (cookieName = 'crunch-cream') => {
+      const sampleCache = {
+        server: { app: {} },
+        state: { [cookieName]: { id: 'abc-123' } }
+      }
+      sampleCache.decorator = cacheDecorator(cookieName)
+      Object.assign(sampleCache, sampleCache.decorator())
+      return sampleCache
+    }
+
+    it('uses contextCache to get existingPermissions', async () => {
+      const sampleCache = getSampleCache()
+      const mockCacheStore = { get: jest.fn() }
+      contextCache.mockReturnValueOnce(mockCacheStore)
+
+      await sampleCache.helpers.existingPermissions.get()
+
+      expect(mockCacheStore.get).toHaveBeenCalled()
+    })
+
+    it('uses value returned by cache store to fulfill request', async () => {
+      const cacheValue = Symbol('cacheValue')
+      const sampleCache = getSampleCache()
+      const mockCacheStore = { get: jest.fn(() => cacheValue) }
+      contextCache.mockReturnValueOnce(mockCacheStore)
+
+      const fulfilledValue = await sampleCache.helpers.existingPermissions.get()
 
-  //   expect(generateCacheDecorator(context).hasSession()).toEqual(expectedHasSession)
-  // })
+      expect(fulfilledValue).toBe(cacheValue)
+    })
+
+    it.each(['get', 'set'])('passes server cache, id and correct key to contextCache before calling %s', async method => {
+      const cookieName = 'fig-roll'
+      const sampleCache = getSampleCache(cookieName)
+      const id = Symbol('id')
+      const appCache = Symbol('appCache')
+      sampleCache.server.app.cache = appCache
+      sampleCache.state[cookieName].id = id
+      const mockCacheStore = { [method]: jest.fn() }
+      contextCache.mockReturnValueOnce(mockCacheStore)
+
+      await sampleCache.helpers.existingPermissions[method]()
+
+      expect(contextCache).toHaveBeenCalledWith(appCache, id, 'existingPermissions')
+    })
+
+    it('uses contextCache to set cache', async () => {
+      const cacheValue = Symbol('cacheValue')
+      const sampleCache = getSampleCache()
+      const mockCacheStore = { set: jest.fn() }
+      contextCache.mockReturnValueOnce(mockCacheStore)
+
+      await sampleCache.helpers.existingPermissions.set(cacheValue)
+
+      expect(mockCacheStore.set).toHaveBeenCalledWith(cacheValue)
+    })
+  })
 })
 
 const getCacheDecoratorContext = context => ({

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

@@ -1,5 +1,6 @@
 import { start, stop, initialize, injectWithCookies, mockSalesApi } from '../../__mocks__/test-utils-system.js'
 import { CONTROLLER, LICENCE_TYPE } from '../../uri.js'
+import { contexts, base, contextCache } from '../cache-manager.js'
 
 beforeAll(() => new Promise(resolve => start(resolve)))
 beforeAll(() => new Promise(resolve => initialize(resolve)))
@@ -7,6 +8,12 @@ afterAll(d => stop(d))
 
 mockSalesApi()
 
+const getMockAppCache = () => ({
+  set: jest.fn(),
+  get: jest.fn(),
+  drop: jest.fn()
+})
+
 describe('The session cache removal', () => {
   it('will result in a redirect to the controller', async () => {
     await injectWithCookies('GET', '/buy/clear-cache')
@@ -27,3 +34,70 @@ describe('The session cache removal', () => {
     expect(response.headers.location).toHaveValidPathFor(CONTROLLER.uri)
   })
 })
+
+describe('contexts', () => {
+  it('has expected contexts', () => {
+    expect(contexts).toMatchSnapshot()
+  })
+})
+
+describe('base', () => {
+  describe.each(['init', 'set'])('has %s function', fnName => {
+    it.each(['abc-123', 'def-456', 'db396bac-38df-48ea-9e1f-c4567274ef44'])('that sets app cache with id %s', sampleId => {
+      const sampleAppCache = getMockAppCache()
+      const sampleBase = base(sampleAppCache, sampleId)
+      const objParam = {}
+      sampleBase[fnName](objParam)
+      expect(sampleAppCache.set).toHaveBeenCalledWith(sampleId, objParam)
+    })
+  })
+
+  it.each(['abc-123', 'def-456', 'db396bac-38df-48ae-9e1f-c4567274ef44'])('has get function that gets app cache with id %s', sampleId => {
+    const sampleAppCache = getMockAppCache()
+    const sampleBase = base(sampleAppCache, sampleId)
+    sampleBase.get()
+    expect(sampleAppCache.get).toHaveBeenCalledWith(sampleId)
+  })
+
+  it.each(['abc-123', 'def-456', 'db396bac-38df-48ea-9ef1-c4567274ef44'])(
+    'has clear function that drops app cache with id %s',
+    sampleId => {
+      const sampleAppCache = getMockAppCache()
+      const sampleBase = base(sampleAppCache, sampleId)
+      sampleBase.clear()
+      expect(sampleAppCache.drop).toHaveBeenCalledWith(sampleId)
+    }
+  )
+})
+
+describe('contextCache', () => {
+  it('get method returns context value if defined', async () => {
+    const sampleAppCache = getMockAppCache()
+    const sampleValue = Symbol('identifier')
+    sampleAppCache.get.mockResolvedValueOnce({ 'page-context': sampleValue })
+
+    const contextValue = await contextCache(sampleAppCache, 'abc-123', 'page').get()
+
+    expect(contextValue).toBe(sampleValue)
+  })
+
+  it('get method returns null if context value is not defined', async () => {
+    const sampleAppCache = getMockAppCache()
+
+    const contextValue = await contextCache(sampleAppCache, 'abc-123', 'page').get()
+
+    expect(contextValue).toBeNull()
+  })
+
+  it('set method is additive to existing context', async () => {
+    const sampleAppCache = getMockAppCache()
+    const originalCacheValue = { 'transaction-context': { a: 1, b: 'f57a955d-40d4-41e3-b1b1-fb7356e7c13b' } }
+    const additionalCacheValue = { c: 'cceab89a-d310-45fc-8d69-2003ded3c736' }
+    const expectedValue = { 'transaction-context': { ...originalCacheValue['transaction-context'], ...additionalCacheValue } }
+    sampleAppCache.get.mockResolvedValueOnce(originalCacheValue)
+
+    await contextCache(sampleAppCache, 'abc-123', 'transaction').set(additionalCacheValue)
+
+    expect(sampleAppCache.set).toHaveBeenCalledWith(expect.any(String), expect.objectContaining(expectedValue))
+  })
+})

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

@@ -91,6 +91,10 @@ const cacheDecorator = sessionCookieName =>
           get: async () => contextCache(this.server.app.cache, id(), 'analytics').get(),
           set: async obj => contextCache(this.server.app.cache, id(), 'analytics').set(obj)
         },
+        existingPermissions: {
+          get: async () => contextCache(this.server.app.cache, id(), 'existingPermissions').get(),
+          set: async obj => contextCache(this.server.app.cache, id(), 'existingPermissions').set(obj)
+        },
 
         // This one differs in that it has an individual segment for each page
         page: {

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

@@ -11,7 +11,8 @@ const contexts = {
   transaction: { identifier: 'transaction-context', initializer: { payment: {}, permissions: [] } },
   status: { identifier: 'status-context', initializer: { permissions: [], currentPermissionIdx: -1 } },
   addressLookup: { identifier: 'address-lookup-context', initializer: { permissions: [] } },
-  analytics: { identifier: 'analytics-context', initializer: { permissions: [] } }
+  analytics: { identifier: 'analytics-context', initializer: { permissions: [] } },
+  existingPermissions: { identifier: 'existing-permissions-context', initializer: { permissions: [] } }
 }
 
 class CacheError extends Error {}