@defra/forms-engine-plugin 4.7.2 → 4.8.0

package/src/server/plugins/engine/helpers.test.ts

@@ -1,868 +0,0 @@
-import {
-  ComponentType,
-  type FormDefinition,
-  type PageQuestion
-} from '@defra/forms-model'
-import Boom from '@hapi/boom'
-import { type ResponseObject, type ResponseToolkit } from '@hapi/hapi'
-import { StatusCodes } from 'http-status-codes'
-import { ValidationError } from 'joi'
-
-import {
-  checkEmailAddressForLiveFormSubmission,
-  checkFormStatus,
-  encodeUrl,
-  engine,
-  evaluateTemplate,
-  getErrors,
-  getExponentialBackoffDelay,
-  getPageHref,
-  proceed,
-  setPageTitles,
-  type GlobalScope
-} from '~/src/server/plugins/engine/helpers.js'
-import { handleLegacyRedirect } from '~/src/server/plugins/engine/helpers.js'
-import { FormModel } from '~/src/server/plugins/engine/models/FormModel.js'
-import { buildFormContextRequest } from '~/src/server/plugins/engine/pageControllers/__stubs__/request.js'
-import {
-  createPage,
-  type PageControllerClass
-} from '~/src/server/plugins/engine/pageControllers/helpers/pages.js'
-import {
-  type FormContext,
-  type FormContextRequest
-} from '~/src/server/plugins/engine/types.js'
-import {
-  FormAction,
-  FormStatus,
-  type FormResponseToolkit
-} from '~/src/server/routes/types.js'
-import definition from '~/test/form/definitions/basic.js'
-import templateDefinition from '~/test/form/definitions/templates.js'
-
-interface NunjucksContext {
-  context: {
-    globals: GlobalScope
-  }
-}
-
-type EvaluateFilter = (this: NunjucksContext, template: unknown) => unknown
-type HrefFilter = (this: NunjucksContext, path: string) => string | undefined
-
-describe('Helpers', () => {
-  let page: PageControllerClass
-  let request: FormContextRequest
-  let h: FormResponseToolkit
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    const model = new FormModel(definition, {
-      basePath: 'test'
-    })
-
-    page = createPage(model, definition.pages[0])
-    const pageUrl = new URL(page.href, 'http://example.com')
-
-    request = buildFormContextRequest({
-      method: 'get',
-      url: pageUrl,
-      path: pageUrl.pathname,
-      params: {
-        path: 'licence',
-        slug: 'test'
-      },
-      query: {},
-      app: { model }
-    })
-
-    const response = {
-      code: jest.fn().mockImplementation(() => response)
-    }
-
-    h = {
-      redirect: jest.fn().mockImplementation(() => response),
-      view: jest.fn(),
-      continue: Symbol('continue')
-    }
-  })
-
-  describe('proceed', () => {
-    it.each([
-      {
-        href: 'https://www.gov.uk/help/privacy-notice',
-
-        request: {
-          method: 'get'
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.MOVED_TEMPORARILY
-        } satisfies Partial<ResponseObject>
-      },
-      {
-        href: '/test/full-name',
-
-        request: {
-          method: 'get'
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.MOVED_TEMPORARILY
-        } satisfies Partial<ResponseObject>
-      },
-      {
-        href: '/test/full-name',
-
-        request: {
-          method: 'post',
-          payload: {
-            action: FormAction.Validate
-          }
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.SEE_OTHER
-        } satisfies Partial<ResponseObject>
-      }
-    ])(
-      'should redirect to the path provided',
-      ({ href, redirect, ...options }) => {
-        request = { ...request, ...options.request }
-
-        const response = proceed(request, h, href)
-
-        expect(h.view).not.toHaveBeenCalled()
-        expect(h.redirect).toHaveBeenCalledWith(href)
-        expect(response.code).toHaveBeenCalledWith(redirect.statusCode)
-      }
-    )
-
-    it.each([
-      {
-        href: '/test/full-name',
-
-        request: {
-          method: 'post',
-          payload: {
-            action: FormAction.Validate
-          },
-          query: {
-            myParam1: 'myValue1',
-            myParam2: 'myValue2',
-            returnUrl: '/test/summary'
-          }
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.SEE_OTHER
-        } satisfies Partial<ResponseObject>
-      }
-    ])(
-      "should redirect to the 'returnUrl' query param provided (relative paths)",
-      ({ href, redirect, ...options }) => {
-        request = { ...request, ...options.request }
-
-        const response = proceed(request, h, href)
-
-        expect(h.view).not.toHaveBeenCalled()
-        expect(h.redirect).toHaveBeenCalledWith(request.query.returnUrl)
-        expect(response.code).toHaveBeenCalledWith(redirect.statusCode)
-      }
-    )
-
-    it.each([
-      {
-        href: '/test/full-name',
-
-        request: {
-          method: 'get',
-          query: { returnUrl: 'slash-missing' }
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.MOVED_TEMPORARILY
-        } satisfies Partial<ResponseObject>
-      },
-      {
-        href: '/test/full-name',
-
-        request: {
-          method: 'post',
-          payload: {
-            action: FormAction.Validate
-          },
-          query: { returnUrl: 'https://www.gov.uk/help/privacy-notice' }
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.SEE_OTHER
-        } satisfies Partial<ResponseObject>
-      },
-      {
-        href: '/test/repeater/example',
-
-        request: {
-          method: 'post',
-          query: {
-            myParam1: 'myValue1',
-            myParam2: 'myValue2',
-            returnUrl: '/test/repeater/summary'
-          },
-          payload: {
-            action: FormAction.AddAnother
-          }
-        } satisfies Partial<FormContextRequest>,
-
-        redirect: {
-          statusCode: StatusCodes.MOVED_TEMPORARILY
-        } satisfies Partial<ResponseObject>
-      }
-    ])(
-      "should not redirect to the 'returnUrl' query param provided (other paths)",
-      ({ href, ...options }) => {
-        request = { ...request, ...options.request }
-
-        proceed(request, h, href)
-        expect(h.redirect).not.toHaveBeenCalledWith(request.query.returnUrl)
-      }
-    )
-
-    it('should not forward custom query params on POST', () => {
-      request = {
-        ...request,
-        method: 'post',
-        query: { parcelId: 'SD5848-9205' }
-      }
-
-      proceed(request, h, '/test/next-page')
-
-      expect(h.redirect).toHaveBeenCalledWith('/test/next-page')
-    })
-
-    it('should forward custom query params on GET so pre-population params survive dispatch redirects', () => {
-      request = {
-        ...request,
-        method: 'get',
-        query: { formId: '69afefa99b7b18cc1cd2c606' }
-      }
-
-      proceed(request, h, '/test/next-page')
-
-      expect(h.redirect).toHaveBeenCalledWith(
-        '/test/next-page?formId=69afefa99b7b18cc1cd2c606'
-      )
-    })
-
-    it('should forward custom query params on GET but not returnUrl', () => {
-      request = {
-        ...request,
-        method: 'get',
-        query: { formId: '69afefa99b7b18cc1cd2c606', returnUrl: '/summary' }
-      }
-
-      proceed(request, h, '/test/next-page')
-
-      expect(h.redirect).toHaveBeenCalledWith(
-        '/test/next-page?formId=69afefa99b7b18cc1cd2c606'
-      )
-    })
-  })
-
-  describe('encodeUrl', () => {
-    it.each([
-      {
-        input: 'http://example.com?myParam=has spaces&more£',
-        output: 'http://example.com/?myParam=has%20spaces&more%C2%A3'
-      },
-      {
-        input: 'mailto:hello@example.com?subject=has spaces&body=more£',
-        output: 'mailto:hello@example.com?subject=has%20spaces&body=more%C2%A3'
-      }
-    ])('should percent encode parameters', ({ input, output }) => {
-      const returned = encodeUrl(input)
-      expect(returned).toBe(output)
-    })
-
-    it('should return undefined when no url is provided', () => {
-      const returned = encodeUrl()
-      expect(returned).toBeUndefined()
-    })
-
-    it('should throw when invalid url is provided', () => {
-      expect(() => encodeUrl('not a url')).toThrow()
-    })
-  })
-
-  describe('getPageHref', () => {
-    it('should return page href', () => {
-      const returned = getPageHref(page)
-      expect(returned).toEqual(page.href)
-    })
-
-    it('should return page href (path override)', () => {
-      const nextPath = '/badgers/monkeys'
-      const nextHref = '/test/badgers/monkeys'
-
-      const returned = getPageHref(page, nextPath)
-      expect(returned).toEqual(nextHref)
-    })
-
-    it('should return page href without query params', () => {
-      request.query.myParam = 'myValue'
-      request.query.myParam2 = 'myValue2'
-
-      const returned = getPageHref(page)
-      expect(returned).toEqual(page.href)
-    })
-
-    it('should return page href (path override) without query params', () => {
-      request.query.myParam = 'myValue'
-      request.query.myParam2 = 'myValue2'
-
-      const nextPath = '/badgers/monkeys'
-      const nextHref = '/test/badgers/monkeys'
-
-      const returned = getPageHref(page, nextPath)
-      expect(returned).toEqual(nextHref)
-    })
-
-    it('should return page href with new query params', () => {
-      const returned = getPageHref(page, {
-        returnUrl: page.getSummaryPath(),
-        badger: 'monkeys'
-      })
-
-      expect(returned).toBe(
-        `${page.href}?returnUrl=${encodeURIComponent('/summary')}&badger=monkeys`
-      )
-    })
-
-    it('should return page href (path override) with new query params', () => {
-      const nextPath = '/badgers/monkeys'
-      const nextHref = '/test/badgers/monkeys'
-
-      const returned = getPageHref(page, nextPath, {
-        returnUrl: page.getSummaryPath(),
-        badger: 'monkeys'
-      })
-
-      expect(returned).toBe(
-        `${nextHref}?returnUrl=${encodeURIComponent('/summary')}&badger=monkeys`
-      )
-    })
-
-    it('should throw when absolute URL is provided', () => {
-      expect(() =>
-        getPageHref(page, 'https://www.gov.uk/help/privacy-notice')
-      ).toThrow('Only relative URLs are allowed')
-    })
-  })
-
-  describe('checkFormStatus', () => {
-    it('should return true/live for params that include live state segment', () => {
-      expect(
-        checkFormStatus({
-          state: FormStatus.Live,
-          slug: 'another',
-          path: 'segment'
-        })
-      ).toStrictEqual({
-        state: FormStatus.Live,
-        isPreview: true
-      })
-    })
-
-    it('should return true/draft for params that include draft state segment', () => {
-      expect(
-        checkFormStatus({
-          state: FormStatus.Draft,
-          slug: 'another',
-          path: 'segment'
-        })
-      ).toStrictEqual({
-        state: FormStatus.Draft,
-        isPreview: true
-      })
-    })
-
-    it('should return false/live for paths without a state segment', () => {
-      expect(
-        checkFormStatus({
-          slug: 'some',
-          path: 'other'
-        })
-      ).toStrictEqual({
-        state: FormStatus.Live,
-        isPreview: false
-      })
-    })
-  })
-
-  describe('checkEmailAddressForLiveFormSubmission', () => {
-    it('should throw an error if emailAddress is undefined and isPreview is false', () => {
-      expect(() =>
-        checkEmailAddressForLiveFormSubmission(undefined, false)
-      ).toThrow(
-        Boom.internal(
-          'An email address is required to complete the form submission'
-        )
-      )
-    })
-
-    it('should not throw an error if emailAddress is defined and isPreview is false', () => {
-      expect(() =>
-        checkEmailAddressForLiveFormSubmission('test@example.com', false)
-      ).not.toThrow()
-    })
-
-    it('should not throw an error if emailAddress is undefined and isPreview is true', () => {
-      expect(() =>
-        checkEmailAddressForLiveFormSubmission(undefined, true)
-      ).not.toThrow()
-    })
-
-    it('should not throw an error if emailAddress is defined and isPreview is true', () => {
-      expect(() =>
-        checkEmailAddressForLiveFormSubmission('test@example.com', true)
-      ).not.toThrow()
-    })
-  })
-
-  describe('getErrors', () => {
-    it('formats dates with ISO strings', () => {
-      const { details } = new ValidationError(
-        'Date of marriage example',
-        [
-          {
-            message:
-              'Date of marriage must be on or before 2021-12-25T00:00:00.000Z',
-            path: ['dateField'],
-            type: 'date.max',
-            context: {
-              key: 'dateField',
-              title: 'date of marriage'
-            }
-          }
-        ],
-        undefined
-      )
-
-      expect(getErrors(details)).toEqual([
-        {
-          path: ['dateField'],
-          href: '#dateField',
-          name: 'dateField',
-          text: 'Date of marriage must be on or before 25 December 2021',
-          context: {
-            key: 'dateField',
-            title: 'date of marriage'
-          }
-        }
-      ])
-    })
-
-    it('does not format the first letter to uppercase', () => {
-      const { details } = new ValidationError(
-        'Date of marriage example',
-        [
-          {
-            message: 'something invalid',
-            path: ['yesNoField'],
-            type: 'string.pattern.base',
-            context: {
-              key: 'yesNoField'
-            }
-          }
-        ],
-        undefined
-      )
-
-      expect(getErrors(details)).toEqual([
-        {
-          path: ['yesNoField'],
-          href: '#yesNoField',
-          name: 'yesNoField',
-          text: 'something invalid',
-          context: {
-            key: 'yesNoField'
-          }
-        }
-      ])
-    })
-  })
-
-  describe('getExponentialBackoffDelay', () => {
-    it.each([
-      { depth: 1, expected: 2000 },
-      { depth: 2, expected: 4000 },
-      { depth: 3, expected: 8000 },
-      { depth: 4, expected: 16000 },
-      { depth: 5, expected: 25000 },
-      { depth: 6, expected: 25000 },
-      { depth: 7, expected: 25000 }
-    ])(
-      'should calculate correct delay for depth $depth',
-      ({ depth, expected }) => {
-        expect(getExponentialBackoffDelay(depth)).toBe(expected)
-      }
-    )
-
-    it('should handle depth of 0', () => {
-      expect(getExponentialBackoffDelay(0)).toBe(1000)
-    })
-
-    it('should handle negative depth', () => {
-      expect(getExponentialBackoffDelay(-1)).toBe(500)
-    })
-
-    it('should cap at 25 seconds (25000ms) even for large depths', () => {
-      // For depth 10: 2000 * 2^(9) would be too high, so it should be capped
-      expect(getExponentialBackoffDelay(10)).toBe(25000)
-      expect(getExponentialBackoffDelay(20)).toBe(25000)
-    })
-  })
-
-  describe('evaluateTemplate', () => {
-    let model: FormModel
-    let formContext: FormContext
-
-    beforeEach(() => {
-      model = new FormModel(templateDefinition, {
-        basePath: 'template'
-      })
-
-      formContext = {
-        evaluationState: {},
-        relevantState: {},
-        relevantPages: [],
-        payload: {},
-        state: {},
-        paths: [],
-        isForceAccess: false,
-        data: {},
-        pageDefMap: model.pageDefMap,
-        listDefMap: model.listDefMap,
-        componentDefMap: model.componentDefMap,
-        pageMap: model.pageMap,
-        componentMap: model.componentMap,
-        referenceNumber: 'foobar'
-      }
-    })
-
-    it('should replace placeholders with values from form context relevantState', () => {
-      Object.assign(formContext.relevantState, {
-        WmHfSb: 'Enrique Chase'
-      })
-
-      const areYouInEngland = templateDefinition.pages[2]
-      expect(areYouInEngland.title).toBe('Are you in England, {{ WmHfSb }}?')
-
-      const result = evaluateTemplate(areYouInEngland.title, formContext)
-      expect(result).toBe('Are you in England, Enrique Chase?')
-    })
-
-    it('should replace placeholders with values from form context data', () => {
-      Object.assign(formContext.data, {
-        score: 'Low'
-      })
-
-      const result = evaluateTemplate(
-        'Your score is: {{ context.data.score }}',
-        formContext
-      )
-
-      expect(result).toBe('Your score is: Low')
-    })
-
-    it('evaluate filter should evaluate a liquid template', () => {
-      Object.assign(formContext.relevantState, {
-        WmHfSb: 'Enrique Chase'
-      })
-
-      const result = evaluateTemplate(
-        '{{ "Hello, {{ WmHfSb }}!" | evaluate }}',
-        formContext
-      )
-
-      expect(result).toBe('Hello, Enrique Chase!')
-    })
-
-    it('page filter should return the page definition', () => {
-      // @ts-expect-error - spyOn type issue
-      const filterSpy = jest.spyOn(engine.filters, 'page')
-      const result = evaluateTemplate(
-        '{%- assign startPageDef = "/start" | page -%}{{ startPageDef.title }}',
-        formContext
-      )
-
-      expect(filterSpy).toHaveBeenCalledWith('/start')
-      expect(result).toBe('Start page')
-    })
-
-    it('page filter should return empty when anything but a string is passed', () => {
-      // @ts-expect-error - spyOn type issue
-      const pageFilterSpy = jest.spyOn(engine.filters, 'page')
-
-      let result = evaluateTemplate('{{ 0 | page }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(0)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ undefined | page }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(undefined)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ null | page }}', formContext)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ false | page }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(false)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ [] | page }}', formContext)
-      expect(result).toBe('')
-    })
-
-    it('href filter should return the page href', () => {
-      // @ts-expect-error - spyOn type issue
-      const filterSpy = jest.spyOn(engine.filters, 'href')
-      const result = evaluateTemplate('{{ "/full-name" | href }}', formContext)
-
-      expect(filterSpy).toHaveBeenCalledWith('/full-name')
-      expect(result).toBe('/template/full-name')
-    })
-
-    it('href filter should return empty when no page passed', () => {
-      // @ts-expect-error - spyOn type issue
-      const pageFilterSpy = jest.spyOn(engine.filters, 'href')
-
-      const result = evaluateTemplate('{{ undefined | href }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(undefined)
-      expect(result).toBe('')
-    })
-
-    it('field filter should return the component definition', () => {
-      // @ts-expect-error - spyOn type issue
-      const filterSpy = jest.spyOn(engine.filters, 'field')
-      const result = evaluateTemplate(
-        '{%- assign fullNameComponentDef = "WmHfSb" | field -%}{{ fullNameComponentDef.title }}',
-        formContext
-      )
-
-      expect(filterSpy).toHaveBeenCalledWith('WmHfSb')
-      expect(result).toBe('What&#39;s your full name?')
-    })
-
-    it('field filter should return empty when anything but a string is passed', () => {
-      // @ts-expect-error - spyOn type issue
-      const pageFilterSpy = jest.spyOn(engine.filters, 'field')
-
-      let result = evaluateTemplate('{{ 0 | field }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(0)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ undefined | field }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(undefined)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ null | field }}', formContext)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ false | field }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(false)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ [] | field }}', formContext)
-      expect(result).toBe('')
-    })
-
-    it('answer filter should return the formatted submitted answer', () => {
-      Object.assign(formContext.relevantState, {
-        TKsWbP: true,
-        WmHfSb: 'Enrique Chase'
-      })
-
-      // @ts-expect-error - spyOn type issue
-      const filterSpy = jest.spyOn(engine.filters, 'answer')
-
-      let result = evaluateTemplate("{{ 'TKsWbP' | answer }}", formContext)
-      expect(filterSpy).toHaveBeenCalledWith('TKsWbP')
-      expect(result).toBe('Yes')
-
-      result = evaluateTemplate("{{ 'WmHfSb' | answer }}", formContext)
-      expect(filterSpy).toHaveBeenCalledWith('WmHfSb')
-      expect(result).toBe('Enrique Chase')
-    })
-
-    it('answer filter should return empty when anything but a string is passed', () => {
-      // @ts-expect-error - spyOn type issue
-      const pageFilterSpy = jest.spyOn(engine.filters, 'answer')
-
-      let result = evaluateTemplate('{{ 0 | answer }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(0)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ undefined | answer }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(undefined)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ null | answer }}', formContext)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ false | answer }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith(false)
-      expect(result).toBe('')
-
-      result = evaluateTemplate('{{ [] | answer }}', formContext)
-      expect(result).toBe('')
-    })
-
-    it('answer filter should return empty when non-form component name is passed', () => {
-      // @ts-expect-error - spyOn type issue
-      const pageFilterSpy = jest.spyOn(engine.filters, 'answer')
-
-      const result = evaluateTemplate('{{ "FGyiLS" | answer }}', formContext)
-      expect(pageFilterSpy).toHaveBeenLastCalledWith('FGyiLS')
-      expect(result).toBe('')
-    })
-  })
-
-  describe('Nunjucks filters', () => {
-    describe('evaluate filter', () => {
-      it('returns non-string values unchanged', () => {
-        const mockContext: NunjucksContext = {
-          context: {
-            globals: {
-              context: { pageMap: new Map() } as FormContext,
-              pages: new Map(),
-              components: new Map()
-            }
-          }
-        }
-
-        const numResult = (
-          engine.filters.evaluate as unknown as EvaluateFilter
-        ).call(mockContext, 123)
-        expect(numResult).toBe(123)
-
-        const objResult = (
-          engine.filters.evaluate as unknown as EvaluateFilter
-        ).call(mockContext, { foo: 'bar' })
-        expect(objResult).toEqual({ foo: 'bar' })
-      })
-    })
-
-    describe('href filter', () => {
-      it('returns undefined when page is undefined', () => {
-        const mockContext: NunjucksContext = {
-          context: {
-            globals: {
-              context: { pageMap: new Map() } as FormContext,
-              pages: new Map(),
-              components: new Map()
-            }
-          }
-        }
-
-        const result = (engine.filters.href as unknown as HrefFilter).call(
-          mockContext,
-          '/some-page'
-        )
-
-        expect(result).toBeUndefined()
-      })
-    })
-  })
-
-  describe('handleLegacyRedirect', () => {
-    let mockH: jest.Mocked<Pick<ResponseToolkit, 'redirect'>>
-    let mockRedirectResponse: jest.Mocked<
-      ReturnType<ResponseToolkit['redirect']>
-    >
-
-    beforeEach(() => {
-      mockRedirectResponse = {
-        permanent: jest.fn().mockReturnThis(),
-        takeover: jest.fn().mockReturnThis()
-      } as unknown as jest.Mocked<ReturnType<ResponseToolkit['redirect']>>
-
-      mockH = {
-        redirect: jest.fn().mockReturnValue(mockRedirectResponse)
-      }
-    })
-
-    it('should call h.redirect with the target URL', () => {
-      const targetUrl = '/another/target'
-      handleLegacyRedirect(mockH as unknown as ResponseToolkit, targetUrl)
-
-      expect(mockH.redirect).toHaveBeenCalledTimes(1)
-      expect(mockH.redirect).toHaveBeenCalledWith(targetUrl)
-    })
-
-    it('should call permanent() and takeover() on the redirect response', () => {
-      const targetUrl = '/final/destination'
-      handleLegacyRedirect(mockH as unknown as ResponseToolkit, targetUrl)
-
-      expect(mockRedirectResponse.permanent).toHaveBeenCalledTimes(1)
-      expect(mockRedirectResponse.takeover).toHaveBeenCalledTimes(1)
-    })
-
-    it('should return the final response object from takeover()', () => {
-      const targetUrl = '/the/end'
-      const response = handleLegacyRedirect(
-        mockH as unknown as ResponseToolkit,
-        targetUrl
-      )
-
-      expect(response).toBe(mockRedirectResponse)
-    })
-  })
-
-  describe('setPageTitles', () => {
-    const definition: FormDefinition = {
-      name: 'Test Form',
-      startPage: '/page1',
-      pages: [
-        {
-          path: '/page1',
-          title: '',
-          next: [],
-          components: [
-            {
-              type: ComponentType.TextField,
-              name: 'textfield1',
-              title: 'What is your name?',
-              options: {},
-              schema: {}
-            },
-            {
-              type: ComponentType.TextField,
-              name: 'textfield2',
-              title: 'What is your favourite food?',
-              options: {},
-              schema: {}
-            }
-          ]
-        } satisfies PageQuestion
-      ],
-      lists: [],
-      sections: [],
-      conditions: []
-    }
-
-    beforeEach(() => {
-      jest.clearAllMocks()
-    })
-    it('should set title if missing', () => {
-      const def = structuredClone(definition)
-      setPageTitles(def)
-      expect(def.pages[0].title).toBe('What is your name?')
-    })
-
-    it('should keep title if supplied', () => {
-      const def = structuredClone(definition)
-      def.pages[0].title = 'Page 1 title'
-      setPageTitles(def)
-      expect(def.pages[0].title).toBe('Page 1 title')
-    })
-  })
-})