static async request (externalId: string, countyCourtJudgment: CountyCourtJudgment, user: User): Promise<Claim> {
   return request.post(`${claimStoreApiUrl}/${externalId}/county-court-judgment`, {
     body: countyCourtJudgment,
     headers: {
       Authorization: `Bearer ${user.bearerToken}`
     }
   })
 }

 static async redetermination (externalId: string, reDetermination: ReDetermination, user: User, madeBy: MadeBy) {
   return request.post(`${claimStoreApiUrl}/${externalId}/re-determination`, {
     body: { explanation: reDetermination.text, partyType: madeBy.value },
     headers: {
       Authorization: `Bearer ${user.bearerToken}`
     }
   })
 }

  static calculatePostponedDeadline (issueDate: Moment): Promise<Moment> {
    const url: string = `${claimApiBaseUrl}/deadline`

    const from: string = MomentFormatter.formatDate(issueDate)

    return request.get(
      `${url}/${from}`
    ).then(response => MomentFactory.parse(response))
  }

  static calculateInterestRate (amount: number, rate: number, startDate: Moment, endDate: Moment): Promise<number> {
    const url: string = `${claimApiBaseUrl}/interest/calculate`

    const from: string = MomentFormatter.formatDate(startDate)
    const to: string = MomentFormatter.formatDate(endDate)

    return request.get(
      `${url}?from_date=${from}&to_date=${to}&amount=${amount}&rate=${rate}`
    ).then(response => response.amount)
  }

 static updateResponseDeadline (updateRequest: UpdateResponseDeadlineRequest, user: User) {
   if (FeatureToggles.isEnabled('testingSupport')) {
     return request.put(
       `${testingSupportUrl}/${updateRequest.claimNumber}/response-deadline/${updateRequest.date.asString()}`,
       {
         headers: {
           Authorization: `Bearer ${user.bearerToken}`
         }
       })
   } else {
     throw new Error('Testing support is not enabled')
   }
 }

 async update (user: User, paymentReference: string, caseReference: string, caseNumber: string): Promise<void> {
   checkDefined(user, 'User is required')
   checkNotEmpty(paymentReference, 'Payment reference is required')
   checkNotEmpty(caseReference, 'Case Reference is required')
   checkNotEmpty(caseNumber, 'Case Number is required')
   return request.patch({
     uri: `${paymentURL}/${paymentReference}`,
     body: this.preparePaymentUpdateRequest(caseReference, caseNumber),
     headers: {
       Authorization: `Bearer ${user.bearerToken}`,
       ServiceAuthorization: `Bearer ${this.serviceAuthToken.bearerToken}`
     }
   }).then(() => Promise.resolve())
     .catch(() => Promise.reject())
 }

  context('timeouts and retries handling', () => {
    const requestDelayInMillis = 500
    const retryAttempts = 3

    const retryingRequest = request.defaults({
      retryDelay: requestDelayInMillis,
      maxAttempts: retryAttempts
    } as RequestPromiseOptions)

    const claimStoreClient: ClaimStoreClient = new ClaimStoreClient(retryingRequest)

    describe('saveClaim', () => {
      function mockSuccessOnFirstSaveAttempt () {
        mock(`${claimStoreApiUrl}`)
          .post(`/${claimant.id}`)
          .reply(HttpStatus.OK, returnedClaim)
      }

      it('should retrieve a claim that was successfully saved on first attempt with feature toggles', async () => {
        mockSuccessOnFirstSaveAttempt()

        const claim: Claim = await claimStoreClient.saveClaim(claimDraft, claimant, 'admissions')

        expect(claim.claimData).to.deep.equal(new ClaimData().deserialize(expectedClaimData))
      })

      it('should retrieve a claim that was successfully saved on first attempt without feature toggles', async () => {
        mockSuccessOnFirstSaveAttempt()

        const claim: Claim = await claimStoreClient.saveClaim(claimDraft, claimant)

        expect(claim.claimData).to.deep.equal(new ClaimData().deserialize(expectedClaimData))
      })

      function mockTimeoutOnFirstSaveAttemptAndConflictOnSecondOne () {
        mock(`${claimStoreApiUrl}`)
          .post(`/${claimant.id}`)
          .socketDelay(requestDelayInMillis + 10)
        mock(`${claimStoreApiUrl}`)
          .post(`/${claimant.id}`)
          .reply(HttpStatus.CONFLICT, `Duplicate claim for external id ${claimDraftData.externalId}`)
        mock(`${claimStoreApiUrl}`)
          .get(`/${claimDraftData.externalId}`)
          .reply(HttpStatus.OK, returnedClaim)
      }

      it('should retrieve claim saved on first attempt that timed out and caused a 409 on retry', async () => {
        resolveLinkDefendant()
        mockTimeoutOnFirstSaveAttemptAndConflictOnSecondOne()

        const claim: Claim = await claimStoreClient.saveClaim(claimDraft, claimant, 'admissions')

        expect(claim.claimData).to.deep.equal(new ClaimData().deserialize(expectedClaimData))
      })

      function resolveLinkDefendant () {
        mock(`${claimStoreApiUrl}`)
          .put('/defendant/link')
          .reply(HttpStatus.OK)
      }

      function mockInternalServerErrorOnAllAttempts () {
        mock(`${claimStoreApiUrl}`)
          .post(`/${claimant.id}`)
          .times(retryAttempts)
          .reply(HttpStatus.INTERNAL_SERVER_ERROR, 'An unexpected error occurred')
      }

      it('should propagate error responses other than 409', async () => {
        mockInternalServerErrorOnAllAttempts()

        try {
          await claimStoreClient.saveClaim(claimDraft, claimant, 'admissions')
        } catch (err) {
          expect(err.statusCode).to.equal(HttpStatus.INTERNAL_SERVER_ERROR)
          expect(err.error).to.equal('An unexpected error occurred')
          return
        }

        expect.fail() // Exception should have been thrown due to 500 response code
      })
    })
  })

 static createPostcodeToCountryClient (): PostcodeToCountryClient {
   return new PostcodeToCountryClient(
     postcodeLookupApiKey,
     request.defaults(requestOptionsOverride)
   )
 }

 static createOSPlacesClient (): OSPlacesClient {
   return new OSPlacesClient(
     postcodeLookupApiKey,
     request.defaults(requestOptionsOverride)
   )
 }