describe('on GET', () => {
    checkAuthorizationGuards(app, 'get', ClaimPaths.confirmationPage.evaluateUri({ externalId: externalId }))

    describe('for authorized user', () => {
      beforeEach(() => {
        idamServiceMock.resolveRetrieveUserFor('1', 'citizen')
      })

      it('should return 500 and render error page when cannot retrieve claim by external id', async () => {
        claimStoreServiceMock.rejectRetrieveClaimByExternalId('HTTP error')

        await request(app)
          .get(ClaimPaths.confirmationPage.evaluateUri({ externalId: externalId }))
          .set('Cookie', `${cookieName}=ABC`)
          .expect(res => expect(res).to.be.serverError.withText('Error'))
      })

      it('should render page when everything is fine', async () => {
        claimStoreServiceMock.resolveRetrieveClaimByExternalId()

        await request(app)
          .get(ClaimPaths.confirmationPage.evaluateUri({ externalId: externalId }))
          .set('Cookie', `${cookieName}=ABC`)
          .expect(res => expect(res).to.be.successful.withText('Claim submitted'))
      })

    })
  })

      it('should render page when everything is fine', async () => {
        claimStoreServiceMock.resolveRetrieveClaimByExternalId()

        await request(app)
          .get(ClaimPaths.confirmationPage.evaluateUri({ externalId: externalId }))
          .set('Cookie', `${cookieName}=ABC`)
          .expect(res => expect(res).to.be.successful.withText('Claim submitted'))
      })

  .get(Paths.finishPaymentReceiver.uri, async (req, res, next) => {
    const draft: Draft<DraftClaim> = res.locals.claimDraft
    const user: User = res.locals.user

    try {
      const { externalId } = req.params

      const paymentReference = draft.document.claimant.payment.reference
      if (!paymentReference) {
        return res.redirect(Paths.confirmationPage.evaluateUri({ externalId: externalId }))
      }
      const payClient = await getPayClient(req)

      const payment: PaymentRetrieveResponse = await payClient.retrieve(user, paymentReference)
      draft.document.claimant.payment = payment

      await new DraftService().save(draft, user.bearerToken)

      const status: string = payment.status
      // https://gds-payments.gelato.io/docs/versions/1.0.0/api-reference
      switch (status) {
        case 'Cancelled':
        case 'Failed':
          logPaymentError(user.id, payment)
          res.redirect(Paths.checkAndSendPage.uri)
          break
        case 'Success':
          await successHandler(req, res, next)
          break
        default:
          logPaymentError(user.id, payment)
          next(new Error(`Payment failed. Status ${status} is returned by the service`))
      }
    } catch (err) {
      const { externalId } = req.params
      trackCustomEvent(`Post payment error for externalId: ${externalId}`,{
        externalId: externalId,
        payment: draft.document.claimant.payment,
        error: err
      })
      logPaymentError(user.id, draft.document.claimant.payment)
      next(err)
    }
  })

async function successHandler (req, res, next) {
  const draft: Draft<DraftClaim> = res.locals.claimDraft
  const user: User = res.locals.user
  const externalId: string = draft.document.externalId
  let savedClaim: Claim

  try {
    const roles: string[] = await claimStoreClient.retrieveUserRoles(user)

    if (!roles.length) {
      logger.error(`missing consent not given role for user, User Id : ${user.id}`)
    }

    let features: string
    if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_admissions')) {
      features = 'admissions'
    }

    if (draft.document.amount.totalAmount() <= 300) {
      if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_directions_questionnaire')) {
        features += features === undefined ? 'directionsQuestionnaire' : ', directionsQuestionnaire'
      }
    }

    if (draft.document.amount.totalAmount() <= 300) {
      if (await featureTogglesClient.isFeatureToggleEnabled(user, roles, 'cmc_mediation_pilot')) {
        features += features === undefined ? 'mediationPilot' : ', mediationPilot'
      }
    }

    savedClaim = await claimStoreClient.saveClaim(draft, user, features)

  } catch (err) {
    if (err.statusCode === HttpStatus.INTERNAL_SERVER_ERROR || err.statusCode === HttpStatus.SERVICE_UNAVAILABLE) {
      logError(
        user.id,
        draft.document.claimant.payment,
        `Payment processed successfully but there was a problem saving claim '${externalId}' to the claim store.`
      )
      trackCustomEvent(`Post payment successful but unable to store claim in claim-store with externalId: ${externalId}`,
        {
          externalId: externalId,
          payment: draft.document.claimant.payment,
          error: err
        })
      next(err)
      return
    } else if (err.statusCode === HttpStatus.CONFLICT) {
      logError(
        user.id,
        draft.document.claimant.payment,
        `Payment processed successfully and claim ${externalId} already exists.`
      )
      savedClaim = await claimStoreClient.retrieveByExternalId(externalId, user)
    }
  }
  const payClient: PayClient = await getPayClient(req)
  const paymentReference = draft.document.claimant.payment.reference

  if (savedClaim) {
    const ccdCaseNumber = savedClaim.ccdCaseId === undefined ? 'UNKNOWN' : String(savedClaim.ccdCaseId)
    await payClient.update(user, paymentReference, savedClaim.externalId, ccdCaseNumber)
  }

  await new DraftService().delete(draft.id, user.bearerToken)
  res.redirect(Paths.confirmationPage.evaluateUri({ externalId: externalId }))
}