@defra/forms-engine-plugin 4.7.2 → 4.7.3

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

@@ -1,332 +0,0 @@
-import { type Page } from '@defra/forms-model'
-import Boom from '@hapi/boom'
-import { type ResponseObject, type ResponseToolkit } from '@hapi/hapi'
-
-import {
-  findPage,
-  getCacheService,
-  getPage,
-  proceed
-} from '~/src/server/plugins/engine/helpers.js'
-import { type FormModel } from '~/src/server/plugins/engine/models/FormModel.js'
-import { type PageControllerClass } from '~/src/server/plugins/engine/pageControllers/helpers/pages.js'
-import { redirectOrMakeHandler } from '~/src/server/plugins/engine/routes/index.js'
-import {
-  type AnyFormRequest,
-  type OnRequestCallback
-} from '~/src/server/plugins/engine/types.js'
-import { type FormResponseToolkit } from '~/src/server/routes/types.js'
-import { type Services } from '~/src/server/types.js'
-
-jest.mock('~/src/server/plugins/engine/helpers')
-
-function buildMockModel(
-  pagesOverride = [] as Page[],
-  pagesControllerOverride = [] as PageControllerClass[],
-  servicesOverride = {} as Services
-) {
-  return {
-    def: {
-      metadata: {
-        submission: { code: 'TEST-CODE' }
-      } as { submission: { code: string } },
-      pages: pagesOverride
-    },
-    getFormContext: jest.fn().mockReturnValue({
-      isForceAccess: false,
-      data: {}
-    }),
-    pages: pagesControllerOverride,
-    services: servicesOverride
-  } as unknown as FormModel
-}
-
-describe('redirectOrMakeHandler', () => {
-  const mockServer = {} as unknown as Parameters<
-    typeof redirectOrMakeHandler
-  >[0]['server']
-  const mockRequest: AnyFormRequest = {
-    server: mockServer,
-    app: {},
-    yar: { flash: () => [] },
-    params: { path: 'test-path' },
-    query: {}
-  } as unknown as AnyFormRequest
-
-  const mockH: FormResponseToolkit = {
-    redirect: jest.fn(),
-    view: jest.fn(),
-    continue: Symbol('continue')
-  } as unknown as FormResponseToolkit
-
-  let mockPage: PageControllerClass
-
-  const mockModel = buildMockModel()
-
-  const mockMakeHandler = jest
-    .fn()
-    .mockResolvedValue({ statusCode: 200 } as ResponseObject)
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockRequest.app = { model: mockModel }
-
-    // Reset mock page
-    mockPage = {
-      getState: jest.fn().mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-      mergeState: jest
-        .fn()
-        .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-      getRelevantPath: jest.fn().mockReturnValue('/test-path'),
-      getSummaryPath: jest.fn().mockReturnValue('/summary'),
-      getHref: jest.fn().mockReturnValue('/test-href'),
-      path: '/test-path'
-    } as unknown as PageControllerClass
-
-    // Reset mock model
-    mockModel.getFormContext = jest.fn().mockReturnValue({
-      isForceAccess: false,
-      data: {},
-      state: {}
-    })
-
-    // Setup mocks
-    ;(getCacheService as jest.Mock).mockReturnValue({
-      getFlash: jest.fn().mockReturnValue({ errors: [] })
-    })
-    ;(getPage as jest.Mock).mockReturnValue(mockPage)
-    ;(findPage as jest.Mock).mockReturnValue({ next: [] })
-    ;(proceed as jest.Mock).mockReturnValue({ statusCode: 302 })
-  })
-
-  describe('onRequest callback functionality', () => {
-    it('should call onRequest callback when provided', async () => {
-      const onRequestCallback: OnRequestCallback = jest
-        .fn()
-        .mockResolvedValue(undefined)
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        onRequestCallback,
-        mockMakeHandler
-      )
-
-      expect(onRequestCallback).toHaveBeenCalledWith(
-        mockRequest,
-        mockH as ResponseToolkit,
-        expect.objectContaining({
-          isForceAccess: false,
-          data: {}
-        })
-      )
-    })
-
-    it('should not call onRequest callback when not provided', async () => {
-      const onRequestCallback = jest.fn()
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      expect(onRequestCallback).not.toHaveBeenCalled()
-    })
-
-    it('should return takeover response when onRequest returns takeover response', async () => {
-      const takeoverResponse = {
-        statusCode: 302,
-        headers: { location: '/redirect-url' },
-        _takeover: true
-      } as unknown as ResponseObject
-
-      const onRequestCallback: OnRequestCallback = jest
-        .fn()
-        .mockResolvedValue(takeoverResponse)
-
-      const result = await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        onRequestCallback,
-        mockMakeHandler
-      )
-
-      expect(result).toBe(takeoverResponse)
-      expect(mockMakeHandler).not.toHaveBeenCalled()
-    })
-
-    it('should continue processing when onRequest returns h.continue', async () => {
-      const onRequestCallback: OnRequestCallback = jest
-        .fn()
-        .mockResolvedValue(mockH.continue)
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        onRequestCallback,
-        mockMakeHandler
-      )
-
-      expect(mockMakeHandler).toHaveBeenCalledWith(mockPage, expect.any(Object))
-    })
-
-    it('should handle onRequest callback errors', async () => {
-      const error = new Error('onRequest callback error')
-      const onRequestCallback: OnRequestCallback = jest
-        .fn()
-        .mockRejectedValue(error)
-
-      await expect(
-        redirectOrMakeHandler(
-          mockRequest,
-          mockH,
-          onRequestCallback,
-          mockMakeHandler
-        )
-      ).rejects.toThrow('onRequest callback error')
-    })
-  })
-
-  describe('existing functionality', () => {
-    it('should throw error when model is missing', async () => {
-      mockRequest.app = {}
-
-      await expect(
-        redirectOrMakeHandler(mockRequest, mockH, undefined, mockMakeHandler)
-      ).rejects.toThrow(Boom.notFound('No model found for /test-path'))
-    })
-
-    it('should call makeHandler when page is relevant', async () => {
-      const testPage = {
-        getState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        mergeState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        getSummaryPath: jest.fn().mockReturnValue('/summary'),
-        getHref: jest.fn().mockReturnValue('/test-href'),
-        getRelevantPath: jest.fn().mockReturnValue('/test-path'),
-        path: '/test-path'
-      } as unknown as PageControllerClass
-      ;(getPage as jest.Mock).mockReturnValue(testPage)
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      expect(mockMakeHandler).toHaveBeenCalledWith(testPage, expect.any(Object))
-    })
-
-    it('should call makeHandler when context has force access', async () => {
-      mockModel.getFormContext = jest.fn().mockReturnValue({
-        isForceAccess: true,
-        data: {},
-        state: {}
-      })
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      expect(mockMakeHandler).toHaveBeenCalledWith(mockPage, expect.any(Object))
-    })
-
-    it('should redirect when page is not relevant', async () => {
-      const testPage = {
-        getState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        mergeState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        getSummaryPath: jest.fn().mockReturnValue('/summary'),
-        getHref: jest.fn().mockReturnValue('/test-href'),
-        getRelevantPath: jest.fn().mockReturnValue('/other-path'),
-        path: '/test-path'
-      } as unknown as PageControllerClass
-      ;(getPage as jest.Mock).mockReturnValue(testPage)
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      expect(proceed).toHaveBeenCalledWith(mockRequest, mockH, '/test-href')
-      expect(mockMakeHandler).not.toHaveBeenCalled()
-    })
-
-    it('should set returnUrl when redirecting and next pages exist', async () => {
-      const testPage = {
-        getState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        mergeState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        getSummaryPath: jest.fn().mockReturnValue('/summary'),
-        getRelevantPath: jest.fn().mockReturnValue('/other-path'),
-        path: '/test-path',
-        getHref: jest
-          .fn()
-          .mockReturnValueOnce('/summary-href') // First call: for summaryPath (returnUrl)
-          .mockReturnValueOnce('/relevant-path-href') // Second call: for relevantPath (redirect)
-      } as unknown as PageControllerClass
-      ;(getPage as jest.Mock).mockReturnValue(testPage)
-      ;(findPage as jest.Mock).mockReturnValue({ next: ['next-page'] })
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      expect(mockRequest.query.returnUrl).toBe('/summary-href')
-      expect(proceed).toHaveBeenCalledWith(
-        mockRequest,
-        mockH,
-        '/relevant-path-href'
-      )
-    })
-
-    it('should not set returnUrl when redirecting and no next pages exist', async () => {
-      const testPage = {
-        getState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        mergeState: jest
-          .fn()
-          .mockResolvedValue({ $$__referenceNumber: 'REF-123' }),
-        getSummaryPath: jest.fn().mockReturnValue('/summary'),
-        getHref: jest.fn().mockReturnValue('/test-href'),
-        getRelevantPath: jest.fn().mockReturnValue('/other-path'),
-        path: '/test-path'
-      } as unknown as PageControllerClass
-      ;(getPage as jest.Mock).mockReturnValue(testPage)
-      const returnUrlBefore = mockRequest.query.returnUrl
-      ;(findPage as jest.Mock).mockReturnValue({ next: [] })
-
-      await redirectOrMakeHandler(
-        mockRequest,
-        mockH,
-        undefined,
-        mockMakeHandler
-      )
-
-      // returnUrl should not be set if next pages don't exist
-      expect(mockRequest.query.returnUrl).toBe(returnUrlBefore)
-      expect(proceed).toHaveBeenCalledWith(mockRequest, mockH, '/test-href')
-    })
-  })
-})

package/src/server/plugins/engine/routes/payment-helper.test.js

@@ -1,136 +0,0 @@
-import {
-  buildPaymentInfo,
-  getPaymentContext
-} from '~/src/server/plugins/engine/routes/payment-helper.js'
-import { get } from '~/src/server/services/httpService.js'
-
-jest.mock('~/src/server/services/httpService.ts')
-
-describe('payment helper', () => {
-  const uuid = '5a54c2fe-da49-4202-8cd3-2121eaca03c3'
-  it('should throw if no session', async () => {
-    const mockRequest = {
-      yar: {
-        get: jest.fn().mockReturnValueOnce(undefined)
-      }
-    }
-    // @ts-expect-error - partial request mock
-    await expect(() => getPaymentContext(mockRequest, uuid)).rejects.toThrow(
-      'No payment session found for uuid=5a54c2fe-da49-4202-8cd3-2121eaca03c3'
-    )
-  })
-
-  it('should throw if no payment id', async () => {
-    const mockRequest = {
-      yar: {
-        get: jest.fn().mockReturnValueOnce({})
-      }
-    }
-    // @ts-expect-error - partial request mock
-    await expect(() => getPaymentContext(mockRequest, uuid)).rejects.toThrow(
-      'No paymentId in session'
-    )
-  })
-
-  it('should get context successfully', async () => {
-    const mockRequest = {
-      yar: {
-        get: jest.fn().mockReturnValueOnce({
-          paymentId: 'payment-id',
-          isLivePayment: false,
-          formId: 'formid'
-        })
-      }
-    }
-
-    const getPaymentStatusApiResult = {
-      payment_id: 'payment-id-12345',
-      _links: {
-        next_url: {
-          href: 'http://next-url-href/payment'
-        }
-      },
-      state: {
-        status: 'created'
-      }
-    }
-
-    jest.mocked(get).mockResolvedValueOnce({
-      res: /** @type {IncomingMessage} */ ({
-        statusCode: 200,
-        headers: {}
-      }),
-      payload: getPaymentStatusApiResult,
-      error: undefined
-    })
-
-    const mockFormsService = {
-      getFormSecret: () => 'secret-value'
-    }
-    // @ts-expect-error - partial request mock
-    const res = await getPaymentContext(mockRequest, uuid, mockFormsService)
-    expect(res).toEqual({
-      paymentStatus: {
-        paymentId: 'payment-id-12345',
-        _links: {
-          next_url: {
-            href: 'http://next-url-href/payment'
-          }
-        },
-        state: {
-          status: 'created'
-        }
-      },
-      session: {
-        formId: 'formid',
-        isLivePayment: false,
-        paymentId: 'payment-id'
-      },
-      sessionKey: 'payment-5a54c2fe-da49-4202-8cd3-2121eaca03c3'
-    })
-  })
-
-  it('should create logging info for a test payment', () => {
-    const res = buildPaymentInfo(
-      'action1',
-      'outcome1',
-      'reason1',
-      false,
-      'pay-123'
-    )
-    expect(res).toEqual({
-      event: {
-        category: 'payment',
-        action: 'action1',
-        outcome: 'outcome1',
-        reason: 'reason1',
-        type: 'test',
-        reference: 'pay-123'
-      }
-    })
-  })
-
-  it('should create logging info for a live payment', () => {
-    const res = buildPaymentInfo(
-      'action2',
-      'outcome2',
-      'reason2',
-      true,
-      'pay-123'
-    )
-    expect(res).toEqual({
-      event: {
-        category: 'payment',
-        action: 'action2',
-        outcome: 'outcome2',
-        reason: 'reason2',
-        type: 'live',
-        reference: 'pay-123'
-      }
-    })
-  })
-})
-
-/**
- * @import  { IncomingMessage } from 'node:http'
- */

package/src/server/plugins/engine/routes/payment.test.js

@@ -1,180 +0,0 @@
-import { StatusCodes } from 'http-status-codes'
-
-import { createServer } from '~/src/server/index.js'
-import { getPaymentContext } from '~/src/server/plugins/engine/routes/payment-helper.js'
-import { renderResponse } from '~/test/helpers/component-helpers.js'
-
-jest.mock('~/src/server/plugins/engine/routes/payment-helper.js')
-
-describe('Payment routes', () => {
-  /** @type {Server} */
-  let server
-
-  beforeAll(async () => {
-    server = await createServer()
-    await server.initialize()
-  })
-
-  beforeEach(() => {
-    jest.resetAllMocks()
-  })
-
-  describe('Return route /payment-callback', () => {
-    const uuid = '06a5b11e-e3e0-48a2-8ac3-56c0fcb6c20d'
-    const options = {
-      method: 'get',
-      url: `/payment-callback?uuid=${uuid}`
-    }
-
-    const paymentSessionData = {
-      uuid,
-      formId: 'form-id',
-      reference: 'form-ref-123',
-      paymentId: 'payment-id',
-      amount: 123,
-      description: 'Payment desc',
-      isLivePayment: false,
-      componentName: 'my-component',
-      returnUrl: 'http://host.com/return-url',
-      failureUrl: 'http://host.com/failure-url'
-    }
-    const sessionKey = 'session-key'
-
-    test.each([
-      { status: 'capturable', finalUrl: 'http://host.com/return-url' },
-      { status: 'success', finalUrl: 'http://host.com/return-url' },
-      { status: 'cancelled', finalUrl: 'http://host.com/failure-url' },
-      { status: 'failed', finalUrl: 'http://host.com/failure-url' },
-      { status: 'error', finalUrl: 'http://host.com/failure-url' },
-      { status: 'created', finalUrl: '/next-url' },
-      { status: 'started', finalUrl: '/next-url' },
-      { status: 'submitted', finalUrl: '/next-url' }
-    ])('should handle payment status of $row.status', async (row) => {
-      const paymentStatus = {
-        paymentId: 'new-payment-id',
-        amount: 125,
-        _links: {
-          next_url: {
-            href: '/next-url',
-            method: 'get'
-          },
-          self: {
-            href: '/self',
-            method: 'get'
-          }
-        },
-        state: /** @type {PaymentResponseState} */ ({
-          status: row.status,
-          finished: true
-        })
-      }
-      jest.mocked(getPaymentContext).mockResolvedValueOnce({
-        session: paymentSessionData,
-        sessionKey,
-        paymentStatus
-      })
-      const { response } = await renderResponse(server, options)
-
-      expect(response.statusCode).toBe(StatusCodes.SEE_OTHER)
-      expect(response.headers.location).toBe(row.finalUrl)
-    })
-
-    it('should throw if nextUrl is missing', async () => {
-      const paymentStatus = {
-        paymentId: 'new-payment-id',
-        _links: {
-          next_url: {},
-          self: {
-            href: '/self',
-            method: 'get'
-          }
-        },
-        state: /** @type {PaymentResponseState} */ ({
-          status: 'created',
-          finished: true
-        })
-      }
-      jest.mocked(getPaymentContext).mockResolvedValueOnce({
-        session: paymentSessionData,
-        sessionKey,
-        // @ts-expect-error - deliberate missing element from object
-        paymentStatus
-      })
-      const { response } = await renderResponse(server, options)
-
-      expect(response.statusCode).toBe(StatusCodes.BAD_REQUEST)
-      // @ts-expect-error - error object
-      expect(response.result?.message).toBe(
-        "Payment in state 'created' but no next_url available"
-      )
-    })
-
-    it('should throw if invalid status', async () => {
-      const paymentStatus = {
-        paymentId: 'new-payment-id',
-        _links: {
-          next_url: {
-            href: '/next-url',
-            method: 'get'
-          },
-          self: {
-            href: '/self',
-            method: 'get'
-          }
-        },
-        state: {
-          status: 'invalid',
-          finished: true
-        }
-      }
-      jest.mocked(getPaymentContext).mockResolvedValueOnce({
-        session: paymentSessionData,
-        sessionKey,
-        // @ts-expect-error - deliberate invalid value which doesnt meet type
-        paymentStatus
-      })
-      const { response } = await renderResponse(server, options)
-
-      expect(response.statusCode).toBe(StatusCodes.INTERNAL_SERVER_ERROR)
-      // @ts-expect-error - error object
-      expect(response.result?.message).toBe('Unknown payment status: invalid')
-    })
-
-    it('should handle payment with email from GOV.UK Pay response', async () => {
-      const paymentStatus = {
-        paymentId: 'new-payment-id',
-        payment_id: 'new-payment-id',
-        amount: 125,
-        email: 'payer@example.com',
-        _links: {
-          next_url: {
-            href: '/next-url',
-            method: 'get'
-          },
-          self: {
-            href: '/self',
-            method: 'get'
-          }
-        },
-        state: /** @type {PaymentResponseState} */ ({
-          status: 'success',
-          finished: true
-        })
-      }
-      jest.mocked(getPaymentContext).mockResolvedValueOnce({
-        session: paymentSessionData,
-        sessionKey,
-        paymentStatus
-      })
-      const { response } = await renderResponse(server, options)
-
-      expect(response.statusCode).toBe(StatusCodes.SEE_OTHER)
-      expect(response.headers.location).toBe('http://host.com/return-url')
-    })
-  })
-})
-
-/**
- * @import { Server } from '@hapi/hapi'
- * @import { PaymentResponseState } from '~/src/server/plugins/payment/types.js'
- */