it('should create DEFENDANT decision when defendant payment intention is most reasonable with pay by instalments', () => {
   claim = new Claim().deserialize({
     ...claimStoreServiceMock.sampleClaimObj,
     ...claimStoreServiceMock.sampleFullAdmissionWithPaymentByInstalmentsResponseObjWithNoDisposableIncome
   })
   draft = new DraftClaimantResponse().deserialize({
     alternatePaymentMethod: {
       paymentOption: {
         option: {
           value: 'INSTALMENTS',
           displayValue: 'By instalments'
         }
       },
       paymentPlan: {
         totalAmount: 3326.59,
         instalmentAmount: 1000,
         firstPaymentDate: {
           year: 2019,
           month: 1,
           day: 1
         },
         paymentSchedule: {
           value: 'EACH_WEEK',
           displayValue: 'Each week'
         },
         completionDate: '2019-10-01',
         paymentLength: '1'
       }
     },
     courtDetermination: { disposableIncome: 0 }
   })
   expect(CourtDecisionHelper.createCourtDecision(claim, draft)).to.equal(DecisionType.DEFENDANT)
 })

  buildPostSubmissionUri (req: express.Request, res: express.Response): string {
    const claim: Claim = res.locals.claim
    const draft: DraftClaimantResponse = res.locals.draft.document
    const claimResponse = claim.response as FullAdmissionResponse | PartialAdmissionResponse

    const externalId: string = req.params.externalId

    const courtDecision = CourtDecisionHelper.createCourtDecision(claim, draft)
    switch (courtDecision) {
      case DecisionType.NOT_APPLICABLE_IS_BUSINESS:
        return Paths.taskListPage.evaluateUri({ externalId: externalId })
      case DecisionType.COURT: {
        return Paths.courtOfferedSetDatePage.evaluateUri({ externalId: externalId })
      }
      case DecisionType.DEFENDANT: {
        if (claimResponse.paymentIntention.paymentOption === PaymentOption.INSTALMENTS) {
          return Paths.courtOfferedInstalmentsPage.evaluateUri({ externalId: externalId })
        }

        if (claimResponse.paymentIntention.paymentOption === PaymentOption.BY_SPECIFIED_DATE) {
          return Paths.courtOfferedSetDatePage.evaluateUri({ externalId: externalId })
        }
        break
      }
      case DecisionType.CLAIMANT:
      case DecisionType.CLAIMANT_IN_FAVOUR_OF_DEFENDANT: {
        return Paths.payBySetDateAcceptedPage.evaluateUri({ externalId: externalId })
      }
    }
  }

  async saveDraft (locals: { user: User; draft: Draft<DraftClaimantResponse>, claim: Claim }): Promise<void> {
    const decisionType: DecisionType = CourtDecisionHelper.createCourtDecision(locals.claim, locals.draft.document)
    if (decisionType !== DecisionType.NOT_APPLICABLE_IS_BUSINESS) {
      locals.draft.document.courtDetermination.decisionType = decisionType

      const courtCalculatedPaymentIntention = PaymentPlanPage.generateCourtCalculatedPaymentIntention(locals.draft.document, locals.claim)
      if (courtCalculatedPaymentIntention) {
        locals.draft.document.courtDetermination.courtPaymentIntention = courtCalculatedPaymentIntention
      }
      locals.draft.document.courtDetermination.courtDecision = PaymentPlanPage.generateCourtOfferedPaymentIntention(locals.draft.document, locals.claim, decisionType)
    }
    return super.saveDraft(locals)
  }

 static getCourtDecision (draft: DraftClaimantResponse, claim: Claim): DecisionType {
   return CourtDecisionHelper.createCourtDecision(claim, draft)
 }