@defra/forms-engine-plugin 4.7.2 → 4.7.3

package/src/server/plugins/engine/models/FormModel.test.ts

@@ -1,725 +0,0 @@
-import {
-  SchemaVersion,
-  formDefinitionSchema,
-  formDefinitionV2Schema,
-  type FormDefinition
-} from '@defra/forms-model'
-
-import { todayAsDateOnly } from '~/src/server/plugins/engine/date-helper.js'
-import { FormModel } from '~/src/server/plugins/engine/models/FormModel.js'
-import { buildFormContextRequest } from '~/src/server/plugins/engine/pageControllers/__stubs__/request.js'
-import { type FormContextRequest } from '~/src/server/plugins/engine/types.js'
-import { FormAction } from '~/src/server/routes/types.js'
-import { V2 as definitionV2 } from '~/test/form/definitions/conditions-basic.js'
-import definition from '~/test/form/definitions/conditions-escaping.js'
-import conditionsListDefinition from '~/test/form/definitions/conditions-list.js'
-import relativeDatesDefinition from '~/test/form/definitions/conditions-relative-dates-v2.js'
-import fieldsRequiredDefinition from '~/test/form/definitions/fields-required.js'
-import joinedConditionsDefinition from '~/test/form/definitions/joined-conditions-simple-v2.js'
-
-jest.mock('~/src/server/plugins/engine/date-helper.ts')
-
-describe('FormModel', () => {
-  beforeEach(() => {
-    jest.resetAllMocks()
-  })
-
-  describe('Constructor', () => {
-    it('loads a valid form definition', () => {
-      expect(
-        () => new FormModel(definition, { basePath: 'test' })
-      ).not.toThrow()
-    })
-
-    it('Sets the page title from first form component when empty (V2 only)', () => {
-      const noTitlesDefinition = {
-        ...definitionV2,
-        pages: definitionV2.pages.map((page) => ({ ...page, title: '' }))
-      }
-
-      const model = new FormModel(noTitlesDefinition, { basePath: 'test' })
-
-      expect(model.def.pages.at(0)?.title).toBe(
-        'Have you previously been married?'
-      )
-      expect(model.def.pages.at(1)?.title).toBe('Date of marriage')
-    })
-
-    it('Gets a list by ID', () => {
-      const definitionWithLists: FormDefinition = {
-        ...definitionV2,
-        lists: [
-          {
-            id: 'c5eba145-b04d-4d41-a50c-e5e2f9b6357f',
-            type: 'string',
-            title: 'foo',
-            name: 'foo',
-            items: [
-              { text: 'a', value: 'a' },
-              { text: 'b', value: 'b' }
-            ]
-          },
-          {
-            type: 'string',
-            title: 'bar',
-            name: 'bar',
-            items: [
-              {
-                id: 'a85a42a8-3e08-4c2a-b263-a0dc0b8c49f6',
-                text: 'a',
-                value: 'a'
-              },
-              {
-                id: 'c31664ac-887b-434b-b9f4-e5bc30d24439',
-                text: 'b',
-                value: 'b'
-              }
-            ]
-          }
-        ]
-      }
-
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: definitionWithLists })
-
-      const model = new FormModel(definitionWithLists, { basePath: 'test' })
-
-      expect(
-        model.getListById('c5eba145-b04d-4d41-a50c-e5e2f9b6357f')
-      ).toBeDefined()
-      expect(model.listDefIdMap.size).toBe(2) // 1 + the yes/no list. list 'bar' isn't present as there's no ID
-    })
-
-    it('Gets a component by ID', () => {
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: definitionV2 })
-
-      const model = new FormModel(definitionV2, { basePath: 'test' })
-
-      expect(
-        model.getComponentById('717eb213-4e4b-4a2d-9cfd-2780f5e1e3e5')
-      ).toBeDefined()
-      expect(model.listDefIdMap.size).toBe(1)
-    })
-
-    it('gets a condition by its ID', () => {
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: definitionV2 })
-      const model = new FormModel(definitionV2, { basePath: 'test' })
-
-      expect(
-        model.getConditionById('6c9e2f4a-1d7b-5e8c-3f6a-9e2d5b7c4f1a')
-      ).toBeDefined()
-    })
-
-    it('throws an error if schema validation fails', () => {
-      formDefinitionV2Schema.validate = jest.fn().mockReturnValueOnce({
-        error: 'Validation error'
-      })
-
-      expect(() => new FormModel(definitionV2, { basePath: 'test' })).toThrow(
-        'Validation error'
-      )
-    })
-
-    it('assigns v1 to the schema if not defined', () => {
-      const definitionWithoutSchema: FormDefinition = {
-        ...definition,
-        schema: undefined
-      }
-
-      // Mock validation to just return the definition
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: definitionWithoutSchema })
-
-      const model = new FormModel(definitionWithoutSchema, { basePath: 'test' })
-
-      expect(model.schemaVersion).toBe(SchemaVersion.V1)
-    })
-
-    it.each([
-      {
-        input: undefined,
-        expected: SchemaVersion.V1,
-        schema: formDefinitionSchema
-      },
-      {
-        input: SchemaVersion.V1,
-        expected: SchemaVersion.V1,
-        schema: formDefinitionSchema
-      },
-      {
-        input: SchemaVersion.V2,
-        expected: SchemaVersion.V2,
-        schema: formDefinitionV2Schema
-      }
-    ])(
-      'assigns $expected to the schema when defined',
-      ({ input, expected, schema }) => {
-        const definitionWithSchema: FormDefinition = {
-          ...definition,
-          schema: input
-        }
-
-        // we just want to test that we're validating the right schema
-        // we don't care about the actual validation logic, this isn't an integration test
-        const spy = jest.spyOn(schema, 'validate').mockReturnValue({
-          value: definitionWithSchema,
-          error: undefined
-        })
-
-        const model = new FormModel(definitionWithSchema, { basePath: 'test' })
-
-        expect(model.schemaVersion).toBe(expected)
-        expect(spy).toHaveBeenCalledWith(definitionWithSchema, {
-          abortEarly: false
-        })
-
-        spy.mockRestore()
-      }
-    )
-  })
-
-  describe('getFormContext', () => {
-    it.each([FormAction.Validate, undefined])(
-      'returns a form context with the correct payload and state when action is %s',
-      (action) => {
-        const formModel = new FormModel(fieldsRequiredDefinition, {
-          basePath: '/components'
-        })
-
-        const state = {
-          $$__referenceNumber: 'foobar'
-        }
-        const pageUrl = new URL('http://example.com/components/fields-required')
-
-        const request: FormContextRequest = buildFormContextRequest({
-          method: 'post',
-          payload: {
-            crumb: 'dummyCrumb',
-            action,
-            textField: 'Hello world'
-          },
-          query: {},
-          path: pageUrl.pathname,
-          params: { path: 'components', slug: 'fields-required' },
-          url: pageUrl,
-          app: { model: formModel }
-        })
-
-        const context = formModel.getFormContext(request, state)
-
-        expect(context.payload.textField).toBe('Hello world')
-        expect(context.state.textField).toBe('Hello world')
-        expect(context.referenceNumber).toEqual(expect.any(String))
-      }
-    )
-
-    it('returns without updating the state when the action is not validate or saveAndExit', () => {
-      const formModel = new FormModel(fieldsRequiredDefinition, {
-        basePath: '/components'
-      })
-
-      const state = {
-        $$__referenceNumber: 'foobar',
-        textField: 'old'
-      }
-      const pageUrl = new URL('http://example.com/components/fields-required')
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'post',
-        payload: { crumb: 'dummyCrumb', action: 'continue', textField: 'new' },
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'components', slug: 'fields-required' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      const context = formModel.getFormContext(request, state)
-
-      // Early return branch should not merge payload into state
-      expect(context.state.textField).toBe('old')
-      expect(context.errors).toBeUndefined()
-      expect(context.referenceNumber).toEqual(expect.any(String))
-    })
-
-    it('clears a previous checkbox field value when the field is omitted from the payload', () => {
-      const formModel = new FormModel(fieldsRequiredDefinition, {
-        basePath: '/components'
-      })
-
-      const state = {
-        $$__referenceNumber: 'foobar',
-        checkboxesSingle: ['Arabian', 'Shetland']
-      }
-      const pageUrl = new URL('http://example.com/components/fields-required')
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'post',
-        payload: { crumb: 'dummyCrumb', action: 'validate' },
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'components', slug: 'fields-required' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      const context = formModel.getFormContext(request, state)
-
-      expect(context.payload.checkboxesSingle).toEqual([])
-      expect(context.errors).toContainEqual(
-        expect.objectContaining({ name: 'checkboxesSingle' })
-      )
-      expect(context.referenceNumber).toEqual(expect.any(String))
-    })
-
-    it('handles missing reference numbers', () => {
-      const formModel = new FormModel(fieldsRequiredDefinition, {
-        basePath: '/components'
-      })
-
-      const state = {
-        checkboxesSingle: ['Arabian', 'Shetland']
-      }
-      const pageUrl = new URL('http://example.com/components/fields-required')
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'post',
-        payload: { crumb: 'dummyCrumb', action: 'validate' },
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'components', slug: 'fields-required' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      expect(() => formModel.getFormContext(request, state)).toThrow(
-        'Reference number not found in form state'
-      )
-    })
-
-    it('handles non-string reference numbers', () => {
-      const formModel = new FormModel(fieldsRequiredDefinition, {
-        basePath: '/components'
-      })
-
-      const state = {
-        $$__referenceNumber: 123456789,
-        checkboxesSingle: ['Arabian', 'Shetland']
-      }
-      const pageUrl = new URL('http://example.com/components/fields-required')
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'post',
-        payload: { crumb: 'dummyCrumb', action: 'validate' },
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'components', slug: 'fields-required' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      expect(() => formModel.getFormContext(request, state)).toThrow(
-        'Reference number not found in form state'
-      )
-    })
-
-    it('redirects to the page if the list field (radio) is invalidated due to list item conditions', () => {
-      const formModel = new FormModel(conditionsListDefinition, {
-        basePath: '/conditional-list-items'
-      })
-
-      const state = {
-        $$__referenceNumber: 'foobar',
-        gXsqLq: true,
-        QwcNsc: 'meat',
-        zeQDES: ['peppers', 'cheese', 'ham']
-      }
-      const pageUrl = new URL(
-        'http://example.com/conditional-list-items/summary'
-      )
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'get',
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'summary', slug: 'conditional-list-items' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      const context = formModel.getFormContext(request, state)
-
-      expect(context.errors).toHaveLength(1)
-      expect(context.errors?.at(0)?.text).toBe(
-        'Options are different because you changed a previous answer'
-      )
-      expect(context.relevantPages).toHaveLength(2)
-      expect(context.paths).toHaveLength(2)
-      expect(context.relevantState).toEqual({ gXsqLq: true, QwcNsc: 'meat' })
-    })
-
-    it('redirects to the page if the list field (check) is invalidated due to list item conditions', () => {
-      const formModel = new FormModel(conditionsListDefinition, {
-        basePath: '/conditional-list-items'
-      })
-
-      const state = {
-        $$__referenceNumber: 'foobar',
-        gXsqLq: true,
-        QwcNsc: 'vegan',
-        zeQDES: ['peppers', 'cheese', 'ham']
-      }
-      const pageUrl = new URL(
-        'http://example.com/conditional-list-items/summary'
-      )
-
-      const request: FormContextRequest = buildFormContextRequest({
-        method: 'get',
-        query: {},
-        path: pageUrl.pathname,
-        params: { path: 'summary', slug: 'conditional-list-items' },
-        url: pageUrl,
-        app: { model: formModel }
-      })
-
-      const context = formModel.getFormContext(request, state)
-
-      expect(context.errors).toHaveLength(1)
-      expect(context.errors?.at(0)?.text).toBe(
-        'Options are different because you changed a previous answer'
-      )
-      expect(context.relevantPages).toHaveLength(3)
-      expect(context.paths).toHaveLength(3)
-      expect(context.relevantState).toEqual({
-        gXsqLq: true,
-        QwcNsc: 'vegan',
-        zeQDES: ['peppers', 'cheese', 'ham']
-      })
-    })
-  })
-
-  describe('makeCondition', () => {
-    test('relative date condition', () => {
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: relativeDatesDefinition })
-      const model = new FormModel(relativeDatesDefinition, { basePath: 'test' })
-
-      const allConditionsKeys = Object.keys(model.conditions)
-      expect(allConditionsKeys).toHaveLength(8)
-
-      // Only test releative date conditions
-      const relativeConditionsKeys = allConditionsKeys.slice(4)
-      expect(relativeConditionsKeys).toHaveLength(4)
-
-      const formState = {
-        ybMHIv: '2023-06-18'
-      }
-
-      const expectedResultsDayBefore = [true, false, false, true]
-
-      const expectedResultsDayOf = [true, true, false, false]
-
-      const expectedResultsDayAfter = [false, true, true, false]
-
-      // Only relative date conditions
-      for (let i = 0; i < relativeConditionsKeys.length; i++) {
-        const condition = model.conditions[relativeConditionsKeys[i]]
-        jest.mocked(todayAsDateOnly).mockReturnValue(new Date(2025, 5, 19))
-        const conditionExec = model.makeCondition(
-          // @ts-expect-error - type doesnt need to match for this test
-          condition
-        )
-        formState.ybMHIv = '2023-06-18'
-        expect(conditionExec.fn(formState)).toBe(expectedResultsDayBefore[i])
-
-        formState.ybMHIv = '2023-06-19'
-        expect(conditionExec.fn(formState)).toBe(expectedResultsDayOf[i])
-
-        formState.ybMHIv = '2023-06-20'
-        expect(conditionExec.fn(formState)).toBe(expectedResultsDayAfter[i])
-      }
-    })
-  })
-})
-
-describe('FormModel - Joined Conditions', () => {
-  it('should handle joined conditions correctly', () => {
-    formDefinitionV2Schema.validate = jest
-      .fn()
-      .mockReturnValue({ value: joinedConditionsDefinition })
-
-    const model = new FormModel(joinedConditionsDefinition, {
-      basePath: 'test'
-    })
-
-    expect(model.conditions).toBeDefined()
-    expect(Object.keys(model.conditions)).toHaveLength(3)
-
-    const joinedCondition =
-      model.conditions['db43c6bc-9ce6-478b-8345-4fff5eff2ba3']
-    expect(joinedCondition).toBeDefined()
-    expect(joinedCondition?.displayName).toBe('is Bob AND over 18')
-
-    const stateAllTrue = { userName: 'Bob', isOverEighteen: true }
-    expect(joinedCondition?.fn(stateAllTrue)).toBe(true)
-
-    const statePartialTrue = { userName: 'Alice', isOverEighteen: true }
-    expect(joinedCondition?.fn(statePartialTrue)).toBe(false)
-
-    const stateFalse = { userName: 'Alice', isOverEighteen: false }
-    expect(joinedCondition?.fn(stateFalse)).toBe(false)
-  })
-
-  it('should evaluate page conditions using joined conditions', () => {
-    formDefinitionV2Schema.validate = jest
-      .fn()
-      .mockReturnValue({ value: joinedConditionsDefinition })
-
-    const model = new FormModel(joinedConditionsDefinition, {
-      basePath: 'test'
-    })
-
-    const joinedConditionPage = model.pages.find(
-      (page) => page.path === '/simple-and-page'
-    )
-
-    expect(joinedConditionPage?.condition).toBeDefined()
-
-    const trueState = { userName: 'Bob', isOverEighteen: true }
-    expect(joinedConditionPage?.condition?.fn(trueState)).toBe(true)
-
-    const falseState = { userName: 'Bob', isOverEighteen: false }
-    expect(joinedConditionPage?.condition?.fn(falseState)).toBe(false)
-  })
-
-  it('should handle V1 joined conditions without aliases', () => {
-    formDefinitionV2Schema.validate = jest
-      .fn()
-      .mockReturnValue({ value: definition })
-
-    const model = new FormModel(definition, {
-      basePath: 'test'
-    })
-
-    expect(model.conditions).toBeDefined()
-    expect(Object.keys(model.conditions)).toHaveLength(1)
-
-    const joinedCondition = model.conditions.ZCXeMz
-    expect(joinedCondition).toBeDefined()
-    expect(joinedCondition?.displayName).toBe('test')
-
-    const testState = { NIJphU: "ap'ostrophe's", iraEpG: "shouldn't've" }
-    expect(joinedCondition?.fn(testState)).toBe(true)
-
-    const testStateFalse = { NIJphU: 'other', iraEpG: "shouldn't've" }
-    expect(joinedCondition?.fn(testStateFalse)).toBe(false)
-
-    const context = model.toConditionContext(testState, model.conditions)
-
-    expect(context).not.toHaveProperty('cond_ZCXeMz')
-
-    expect(context).toHaveProperty('ZCXeMz')
-
-    expect(context).toHaveProperty('NIJphU', "ap'ostrophe's")
-    expect(context).toHaveProperty('iraEpG', "shouldn't've")
-  })
-
-  it('should use schema version to determine condition aliases', () => {
-    const v1Definition = { ...definition, schema: SchemaVersion.V1 }
-    formDefinitionV2Schema.validate = jest
-      .fn()
-      .mockReturnValue({ value: v1Definition })
-
-    const v1Model = new FormModel(v1Definition, { basePath: 'test' })
-    expect(v1Model.schemaVersion).toBe(SchemaVersion.V1)
-
-    const v1TestState = { NIJphU: "ap'ostrophe's", iraEpG: "shouldn't've" }
-    const v1Context = v1Model.toConditionContext(
-      v1TestState,
-      v1Model.conditions
-    )
-
-    expect(v1Context).toHaveProperty('ZCXeMz')
-    expect(v1Context).not.toHaveProperty('cond_ZCXeMz')
-
-    formDefinitionV2Schema.validate = jest
-      .fn()
-      .mockReturnValue({ value: joinedConditionsDefinition })
-
-    const v2Model = new FormModel(joinedConditionsDefinition, {
-      basePath: 'test'
-    })
-    expect(v2Model.schemaVersion).toBe(SchemaVersion.V2)
-
-    const v2TestState = { userName: 'Bob', isOverEighteen: true }
-    const v2Context = v2Model.toConditionContext(
-      v2TestState,
-      v2Model.conditions
-    )
-
-    expect(v2Context).toHaveProperty('cond_d15aff7a622440a28e5f51a5af2f7910')
-    expect(v2Context).toHaveProperty('cond_d1f9fcc7f09847e79d314f5ee57ba985')
-    expect(v2Context).toHaveProperty('cond_db43c6bc9ce6478b83454fff5eff2ba3')
-
-    expect(v2Context).not.toHaveProperty('d15aff7a-6224-40a2-8e5f-51a5af2f7910')
-    expect(v2Context).not.toHaveProperty('d1f9fcc7-f098-47e7-9d31-4f5ee57ba985')
-    expect(v2Context).not.toHaveProperty('db43c6bc-9ce6-478b-8345-4fff5eff2ba3')
-  })
-
-  describe('generateConditionAlias', () => {
-    it('should generate valid JavaScript identifiers from condition IDs', () => {
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: joinedConditionsDefinition })
-
-      const model = new FormModel(joinedConditionsDefinition, {
-        basePath: 'test'
-      })
-
-      const evaluationState = { userName: 'Bob', isOverEighteen: true }
-
-      const context = model.toConditionContext(
-        evaluationState,
-        model.conditions
-      )
-
-      expect(context).toHaveProperty('cond_d15aff7a622440a28e5f51a5af2f7910')
-      expect(context).toHaveProperty('cond_d1f9fcc7f09847e79d314f5ee57ba985')
-      expect(context).toHaveProperty('cond_db43c6bc9ce6478b83454fff5eff2ba3')
-    })
-  })
-
-  describe('toConditionExpression', () => {
-    it('should handle V2 engine with display name replacement', () => {
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: joinedConditionsDefinition })
-
-      const model = new FormModel(joinedConditionsDefinition, {
-        basePath: 'test'
-      })
-
-      const joinedCondition =
-        model.conditions['db43c6bc-9ce6-478b-8345-4fff5eff2ba3']
-      expect(joinedCondition).toBeDefined()
-
-      const stateTrue = { userName: 'Bob', isOverEighteen: true }
-      const stateFalse = { userName: 'Alice', isOverEighteen: false }
-
-      expect(joinedCondition?.fn(stateTrue)).toBe(true)
-      expect(joinedCondition?.fn(stateFalse)).toBe(false)
-
-      expect(joinedCondition?.expr).toBeDefined()
-      expect(typeof joinedCondition?.expr.evaluate).toBe('function')
-    })
-
-    it('should handle V1 engine without display name replacement', () => {
-      const model = new FormModel(definition, { basePath: 'test' })
-
-      const condition = model.conditions.ZCXeMz
-      expect(condition).toBeDefined()
-      expect(condition?.expr).toBeDefined()
-
-      const testState = { NIJphU: "ap'ostrophe's", iraEpG: "shouldn't've" }
-      expect(condition?.fn(testState)).toBe(true)
-    })
-
-    it('should handle conditions without display names', () => {
-      const definitionWithoutDisplayName = {
-        ...joinedConditionsDefinition,
-        conditions: joinedConditionsDefinition.conditions.map((condition) => ({
-          ...condition,
-          displayName: condition.displayName || 'fallback'
-        }))
-      }
-
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: definitionWithoutDisplayName })
-
-      const model = new FormModel(definitionWithoutDisplayName, {
-        basePath: 'test'
-      })
-
-      expect(model.conditions).toBeDefined()
-      expect(Object.keys(model.conditions)).toHaveLength(3)
-    })
-  })
-
-  describe('getSection', () => {
-    it('should look up section by name for V1 schema', () => {
-      const v1Definition = {
-        ...definition,
-        sections: [
-          { name: 'personal', title: 'Personal details' },
-          { name: 'contact', title: 'Contact details' }
-        ]
-      }
-
-      const model = new FormModel(v1Definition, { basePath: 'test' })
-
-      expect(model.getSection('personal')).toEqual(
-        expect.objectContaining({
-          name: 'personal',
-          title: 'Personal details'
-        })
-      )
-      expect(model.getSection('contact')).toEqual(
-        expect.objectContaining({
-          name: 'contact',
-          title: 'Contact details'
-        })
-      )
-      expect(model.getSection('nonexistent')).toBeUndefined()
-    })
-
-    it('should look up section by ID for V2 schema', () => {
-      const v2Definition = {
-        ...definitionV2,
-        sections: [
-          {
-            id: 'a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d',
-            name: 'personal',
-            title: 'Personal details'
-          },
-          {
-            id: 'b2c3d4e5-6f7a-8b9c-0d1e-2f3a4b5c6d7e',
-            name: 'contact',
-            title: 'Contact details'
-          }
-        ]
-      }
-
-      formDefinitionV2Schema.validate = jest
-        .fn()
-        .mockReturnValue({ value: v2Definition })
-
-      const model = new FormModel(v2Definition, { basePath: 'test' })
-
-      expect(model.getSection('a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d')).toEqual(
-        expect.objectContaining({
-          id: 'a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d',
-          name: 'personal',
-          title: 'Personal details'
-        })
-      )
-      expect(model.getSection('b2c3d4e5-6f7a-8b9c-0d1e-2f3a4b5c6d7e')).toEqual(
-        expect.objectContaining({
-          id: 'b2c3d4e5-6f7a-8b9c-0d1e-2f3a4b5c6d7e',
-          name: 'contact',
-          title: 'Contact details'
-        })
-      )
-      // V2 should not find by name
-      expect(model.getSection('personal')).toBeUndefined()
-      expect(model.getSection('nonexistent')).toBeUndefined()
-    })
-  })
-})