@defra/forms-engine-plugin 4.7.2-alpha → 4.7.3

package/src/server/plugins/postcode-lookup/service.test.js

@@ -1,177 +0,0 @@
-import Boom from '@hapi/boom'
-
-import * as service from '~/src/server/plugins/postcode-lookup/service.js'
-import { result as postcodeResult } from '~/src/server/plugins/postcode-lookup/test/__stubs__/postcode.js'
-import { result as queryResult } from '~/src/server/plugins/postcode-lookup/test/__stubs__/query.js'
-import { result as uprnResult } from '~/src/server/plugins/postcode-lookup/test/__stubs__/uprn.js'
-import { getJson } from '~/src/server/services/httpService.js'
-
-jest.mock('~/src/server/services/httpService.ts')
-
-describe('Postcode lookup service', () => {
-  describe('searchByPostcode', () => {
-    it('should return formatted addresses', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 200,
-          headers: {}
-        }),
-        payload: postcodeResult,
-        error: undefined
-      })
-
-      const results = await service.searchByPostcode('NW1 6XE', 'apikey')
-
-      expect(results).toHaveLength(10)
-      expect(results.at(0)).toEqual({
-        address: "EMILIA'S CRAFTED PASTA, 215, BAKER STREET, LONDON, NW1 6XE",
-        addressLine1: "Emilia's Crafted Pasta 215",
-        addressLine2: 'Baker Street',
-        county: '',
-        formatted: "Emilia's Crafted Pasta 215, Baker Street, London, NW1 6XE",
-        postcode: 'NW1 6XE',
-        town: 'London',
-        uprn: '10033619968'
-      })
-    })
-
-    it('should return an empty response when an error is encountered', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 300,
-          headers: {}
-        }),
-        payload: undefined,
-        error: new Error('Unknown error')
-      })
-
-      const results = await service.searchByPostcode('NW1 6XE', 'apikey')
-
-      expect(results).toHaveLength(0)
-      expect(results).toEqual([])
-    })
-
-    it('should return an empty response when a non 200 response is encountered', async () => {
-      jest
-        .mocked(getJson)
-        .mockRejectedValueOnce(
-          Boom.badRequest(
-            'OS API error',
-            new Error('Invalid postcode segments')
-          )
-        )
-
-      const results = await service.searchByPostcode(
-        'invalid postcode',
-        'apikey'
-      )
-
-      expect(results).toHaveLength(0)
-      expect(results).toEqual([])
-    })
-
-    it('should return an empty response when no results are returned', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 200,
-          headers: {}
-        }),
-        payload: { results: undefined },
-        error: undefined
-      })
-
-      const results = await service.searchByPostcode('NW1 6XE', 'apikey')
-
-      expect(results).toHaveLength(0)
-      expect(results).toEqual([])
-    })
-  })
-
-  describe('searchByUPRN', () => {
-    it('should return formatted addresses', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 200,
-          headers: {}
-        }),
-        payload: uprnResult,
-        error: undefined
-      })
-
-      const results = await service.searchByUPRN('100023071949', 'apikey')
-
-      expect(results).toHaveLength(1)
-      expect(results.at(0)).toEqual({
-        address: 'SHERLOCK HOLMES MUSEUM, 221B, BAKER STREET, LONDON, NW1 6XE',
-        addressLine1: 'Sherlock Holmes Museum 221b',
-        addressLine2: 'Baker Street',
-        county: '',
-        formatted: 'Sherlock Holmes Museum 221b, Baker Street, London, NW1 6XE',
-        postcode: 'NW1 6XE',
-        town: 'London',
-        uprn: '100023071949'
-      })
-    })
-  })
-
-  describe('searchByQuery', () => {
-    it('should return formatted addresses', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 200,
-          headers: {}
-        }),
-        payload: queryResult,
-        error: undefined
-      })
-
-      const results = await service.searchByQuery(
-        'Prime minister downing',
-        'apikey'
-      )
-
-      expect(results).toHaveLength(5)
-      expect(results.at(0)).toEqual({
-        address: 'BAKER STREET COTTAGE, BAKER STREET, FROME, BA11 3BL',
-        addressLine1: 'Baker Street Cottage',
-        addressLine2: 'Baker Street',
-        town: 'Frome',
-        county: '',
-        formatted: 'Baker Street Cottage, Baker Street, Frome, BA11 3BL',
-        postcode: 'BA11 3BL',
-        uprn: '250034655'
-      })
-    })
-  })
-
-  describe('search', () => {
-    it('should return formatted addresses', async () => {
-      jest.mocked(getJson).mockResolvedValueOnce({
-        res: /** @type {IncomingMessage} */ ({
-          statusCode: 200,
-          headers: {}
-        }),
-        payload: postcodeResult,
-        error: undefined
-      })
-
-      const results = await service.search('NW1 6XE', 'Emilia', 'apikey')
-
-      expect(results).toHaveLength(1)
-      expect(results.at(0)).toEqual({
-        address: "EMILIA'S CRAFTED PASTA, 215, BAKER STREET, LONDON, NW1 6XE",
-        addressLine1: "Emilia's Crafted Pasta 215",
-        addressLine2: 'Baker Street',
-        county: '',
-        formatted: "Emilia's Crafted Pasta 215, Baker Street, London, NW1 6XE",
-        postcode: 'NW1 6XE',
-        town: 'London',
-        uprn: '10033619968'
-      })
-    })
-  })
-})
-
-/**
- * @import  { IncomingMessage } from 'node:http'
- */

package/src/server/postcode-lookup.test.ts

@@ -1,64 +0,0 @@
-import { type Server } from '@hapi/hapi'
-
-import { createServer } from '~/src/server/index.js'
-import { getFormMetadata } from '~/src/server/plugins/engine/services/formsService.js'
-import * as defaultServices from '~/src/server/plugins/engine/services/index.js'
-import * as fixtures from '~/test/fixtures/index.js'
-
-jest.mock('~/src/server/plugins/engine/services/formsService.js')
-jest.mock('~/src/server/plugins/engine/services/uploadService.js')
-
-describe('Postcode lookup plugin', () => {
-  let server: Server
-
-  beforeEach(() => {
-    jest.mocked(getFormMetadata).mockResolvedValue(fixtures.form.metadata)
-  })
-
-  afterAll(async () => {
-    await server.stop()
-  })
-
-  describe('Plugin registration', () => {
-    test('Registers plugin with ordnance survey key', async () => {
-      server = await createServer({
-        services: defaultServices,
-        ordnanceSurveyApiKey: 'dummy'
-      })
-      await server.initialize()
-
-      expect(server.registrations).toHaveProperty(
-        '@defra/forms-engine-plugin/postcode-lookup',
-        {
-          name: '@defra/forms-engine-plugin/postcode-lookup',
-          options: { ordnanceSurveyApiKey: 'dummy' },
-          version: undefined
-        }
-      )
-
-      expect(
-        server.table().find((route) => route.path === '/postcode-lookup')
-      ).toBeDefined()
-    })
-
-    test('Does not register plugin when no ordnance survey key is provided', async () => {
-      server = await createServer({
-        services: defaultServices
-      })
-      await server.initialize()
-
-      expect(server.registrations).not.toHaveProperty(
-        '@defra/forms-engine-plugin/postcode-lookup',
-        {
-          name: '@defra/forms-engine-plugin/postcode-lookup',
-          options: { ordnanceSurveyApiKey: 'dummy' },
-          version: undefined
-        }
-      )
-
-      expect(
-        server.table().find((route) => route.path === '/postcode-lookup')
-      ).toBeUndefined()
-    })
-  })
-})

package/src/server/routes/dummy-api.test.ts

@@ -1,97 +0,0 @@
-import { type Server } from '@hapi/hapi'
-import MockDate from 'mockdate'
-
-import { createServer } from '~/src/server/index.js'
-
-describe('Dummy API', () => {
-  let server: Server
-
-  const payload = {
-    meta: {
-      referenceNumber: 'FOO-BAR-123'
-    },
-    data: {
-      main: {
-        applicantFirstName: 'Joe',
-        applicantLastName: 'Bloggs',
-        dateOfBirth: '2020-01-01'
-      }
-    }
-  }
-
-  beforeAll(async () => {
-    MockDate.set('2025-01-01T00:00:00Z')
-    server = await createServer({
-      enforceCsrf: false
-    })
-    await server.initialize()
-  })
-
-  afterAll(async () => {
-    await server.stop()
-    MockDate.reset()
-  })
-
-  it('should validate on-load-page POST response', async () => {
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/example/on-load-page',
-      payload
-    })
-
-    expect(res.statusCode).toBe(200)
-    expect(res.result).toMatchObject({
-      submissionEvent: 'GET',
-      submissionReferenceNumber: payload.meta.referenceNumber
-    })
-  })
-
-  /*
-  This is just dummy code that won't run in prod, we don't need a full suite of tests.
-  */
-  it('should validate on-summary POST response', async () => {
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/example/on-summary',
-      payload
-    })
-
-    expect(res.statusCode).toBe(200)
-    expect(res.result).toMatchObject({
-      calculatedAge: 5,
-      submissionEvent: 'POST',
-      submissionReferenceNumber: payload.meta.referenceNumber
-    })
-  })
-
-  it('should calculate age correctly when birthday has not occurred yet this year', async () => {
-    // Set today's date to just before the birthday in 2025
-    MockDate.set('2025-01-01T00:00:00Z')
-
-    const payloadWithFutureBirthday = {
-      meta: {
-        referenceNumber: 'FOO-BAR-456'
-      },
-      data: {
-        main: {
-          applicantFirstName: 'Jane',
-          applicantLastName: 'Doe',
-          dateOfBirth: '2020-02-01' // Birthday is in February, today is January
-        }
-      }
-    }
-
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/example/on-summary',
-      payload: payloadWithFutureBirthday
-    })
-
-    expect(res.statusCode).toBe(200)
-    expect(res.result).toMatchObject({
-      calculatedAge: 4, // Should be 4, not 5, because birthday hasn't occurred yet
-      submissionEvent: 'POST',
-      submissionReferenceNumber: payloadWithFutureBirthday.meta.referenceNumber
-    })
-  })
-})

package/src/server/services/cacheService.test.ts

@@ -1,308 +0,0 @@
-import { type Request, type Server } from '@hapi/hapi'
-
-import { config } from '~/src/config/index.js'
-import { type FormRequest } from '~/src/server/routes/types.js'
-import { CacheService, merge } from '~/src/server/services/cacheService.js'
-
-describe('CacheService', () => {
-  let mockServer: Partial<Server>
-  let mockCache: {
-    get: jest.Mock
-    set: jest.Mock
-    drop: jest.Mock
-  }
-  let cacheService: CacheService
-
-  beforeEach(() => {
-    mockCache = {
-      get: jest.fn(),
-      set: jest.fn(),
-      drop: jest.fn()
-    }
-
-    mockServer = {
-      log: jest.fn(),
-      cache: (() => ({
-        ...mockCache,
-        provision: jest.fn()
-      })) as unknown as Server['cache'],
-      logger: {
-        info: jest.fn()
-      } as unknown as Server['logger']
-    }
-
-    cacheService = new CacheService({
-      server: mockServer as Server,
-      cacheName: 'test-cache'
-    })
-  })
-
-  describe('getState', () => {
-    describe('when cache exists', () => {
-      it('should return cached state', async () => {
-        const mockRequest = {
-          yar: { id: 'some-session' },
-          params: { state: 'form1', slug: 'page1' }
-        } as unknown as FormRequest
-        const mockState = { someData: 'test' }
-
-        mockCache.get.mockResolvedValue(mockState)
-
-        const result = await cacheService.getState(mockRequest)
-
-        expect(result).toEqual(mockState)
-        expect(mockCache.get).toHaveBeenCalledWith({
-          segment: 'cache',
-          id: 'some-session:form1:page1:'
-        })
-      })
-    })
-
-    describe('when cache does not exist', () => {
-      it('should return empty object', async () => {
-        const mockRequest = {
-          yar: { id: 'some-session' },
-          params: { state: 'form1', slug: 'page1' }
-        } as unknown as FormRequest
-
-        mockCache.get.mockResolvedValue(null)
-
-        const result = await cacheService.getState(mockRequest)
-
-        expect(result).toEqual({})
-      })
-    })
-  })
-
-  describe('setState', () => {
-    it('should set state with correct TTL and return updated state', async () => {
-      const mockRequest = {
-        yar: { id: 'some-session' },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-      const mockState = { someData: 'test' }
-      const mockTTL = 3600000
-
-      jest.spyOn(config, 'get').mockReturnValue(mockTTL)
-
-      // Mock getState to return the updated state after set
-      jest.spyOn(cacheService, 'getState').mockResolvedValue(mockState)
-
-      await expect(
-        cacheService.setState(mockRequest, mockState)
-      ).resolves.toEqual(mockState)
-
-      expect(mockCache.set).toHaveBeenCalledWith(
-        {
-          segment: 'cache',
-          id: 'some-session:form1:page1:'
-        },
-        mockState,
-        mockTTL
-      )
-      expect(cacheService.getState).toHaveBeenCalledWith(mockRequest)
-    })
-  })
-
-  describe('Key', () => {
-    describe('when session ID is missing', () => {
-      it('should throw error', () => {
-        const mockRequest = {
-          yar: { id: null },
-          params: {}
-        } as unknown as Request
-
-        expect(() => cacheService.Key(mockRequest)).toThrow(
-          'No session ID found'
-        )
-      })
-    })
-  })
-
-  describe('merge', () => {
-    describe('when merging objects', () => {
-      it('should merge them correctly', () => {
-        const state = { field1: 'some-data-1', field2: 'some-data-2' }
-        const update = { field2: 'updated', field3: 'some-data-3' }
-
-        const result = merge(state, update)
-
-        expect(result).toEqual({
-          field1: 'some-data-1',
-          field2: 'updated',
-          field3: 'some-data-3'
-        })
-      })
-    })
-
-    describe('when merging arrays', () => {
-      it('should overwrite instead of merge', () => {
-        const state = { items: ['some-item-1', 'some-item-2'] }
-        const update = { items: ['some-item-3'] }
-
-        const result = merge(state, update)
-
-        expect(result.items).toEqual(['some-item-3'])
-      })
-    })
-  })
-
-  describe('getFlash', () => {
-    describe('when messages exist', () => {
-      it('should return first message', () => {
-        const mockRequest = {
-          yar: {
-            id: 'some-session',
-            flash: jest.fn().mockReturnValue([{ errors: [{ type: 'error' }] }])
-          },
-          params: { state: 'form1', slug: 'page1' }
-        } as unknown as FormRequest
-
-        const result = cacheService.getFlash(mockRequest)
-
-        expect(result).toEqual({ errors: [{ type: 'error' }] })
-      })
-    })
-
-    describe('when no messages exist', () => {
-      it('should return undefined', () => {
-        const mockRequest = {
-          yar: {
-            id: 'some-session',
-            flash: jest.fn().mockReturnValue([])
-          },
-          params: { state: 'form1', slug: 'page1' }
-        } as unknown as FormRequest
-
-        const result = cacheService.getFlash(mockRequest)
-
-        expect(result).toBeUndefined()
-      })
-    })
-  })
-
-  describe('setFlash', () => {
-    it('should set flash message', () => {
-      const mockRequest = {
-        yar: {
-          id: 'some-session',
-          flash: jest.fn()
-        },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-      const message = {
-        errors: [
-          {
-            type: 'error',
-            href: '#error',
-            name: 'error',
-            text: 'Error message',
-            path: ['path-abc']
-          }
-        ]
-      }
-
-      cacheService.setFlash(mockRequest, message)
-
-      expect(mockRequest.yar.flash).toHaveBeenCalledWith(
-        'some-session:form1:page1:',
-        message
-      )
-    })
-  })
-
-  describe('clearState', () => {
-    it('should clear state from cache', async () => {
-      const mockRequest = {
-        yar: { id: 'some-session' },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-
-      await cacheService.clearState(mockRequest)
-
-      expect(mockCache.drop).toHaveBeenCalledWith({
-        segment: 'cache',
-        id: 'some-session:form1:page1:'
-      })
-    })
-
-    it('should not clear state when session ID is undefined', async () => {
-      const mockRequest = {
-        yar: { id: undefined },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-
-      await cacheService.clearState(mockRequest)
-
-      expect(mockCache.drop).not.toHaveBeenCalled()
-    })
-
-    it('should not clear state when session ID is null', async () => {
-      const mockRequest = {
-        yar: { id: null },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-
-      await cacheService.clearState(mockRequest)
-
-      expect(mockCache.drop).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('getConfirmationState', () => {
-    it('should return confirmation state from cache', async () => {
-      const mockRequest = {
-        yar: { id: 'some-session' },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-      const mockState = { confirmed: true as const }
-
-      mockCache.get.mockResolvedValue(mockState)
-
-      const result = await cacheService.getConfirmationState(mockRequest)
-
-      expect(result).toEqual(mockState)
-      expect(mockCache.get).toHaveBeenCalledWith({
-        segment: 'cache',
-        id: 'some-session:form1:page1::confirmation'
-      })
-    })
-
-    it('should return empty object when no confirmation state exists', async () => {
-      const mockRequest = {
-        yar: { id: 'some-session' },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-
-      mockCache.get.mockResolvedValue(null)
-
-      const result = await cacheService.getConfirmationState(mockRequest)
-
-      expect(result).toEqual({})
-    })
-  })
-
-  describe('setConfirmationState', () => {
-    it('should set confirmation state in cache', async () => {
-      const mockRequest = {
-        yar: { id: 'some-session' },
-        params: { state: 'form1', slug: 'page1' }
-      } as unknown as FormRequest
-      const mockState = { confirmed: true as const }
-      const mockTTL = 3600000
-
-      jest.spyOn(config, 'get').mockReturnValue(mockTTL)
-
-      await cacheService.setConfirmationState(mockRequest, mockState)
-
-      expect(mockCache.set).toHaveBeenCalledWith(
-        {
-          segment: 'cache',
-          id: 'some-session:form1:page1::confirmation'
-        },
-        mockState,
-        mockTTL
-      )
-    })
-  })
-})