@defra/forms-engine-plugin 2.0.2 → 2.1.0

package/src/server/plugins/engine/pageControllers/QuestionPageController.test.ts

@@ -1,6 +1,7 @@
 import { type PageQuestion } from '@defra/forms-model'
 import { type ResponseToolkit } from '@hapi/hapi'
 
+import { getCacheService } from '~/src/server/plugins/engine/helpers.js'
 import { FormModel } from '~/src/server/plugins/engine/models/FormModel.js'
 import { QuestionPageController } from '~/src/server/plugins/engine/pageControllers/QuestionPageController.js'
 import {
@@ -1333,63 +1334,127 @@ describe('Save and Return functionality', () => {
 
   describe('handleSaveAndReturn', () => {
     it('should save state and redirect to exit page', async () => {
+      const sessionPersisterMock = jest.fn()
       const state: FormSubmissionState = {
         $$__referenceNumber: 'foobar',
         yesNoField: true
       }
       const request = {
         ...requestPage1,
+        server: {
+          plugins: {
+            'forms-engine-plugin': {
+              saveAndReturn: {
+                sessionPersister: sessionPersisterMock
+              },
+              cacheService: {
+                clearState: jest.fn()
+              } as unknown as CacheService
+            }
+          }
+        },
         method: 'post',
         payload: { yesNoField: true, action: 'save-and-return' }
       } as unknown as FormRequestPayload
 
-      const context = model.getFormContext(request, state)
+      const cacheService = getCacheService(request.server)
 
-      jest.spyOn(controller1, 'setState').mockResolvedValue(state)
+      const context = model.getFormContext(request, state)
 
       await controller1.handleSaveAndReturn(request, context, h)
 
-      expect(controller1.setState).toHaveBeenCalledWith(request, state)
+      expect(sessionPersisterMock).toHaveBeenCalledWith(context.state, request)
+      expect(cacheService.clearState).toHaveBeenCalledWith(request)
       expect(h.redirect).toHaveBeenCalledWith('/test/exit')
     })
 
-    it('should handle save-and-return with incomplete data', async () => {
+    it('should throw if sessionPersister inside saveAndReturn options provided', async () => {
+      const sessionPersisterMock = jest.fn()
       const state: FormSubmissionState = {
         $$__referenceNumber: 'foobar',
-        yesNoField: null
+        yesNoField: true
       }
       const request = {
         ...requestPage1,
+        server: {
+          plugins: {
+            'forms-engine-plugin': {
+              // No sessionPersister object
+              saveAndReturn: {}
+            }
+          }
+        },
         method: 'post',
-        payload: { yesNoField: '', action: 'save-and-return' }
+        payload: { yesNoField: true, action: 'save-and-return' }
       } as unknown as FormRequestPayload
 
       const context = model.getFormContext(request, state)
 
-      jest.spyOn(controller1, 'setState').mockResolvedValue(state)
+      await expect(
+        controller1.handleSaveAndReturn(request, context, h)
+      ).rejects.toThrow('Server misconfigured for save and return')
 
-      await controller1.handleSaveAndReturn(request, context, h)
+      expect(sessionPersisterMock).not.toHaveBeenCalled()
+      expect(h.redirect).not.toHaveBeenCalled()
+    })
 
-      expect(controller1.setState).toHaveBeenCalledWith(request, state)
-      expect(h.redirect).toHaveBeenCalledWith('/test/exit')
+    it('should throw if no saveAndReturn options provided', async () => {
+      const sessionPersisterMock = jest.fn()
+      const state: FormSubmissionState = {
+        $$__referenceNumber: 'foobar',
+        yesNoField: true
+      }
+      const request = {
+        ...requestPage1,
+        server: {
+          plugins: {
+            'forms-engine-plugin': {
+              // No saveAndReturn object
+            }
+          }
+        },
+        method: 'post',
+        payload: { yesNoField: true, action: 'save-and-return' }
+      } as unknown as FormRequestPayload
+
+      const context = model.getFormContext(request, state)
+
+      await expect(
+        controller1.handleSaveAndReturn(request, context, h)
+      ).rejects.toThrow('Server misconfigured for save and return')
+
+      expect(sessionPersisterMock).not.toHaveBeenCalled()
+      expect(h.redirect).not.toHaveBeenCalled()
     })
 
-    it('should handle save-and-return with validation errors', async () => {
+    it('should throw if sessionPersister throws as well with validation errors', async () => {
+      const sessionPersisterMock = jest.fn().mockImplementation(() => {
+        throw new Error('Session persister error')
+      })
       const state: FormSubmissionState = { $$__referenceNumber: 'foobar' }
       const request = {
         ...requestPage1,
         method: 'post',
+        server: {
+          plugins: {
+            'forms-engine-plugin': {
+              saveAndReturn: {
+                sessionPersister: sessionPersisterMock
+              }
+            }
+          }
+        },
         payload: { action: 'save-and-return' }
       } as unknown as FormRequestPayload
 
       const context = model.getFormContext(request, state)
 
-      jest.spyOn(controller1, 'setState').mockResolvedValue(state)
-
-      await controller1.handleSaveAndReturn(request, context, h)
+      await expect(
+        controller1.handleSaveAndReturn(request, context, h)
+      ).rejects.toThrow('Session persister error')
 
-      expect(controller1.setState).toHaveBeenCalledWith(request, state)
-      expect(h.redirect).toHaveBeenCalledWith('/test/exit')
+      expect(sessionPersisterMock).toHaveBeenCalledWith(context.state, request)
+      expect(h.redirect).not.toHaveBeenCalledWith('/test/exit')
     })
   })
 

package/src/server/plugins/engine/pageControllers/QuestionPageController.ts

@@ -8,6 +8,7 @@ import {
   type Link,
   type Page
 } from '@defra/forms-model'
+import Boom from '@hapi/boom'
 import { type ResponseToolkit, type RouteOptions } from '@hapi/hapi'
 import { type ValidationErrorItem } from 'joi'
 
@@ -17,6 +18,7 @@ import { type BackLink } from '~/src/server/plugins/engine/components/types.js'
 import {
   getCacheService,
   getErrors,
+  getSaveAndReturnHelpers,
   normalisePath,
   proceed
 } from '~/src/server/plugins/engine/helpers.js'
@@ -548,7 +550,17 @@ export class QuestionPageController extends PageController {
     const { state } = context
 
     // Save the current state and redirect to exit page
-    await this.setState(request, state)
+    const saveAndReturn = getSaveAndReturnHelpers(request.server)
+
+    if (!saveAndReturn?.sessionPersister) {
+      throw Boom.internal('Server misconfigured for save and return')
+    }
+
+    await saveAndReturn.sessionPersister(state, request)
+
+    const cacheService = getCacheService(request.server)
+    await cacheService.clearState(request)
+
     return h.redirect(this.getHref('/exit'))
   }
 

package/src/server/plugins/engine/plugin.ts

@@ -43,8 +43,7 @@ export const plugin = {
       cacheName,
       options: {
         keyGenerator: saveAndReturn?.keyGenerator,
-        sessionHydrator: saveAndReturn?.sessionHydrator,
-        sessionPersister: saveAndReturn?.sessionPersister
+        sessionHydrator: saveAndReturn?.sessionHydrator
       }
     })
 

package/src/server/plugins/engine/routes/questions.test.ts

@@ -0,0 +1,416 @@
+import Boom from '@hapi/boom'
+import { type ResponseObject, type ResponseToolkit } from '@hapi/hapi'
+// eslint-disable-next-line n/no-unpublished-import
+import nock from 'nock'
+
+import { type FormModel } from '~/src/server/plugins/engine/models/FormModel.js'
+import { type PageControllerClass } from '~/src/server/plugins/engine/pageControllers/helpers.js'
+import { redirectOrMakeHandler } from '~/src/server/plugins/engine/routes/index.js'
+import {
+  makeGetHandler,
+  makePostHandler
+} from '~/src/server/plugins/engine/routes/questions.js'
+import { type FormContext } from '~/src/server/plugins/engine/types.js'
+import {
+  type FormRequest,
+  type FormRequestPayload
+} from '~/src/server/routes/types.js'
+jest.mock('~/src/server/plugins/engine/models/SummaryViewModel', () => ({
+  SummaryViewModel: class {
+    summary = 'mocked summary'
+  }
+}))
+
+jest.mock(
+  '~/src/server/plugins/engine/pageControllers/SummaryPageController',
+  () => ({
+    getFormSubmissionData: jest.fn().mockReturnValue([])
+  })
+)
+
+jest.mock('~/src/server/plugins/engine/outputFormatters/machine/v1', () => ({
+  format: jest.fn().mockReturnValue('mocked format')
+}))
+
+jest.mock('~/src/server/plugins/engine/routes/index')
+
+describe('makeGetHandler', () => {
+  const hMock: Pick<ResponseToolkit, 'redirect' | 'view'> = {
+    redirect: jest.fn(),
+    view: jest.fn()
+  }
+
+  beforeEach(() => {
+    nock('http://test').persist().post('/load').reply(200, {
+      wasGetCalled: true
+    })
+  })
+
+  afterEach(() => {
+    jest.mocked(redirectOrMakeHandler).mockRestore()
+    nock.cleanAll()
+  })
+
+  it('calls the callback when events.onLoad.type is http', async () => {
+    let data = {}
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        data = context.data
+        return Promise.resolve({} as unknown as ResponseObject)
+      }
+    )
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: { model: modelMock }
+    } as FormRequest
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => Promise.resolve(fn(pageMock, contextMock))
+      )
+
+    await makeGetHandler()(requestMock, hMock)
+
+    expect(data).toMatchObject({
+      wasGetCalled: true
+    })
+  })
+
+  it('does not call the callback when the events.onLoad.type is not http', async () => {
+    let data = {}
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        data = context.data
+        return Promise.resolve({} as unknown as ResponseObject)
+      }
+    )
+
+    pageMock.events = {}
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: { model: modelMock }
+    } as FormRequest
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => Promise.resolve(fn(pageMock, contextMock))
+      )
+
+    await makeGetHandler()(requestMock, hMock)
+
+    expect(data).toMatchObject({})
+  })
+
+  it('throws when model is missing', async () => {
+    let error
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        _context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        return Promise.resolve({} as unknown as ResponseObject)
+      }
+    )
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: {}
+    } as FormRequest
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        async (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => {
+          try {
+            await fn(pageMock, contextMock)
+          } catch (err) {
+            error = err
+          }
+
+          return Promise.resolve({} as unknown as ResponseObject)
+        }
+      )
+
+    await makeGetHandler()(requestMock, hMock)
+
+    expect(error).toEqual(Boom.notFound('No model found for /some-path'))
+  })
+})
+
+describe('makePostHandler', () => {
+  const hMock: Pick<ResponseToolkit, 'redirect' | 'view'> = {
+    redirect: jest.fn(),
+    view: jest.fn()
+  }
+
+  beforeEach(() => {
+    nock('http://test').post('/save').reply(200, {
+      wasPostCalled: true
+    })
+  })
+
+  afterEach(() => {
+    jest.mocked(redirectOrMakeHandler).mockRestore()
+    nock.cleanAll()
+  })
+
+  it('calls the callback when events.onSave.type is http and the page controller was successful', async () => {
+    const mockPostResponse: ResponseObject = {
+      statusCode: 200
+    } as ResponseObject
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        _context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        // do return a valid ResponseObject wrapped in Promise.resolve
+        return mockPostResponse
+      }
+    )
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: { model: modelMock },
+      payload: { some: 'payload' }
+    } as unknown as FormRequestPayload
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => Promise.resolve(fn(pageMock, contextMock))
+      )
+
+    const response = await makePostHandler()(requestMock, hMock)
+
+    expect(nock.pendingMocks()).toBeEmpty()
+    expect(response).toBe(mockPostResponse)
+  })
+
+  it('does not call the callback when the events.onSave.type is not http', async () => {
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        _context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        return Promise.resolve({} as unknown as ResponseObject)
+      }
+    )
+
+    pageMock.events = {}
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: { model: modelMock },
+      payload: { some: 'payload' }
+    } as unknown as FormRequestPayload
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => Promise.resolve(fn(pageMock, contextMock))
+      )
+
+    await makePostHandler()(requestMock, hMock)
+
+    expect(nock.pendingMocks()).not.toBeEmpty()
+  })
+
+  it('does not call the callback when events.onSave.type is http and the page controller was unsuccessful', async () => {
+    const mockPostResponse: ResponseObject = {
+      statusCode: 500
+    } as ResponseObject
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        _context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        // do return a valid ResponseObject wrapped in Promise.resolve
+        return mockPostResponse
+      }
+    )
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: { model: modelMock },
+      payload: { some: 'payload' }
+    } as unknown as FormRequestPayload
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => Promise.resolve(fn(pageMock, contextMock))
+      )
+
+    await makePostHandler()(requestMock, hMock)
+
+    expect(nock.pendingMocks()).not.toBeEmpty()
+  })
+
+  it('throws when model is missing', async () => {
+    let error
+
+    const modelMock = {
+      basePath: 'some-base-path',
+      def: { name: 'Hello world' }
+    } as FormModel
+
+    const pageMock = createMockPageController(
+      modelMock,
+      (
+        _request: FormRequest,
+        _context: FormContext,
+        _h: Pick<ResponseToolkit, 'redirect' | 'view'>
+      ) => {
+        return Promise.resolve({} as unknown as ResponseObject)
+      }
+    )
+
+    const contextMock = { data: {}, model: {} } as unknown as FormContext
+
+    const requestMock = {
+      params: { path: 'some-path' },
+      app: {},
+      payload: { some: 'payload' }
+    } as unknown as FormRequestPayload
+
+    jest
+      .mocked(redirectOrMakeHandler)
+      .mockImplementation(
+        async (
+          _req: FormRequest | FormRequestPayload,
+          _h: Pick<ResponseToolkit, 'redirect' | 'view'>,
+          fn
+        ) => {
+          try {
+            await fn(pageMock, contextMock)
+          } catch (err) {
+            error = err
+          }
+
+          return Promise.resolve({} as unknown as ResponseObject)
+        }
+      )
+
+    await makePostHandler()(requestMock, hMock)
+
+    expect(error).toEqual(Boom.notFound('No model found for /some-path'))
+  })
+})
+
+function createMockPageController(
+  model: FormModel,
+  routeHandler: (
+    request: FormRequest,
+    context: FormContext,
+    h: Pick<ResponseToolkit, 'redirect' | 'view'>
+  ) => ResponseObject | Promise<ResponseObject>
+): PageControllerClass {
+  return {
+    model,
+    events: {
+      onLoad: {
+        type: 'http',
+        options: { method: 'POST', url: 'http://test/load' }
+      },
+      onSave: {
+        type: 'http',
+        options: { method: 'POST', url: 'http://test/save' }
+      }
+    },
+    makeGetRouteHandler: () => routeHandler,
+    makePostRouteHandler: () => routeHandler
+  } as unknown as PageControllerClass
+}