integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentRescheduleAtDisbursementTest.java - fineract - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.fineract.integrationtests;

 import static org.junit.jupiter.api.Assertions.assertEquals;

 import io.restassured.builder.RequestSpecBuilder;
 import io.restassured.builder.ResponseSpecBuilder;
 import io.restassured.http.ContentType;
 import io.restassured.specification.RequestSpecification;
 import io.restassured.specification.ResponseSpecification;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.apache.fineract.integrationtests.common.ClientHelper;
 import org.apache.fineract.integrationtests.common.CollateralManagementHelper;
 import org.apache.fineract.integrationtests.common.Utils;
 import org.apache.fineract.integrationtests.common.accounting.Account;
 import org.apache.fineract.integrationtests.common.loans.LoanApplicationTestBuilder;
 import org.apache.fineract.integrationtests.common.loans.LoanProductTestBuilder;
 import org.apache.fineract.integrationtests.common.loans.LoanStatusChecker;
 import org.apache.fineract.integrationtests.common.loans.LoanTestLifecycleExtension;
 import org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 @SuppressWarnings("rawtypes")
 @ExtendWith(LoanTestLifecycleExtension.class)
 public class LoanRepaymentRescheduleAtDisbursementTest {

     private static final Logger LOG = LoggerFactory.getLogger(LoanRepaymentRescheduleAtDisbursementTest.class);
     private ResponseSpecification responseSpec;
     private RequestSpecification requestSpec;
     private LoanTransactionHelper loanTransactionHelper;
     private LoanApplicationApprovalTest loanApplicationApprovalTest;
     private ResponseSpecification generalResponseSpec;

     @BeforeEach
     public void setup() {
         Utils.initializeRESTAssured();
         this.requestSpec = new RequestSpecBuilder().setContentType(ContentType.JSON).build();
         this.requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey());
         this.responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build();
         this.loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec);
         this.loanApplicationApprovalTest = new LoanApplicationApprovalTest();
         this.generalResponseSpec = new ResponseSpecBuilder().build();
     }

     @SuppressWarnings("unchecked")
     @Test
     public void testLoanRepaymentRescheduleAtDisbursement() {

         final String approvalAmount = "10000";
         final String approveDate = "01 March 2015";
         final String expectedDisbursementDate = "01 March 2015";
         final String disbursementDate = "01 March 2015";
         final String adjustRepaymentDate = "16 March 2015";

         // CREATE CLIENT
         final Integer clientID = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2014");
         LOG.info("---------------------------------CLIENT CREATED WITH ID--------------------------------------------------- {}", clientID);

         // CREATE LOAN MULTIDISBURSAL PRODUCT WITH INTEREST RECALCULATION
         final Integer loanProductID = createLoanProductWithInterestRecalculation(LoanProductTestBuilder.RBI_INDIA_STRATEGY,
                 LoanProductTestBuilder.RECALCULATION_COMPOUNDING_METHOD_NONE,
                 LoanProductTestBuilder.RECALCULATION_STRATEGY_REDUCE_NUMBER_OF_INSTALLMENTS,
                 LoanProductTestBuilder.RECALCULATION_FREQUENCY_TYPE_DAILY, "0",
                 LoanProductTestBuilder.INTEREST_APPLICABLE_STRATEGY_ON_PRE_CLOSE_DATE, null);

         // CREATE TRANCHES
         List<HashMap> createTranches = new ArrayList<>();
         createTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 March 2015", "5000"));
         createTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 May 2015", "5000"));

         // APPROVE TRANCHES
         List<HashMap> approveTranches = new ArrayList<>();
         approveTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 March 2015", "5000"));
         approveTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 May 2015", "5000"));

         List<HashMap> collaterals = new ArrayList<>();
         final Integer collateralId = CollateralManagementHelper.createCollateralProduct(this.requestSpec, this.responseSpec);
         Assertions.assertNotNull(collateralId);
         final Integer clientCollateralId = CollateralManagementHelper.createClientCollateral(this.requestSpec, this.responseSpec,
                 String.valueOf(clientID), collateralId);
         Assertions.assertNotNull(clientCollateralId);
         addCollaterals(collaterals, clientCollateralId, BigDecimal.valueOf(1));

         // APPLY FOR TRANCHE LOAN WITH INTEREST RECALCULATION
         final Integer loanID = applyForLoanApplicationForInterestRecalculation(clientID, loanProductID, disbursementDate,
                 LoanApplicationTestBuilder.RBI_INDIA_STRATEGY, new ArrayList<HashMap>(0), createTranches, collaterals);

         HashMap loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(this.requestSpec, this.responseSpec, loanID);

         // VALIDATE THE LOAN STATUS
         LoanStatusChecker.verifyLoanIsPending(loanStatusHashMap);

         LOG.info("-----------------------------------APPROVE LOAN-----------------------------------------------------------");
         loanStatusHashMap = this.loanTransactionHelper.approveLoanWithApproveAmount(approveDate, expectedDisbursementDate, approvalAmount,
                 loanID, approveTranches);

         // VALIDATE THE LOAN IS APPROVED
         LoanStatusChecker.verifyLoanIsApproved(loanStatusHashMap);
         LoanStatusChecker.verifyLoanIsWaitingForDisbursal(loanStatusHashMap);

         // DISBURSE A FIRST TRANCHE
         this.loanTransactionHelper.disburseLoanWithRepaymentReschedule(disbursementDate, loanID, adjustRepaymentDate);
         loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(this.requestSpec, this.responseSpec, loanID);

         ArrayList<HashMap> loanRepaymnetSchedule = this.loanTransactionHelper.getLoanRepaymentSchedule(requestSpec, generalResponseSpec,
                 loanID);
         HashMap firstInstallement = loanRepaymnetSchedule.get(1);
         Map<String, Object> expectedvalues = new HashMap<>(3);
         Calendar date = Calendar.getInstance(Utils.getTimeZoneOfTenant());
         date.set(2015, Calendar.MARCH, 16);
         expectedvalues.put("dueDate", getDateAsArray(date, 0));
         expectedvalues.put("principalDue", "834.71");
         expectedvalues.put("interestDue", "49.32");
         expectedvalues.put("feeChargesDue", "0");
         expectedvalues.put("penaltyChargesDue", "0");
         expectedvalues.put("totalDueForPeriod", "884.03");

         // VALIDATE REPAYMENT SCHEDULE
         verifyLoanRepaymentSchedule(firstInstallement, expectedvalues);

     }

     private void addCollaterals(List<HashMap> collaterals, Integer collateralId, BigDecimal quantity) {
         collaterals.add(collaterals(collateralId, quantity));
     }

     private HashMap<String, String> collaterals(Integer collateralId, BigDecimal quantity) {
         HashMap<String, String> collateral = new HashMap<String, String>(2);
         collateral.put("clientCollateralId", collateralId.toString());
         collateral.put("quantity", quantity.toString());
         return collateral;
     }

     private void verifyLoanRepaymentSchedule(final HashMap firstInstallement, final Map<String, Object> expectedvalues) {

         assertEquals(expectedvalues.get("dueDate"), firstInstallement.get("dueDate"));
         assertEquals(String.valueOf(expectedvalues.get("principalDue")), String.valueOf(firstInstallement.get("principalDue")));
         assertEquals(String.valueOf(expectedvalues.get("interestDue")), String.valueOf(firstInstallement.get("interestDue")));
         assertEquals(String.valueOf(expectedvalues.get("feeChargesDue")), String.valueOf(firstInstallement.get("feeChargesDue")));
         assertEquals(String.valueOf(expectedvalues.get("penaltyChargesDue")), String.valueOf(firstInstallement.get("penaltyChargesDue")));
         assertEquals(String.valueOf(expectedvalues.get("totalDueForPeriod")), String.valueOf(firstInstallement.get("totalDueForPeriod")));

     }

     private Integer createLoanProductWithInterestRecalculation(final String repaymentStrategy,
             final String interestRecalculationCompoundingMethod, final String rescheduleStrategyMethod,
             final String recalculationRestFrequencyType, final String recalculationRestFrequencyInterval,
             final String preCloseInterestCalculationStrategy, final Account[] accounts) {
         final String recalculationCompoundingFrequencyType = null;
         final String recalculationCompoundingFrequencyInterval = null;
         final Integer recalculationCompoundingFrequencyOnDayType = null;
         final Integer recalculationCompoundingFrequencyDayOfWeekType = null;
         final Integer recalculationRestFrequencyOnDayType = null;
         final Integer recalculationRestFrequencyDayOfWeekType = null;
         return createLoanProductWithInterestRecalculation(repaymentStrategy, interestRecalculationCompoundingMethod,
                 rescheduleStrategyMethod, recalculationRestFrequencyType, recalculationRestFrequencyInterval,
                 recalculationCompoundingFrequencyType, recalculationCompoundingFrequencyInterval, preCloseInterestCalculationStrategy,
                 accounts, null, false, recalculationCompoundingFrequencyOnDayType, recalculationCompoundingFrequencyDayOfWeekType,
                 recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType);
     }

     private Integer createLoanProductWithInterestRecalculation(final String repaymentStrategy,
             final String interestRecalculationCompoundingMethod, final String rescheduleStrategyMethod,
             final String recalculationRestFrequencyType, final String recalculationRestFrequencyInterval,
             final String recalculationCompoundingFrequencyType, final String recalculationCompoundingFrequencyInterval,
             final String preCloseInterestCalculationStrategy, final Account[] accounts, final String chargeId,
             boolean isArrearsBasedOnOriginalSchedule, final Integer recalculationCompoundingFrequencyOnDayType,
             final Integer recalculationCompoundingFrequencyDayOfWeekType, final Integer recalculationRestFrequencyOnDayType,
             final Integer recalculationRestFrequencyDayOfWeekType) {
         LOG.info("------------------------------CREATING NEW LOAN PRODUCT ---------------------------------------");
         LoanProductTestBuilder builder = new LoanProductTestBuilder().withPrincipal("10000.00").withNumberOfRepayments("12")
                 .withRepaymentAfterEvery("2").withRepaymentTypeAsWeek().withinterestRatePerPeriod("2")
                 .withInterestRateFrequencyTypeAsMonths().withTranches(true).withInterestCalculationPeriodTypeAsRepaymentPeriod(true)
                 .withRepaymentStrategy(repaymentStrategy).withInterestTypeAsDecliningBalance()
                 .withInterestRecalculationDetails(interestRecalculationCompoundingMethod, rescheduleStrategyMethod,
                         preCloseInterestCalculationStrategy)
                 .withInterestRecalculationRestFrequencyDetails(recalculationRestFrequencyType, recalculationRestFrequencyInterval,
                         recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType)
                 .withInterestRecalculationCompoundingFrequencyDetails(recalculationCompoundingFrequencyType,
                         recalculationCompoundingFrequencyInterval, recalculationCompoundingFrequencyOnDayType,
                         recalculationCompoundingFrequencyDayOfWeekType);
         if (accounts != null) {
             builder = builder.withAccountingRulePeriodicAccrual(accounts);
         }

         if (isArrearsBasedOnOriginalSchedule) {
             builder = builder.withArrearsConfiguration();
         }

         final String loanProductJSON = builder.build(chargeId);
         return this.loanTransactionHelper.getLoanProductId(loanProductJSON);
     }

     private Integer applyForLoanApplicationForInterestRecalculation(final Integer clientID, final Integer loanProductID,
             final String disbursementDate, final String repaymentStrategy, final List<HashMap> charges, List<HashMap> tranches,
             final List<HashMap> collaterals) {
         final String graceOnInterestPayment = null;
         final String graceOnPrincipalPayment = null;

         return applyForLoanApplicationForInterestRecalculation(clientID, loanProductID, disbursementDate, repaymentStrategy, charges,
                 graceOnInterestPayment, graceOnPrincipalPayment, tranches, collaterals);
     }

     private Integer applyForLoanApplicationForInterestRecalculation(final Integer clientID, final Integer loanProductID,
             final String disbursementDate, final String repaymentStrategy, final List<HashMap> charges, final String graceOnInterestPayment,
             final String graceOnPrincipalPayment, List<HashMap> tranches, List<HashMap> collaterals) {
         LOG.info("--------------------------------APPLYING FOR LOAN APPLICATION--------------------------------");
         final String loanApplicationJSON = new LoanApplicationTestBuilder() //
                 .withPrincipal("10000.00") //
                 .withLoanTermFrequency("24") //
                 .withLoanTermFrequencyAsWeeks() //
                 .withNumberOfRepayments("12") //
                 .withRepaymentEveryAfter("2") //
                 .withRepaymentFrequencyTypeAsWeeks() //
                 .withInterestRatePerPeriod("2") //
                 .withAmortizationTypeAsEqualInstallments() //
                 .withTranches(tranches).withFixedEmiAmount("") //
                 .withInterestTypeAsDecliningBalance() //
                 .withInterestCalculationPeriodTypeAsDays() //
                 .withInterestCalculationPeriodTypeAsDays() //
                 .withExpectedDisbursementDate(disbursementDate) //
                 .withSubmittedOnDate(disbursementDate) //
                 .withRepaymentStrategy(repaymentStrategy) //
                 .withCollaterals(collaterals).withCharges(charges)//
                 .build(clientID.toString(), loanProductID.toString(), null);
         return this.loanTransactionHelper.getLoanId(loanApplicationJSON);
     }

     private List getDateAsArray(Calendar date, int addPeriod) {
         return getDateAsArray(date, addPeriod, Calendar.DAY_OF_MONTH);
     }

     private List getDateAsArray(Calendar date, int addvalue, int type) {
         date.add(type, addvalue);
         return new ArrayList<>(Arrays.asList(date.get(Calendar.YEAR), date.get(Calendar.MONTH) + 1, date.get(Calendar.DAY_OF_MONTH)));
     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.fineract.integrationtests;

	import static org.junit.jupiter.api.Assertions.assertEquals;

	import io.restassured.builder.RequestSpecBuilder;
	import io.restassured.builder.ResponseSpecBuilder;
	import io.restassured.http.ContentType;
	import io.restassured.specification.RequestSpecification;
	import io.restassured.specification.ResponseSpecification;
	import java.math.BigDecimal;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Calendar;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import org.apache.fineract.integrationtests.common.ClientHelper;
	import org.apache.fineract.integrationtests.common.CollateralManagementHelper;
	import org.apache.fineract.integrationtests.common.Utils;
	import org.apache.fineract.integrationtests.common.accounting.Account;
	import org.apache.fineract.integrationtests.common.loans.LoanApplicationTestBuilder;
	import org.apache.fineract.integrationtests.common.loans.LoanProductTestBuilder;
	import org.apache.fineract.integrationtests.common.loans.LoanStatusChecker;
	import org.apache.fineract.integrationtests.common.loans.LoanTestLifecycleExtension;
	import org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper;
	import org.junit.jupiter.api.Assertions;
	import org.junit.jupiter.api.BeforeEach;
	import org.junit.jupiter.api.Test;
	import org.junit.jupiter.api.extension.ExtendWith;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	@SuppressWarnings("rawtypes")
	@ExtendWith(LoanTestLifecycleExtension.class)
	public class LoanRepaymentRescheduleAtDisbursementTest {

	private static final Logger LOG = LoggerFactory.getLogger(LoanRepaymentRescheduleAtDisbursementTest.class);
	private ResponseSpecification responseSpec;
	private RequestSpecification requestSpec;
	private LoanTransactionHelper loanTransactionHelper;
	private LoanApplicationApprovalTest loanApplicationApprovalTest;
	private ResponseSpecification generalResponseSpec;

	@BeforeEach
	public void setup() {
	Utils.initializeRESTAssured();
	this.requestSpec = new RequestSpecBuilder().setContentType(ContentType.JSON).build();
	this.requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey());
	this.responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build();
	this.loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec);
	this.loanApplicationApprovalTest = new LoanApplicationApprovalTest();
	this.generalResponseSpec = new ResponseSpecBuilder().build();
	}

	@SuppressWarnings("unchecked")
	@Test
	public void testLoanRepaymentRescheduleAtDisbursement() {

	final String approvalAmount = "10000";
	final String approveDate = "01 March 2015";
	final String expectedDisbursementDate = "01 March 2015";
	final String disbursementDate = "01 March 2015";
	final String adjustRepaymentDate = "16 March 2015";

	// CREATE CLIENT
	final Integer clientID = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2014");
	LOG.info("---------------------------------CLIENT CREATED WITH ID--------------------------------------------------- {}", clientID);

	// CREATE LOAN MULTIDISBURSAL PRODUCT WITH INTEREST RECALCULATION
	final Integer loanProductID = createLoanProductWithInterestRecalculation(LoanProductTestBuilder.RBI_INDIA_STRATEGY,
	LoanProductTestBuilder.RECALCULATION_COMPOUNDING_METHOD_NONE,
	LoanProductTestBuilder.RECALCULATION_STRATEGY_REDUCE_NUMBER_OF_INSTALLMENTS,
	LoanProductTestBuilder.RECALCULATION_FREQUENCY_TYPE_DAILY, "0",
	LoanProductTestBuilder.INTEREST_APPLICABLE_STRATEGY_ON_PRE_CLOSE_DATE, null);

	// CREATE TRANCHES
	List<HashMap> createTranches = new ArrayList<>();
	createTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 March 2015", "5000"));
	createTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 May 2015", "5000"));

	// APPROVE TRANCHES
	List<HashMap> approveTranches = new ArrayList<>();
	approveTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 March 2015", "5000"));
	approveTranches.add(this.loanApplicationApprovalTest.createTrancheDetail("01 May 2015", "5000"));

	List<HashMap> collaterals = new ArrayList<>();
	final Integer collateralId = CollateralManagementHelper.createCollateralProduct(this.requestSpec, this.responseSpec);
	Assertions.assertNotNull(collateralId);
	final Integer clientCollateralId = CollateralManagementHelper.createClientCollateral(this.requestSpec, this.responseSpec,
	String.valueOf(clientID), collateralId);
	Assertions.assertNotNull(clientCollateralId);
	addCollaterals(collaterals, clientCollateralId, BigDecimal.valueOf(1));

	// APPLY FOR TRANCHE LOAN WITH INTEREST RECALCULATION
	final Integer loanID = applyForLoanApplicationForInterestRecalculation(clientID, loanProductID, disbursementDate,
	LoanApplicationTestBuilder.RBI_INDIA_STRATEGY, new ArrayList<HashMap>(0), createTranches, collaterals);

	HashMap loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(this.requestSpec, this.responseSpec, loanID);

	// VALIDATE THE LOAN STATUS
	LoanStatusChecker.verifyLoanIsPending(loanStatusHashMap);

	LOG.info("-----------------------------------APPROVE LOAN-----------------------------------------------------------");
	loanStatusHashMap = this.loanTransactionHelper.approveLoanWithApproveAmount(approveDate, expectedDisbursementDate, approvalAmount,
	loanID, approveTranches);

	// VALIDATE THE LOAN IS APPROVED
	LoanStatusChecker.verifyLoanIsApproved(loanStatusHashMap);
	LoanStatusChecker.verifyLoanIsWaitingForDisbursal(loanStatusHashMap);

	// DISBURSE A FIRST TRANCHE
	this.loanTransactionHelper.disburseLoanWithRepaymentReschedule(disbursementDate, loanID, adjustRepaymentDate);
	loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(this.requestSpec, this.responseSpec, loanID);

	ArrayList<HashMap> loanRepaymnetSchedule = this.loanTransactionHelper.getLoanRepaymentSchedule(requestSpec, generalResponseSpec,
	loanID);
	HashMap firstInstallement = loanRepaymnetSchedule.get(1);
	Map<String, Object> expectedvalues = new HashMap<>(3);
	Calendar date = Calendar.getInstance(Utils.getTimeZoneOfTenant());
	date.set(2015, Calendar.MARCH, 16);
	expectedvalues.put("dueDate", getDateAsArray(date, 0));
	expectedvalues.put("principalDue", "834.71");
	expectedvalues.put("interestDue", "49.32");
	expectedvalues.put("feeChargesDue", "0");
	expectedvalues.put("penaltyChargesDue", "0");
	expectedvalues.put("totalDueForPeriod", "884.03");

	// VALIDATE REPAYMENT SCHEDULE
	verifyLoanRepaymentSchedule(firstInstallement, expectedvalues);

	}

	private void addCollaterals(List<HashMap> collaterals, Integer collateralId, BigDecimal quantity) {
	collaterals.add(collaterals(collateralId, quantity));
	}

	private HashMap<String, String> collaterals(Integer collateralId, BigDecimal quantity) {
	HashMap<String, String> collateral = new HashMap<String, String>(2);
	collateral.put("clientCollateralId", collateralId.toString());
	collateral.put("quantity", quantity.toString());
	return collateral;
	}

	private void verifyLoanRepaymentSchedule(final HashMap firstInstallement, final Map<String, Object> expectedvalues) {

	assertEquals(expectedvalues.get("dueDate"), firstInstallement.get("dueDate"));
	assertEquals(String.valueOf(expectedvalues.get("principalDue")), String.valueOf(firstInstallement.get("principalDue")));
	assertEquals(String.valueOf(expectedvalues.get("interestDue")), String.valueOf(firstInstallement.get("interestDue")));
	assertEquals(String.valueOf(expectedvalues.get("feeChargesDue")), String.valueOf(firstInstallement.get("feeChargesDue")));
	assertEquals(String.valueOf(expectedvalues.get("penaltyChargesDue")), String.valueOf(firstInstallement.get("penaltyChargesDue")));
	assertEquals(String.valueOf(expectedvalues.get("totalDueForPeriod")), String.valueOf(firstInstallement.get("totalDueForPeriod")));

	}

	private Integer createLoanProductWithInterestRecalculation(final String repaymentStrategy,
	final String interestRecalculationCompoundingMethod, final String rescheduleStrategyMethod,
	final String recalculationRestFrequencyType, final String recalculationRestFrequencyInterval,
	final String preCloseInterestCalculationStrategy, final Account[] accounts) {
	final String recalculationCompoundingFrequencyType = null;
	final String recalculationCompoundingFrequencyInterval = null;
	final Integer recalculationCompoundingFrequencyOnDayType = null;
	final Integer recalculationCompoundingFrequencyDayOfWeekType = null;
	final Integer recalculationRestFrequencyOnDayType = null;
	final Integer recalculationRestFrequencyDayOfWeekType = null;
	return createLoanProductWithInterestRecalculation(repaymentStrategy, interestRecalculationCompoundingMethod,
	rescheduleStrategyMethod, recalculationRestFrequencyType, recalculationRestFrequencyInterval,
	recalculationCompoundingFrequencyType, recalculationCompoundingFrequencyInterval, preCloseInterestCalculationStrategy,
	accounts, null, false, recalculationCompoundingFrequencyOnDayType, recalculationCompoundingFrequencyDayOfWeekType,
	recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType);
	}

	private Integer createLoanProductWithInterestRecalculation(final String repaymentStrategy,
	final String interestRecalculationCompoundingMethod, final String rescheduleStrategyMethod,
	final String recalculationRestFrequencyType, final String recalculationRestFrequencyInterval,
	final String recalculationCompoundingFrequencyType, final String recalculationCompoundingFrequencyInterval,
	final String preCloseInterestCalculationStrategy, final Account[] accounts, final String chargeId,
	boolean isArrearsBasedOnOriginalSchedule, final Integer recalculationCompoundingFrequencyOnDayType,
	final Integer recalculationCompoundingFrequencyDayOfWeekType, final Integer recalculationRestFrequencyOnDayType,
	final Integer recalculationRestFrequencyDayOfWeekType) {
	LOG.info("------------------------------CREATING NEW LOAN PRODUCT ---------------------------------------");
	LoanProductTestBuilder builder = new LoanProductTestBuilder().withPrincipal("10000.00").withNumberOfRepayments("12")
	.withRepaymentAfterEvery("2").withRepaymentTypeAsWeek().withinterestRatePerPeriod("2")
	.withInterestRateFrequencyTypeAsMonths().withTranches(true).withInterestCalculationPeriodTypeAsRepaymentPeriod(true)
	.withRepaymentStrategy(repaymentStrategy).withInterestTypeAsDecliningBalance()
	.withInterestRecalculationDetails(interestRecalculationCompoundingMethod, rescheduleStrategyMethod,
	preCloseInterestCalculationStrategy)
	.withInterestRecalculationRestFrequencyDetails(recalculationRestFrequencyType, recalculationRestFrequencyInterval,
	recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType)
	.withInterestRecalculationCompoundingFrequencyDetails(recalculationCompoundingFrequencyType,
	recalculationCompoundingFrequencyInterval, recalculationCompoundingFrequencyOnDayType,
	recalculationCompoundingFrequencyDayOfWeekType);
	if (accounts != null) {
	builder = builder.withAccountingRulePeriodicAccrual(accounts);
	}

	if (isArrearsBasedOnOriginalSchedule) {
	builder = builder.withArrearsConfiguration();
	}

	final String loanProductJSON = builder.build(chargeId);
	return this.loanTransactionHelper.getLoanProductId(loanProductJSON);
	}

	private Integer applyForLoanApplicationForInterestRecalculation(final Integer clientID, final Integer loanProductID,
	final String disbursementDate, final String repaymentStrategy, final List<HashMap> charges, List<HashMap> tranches,
	final List<HashMap> collaterals) {
	final String graceOnInterestPayment = null;
	final String graceOnPrincipalPayment = null;

	return applyForLoanApplicationForInterestRecalculation(clientID, loanProductID, disbursementDate, repaymentStrategy, charges,
	graceOnInterestPayment, graceOnPrincipalPayment, tranches, collaterals);
	}

	private Integer applyForLoanApplicationForInterestRecalculation(final Integer clientID, final Integer loanProductID,
	final String disbursementDate, final String repaymentStrategy, final List<HashMap> charges, final String graceOnInterestPayment,
	final String graceOnPrincipalPayment, List<HashMap> tranches, List<HashMap> collaterals) {
	LOG.info("--------------------------------APPLYING FOR LOAN APPLICATION--------------------------------");
	final String loanApplicationJSON = new LoanApplicationTestBuilder() //
	.withPrincipal("10000.00") //
	.withLoanTermFrequency("24") //
	.withLoanTermFrequencyAsWeeks() //
	.withNumberOfRepayments("12") //
	.withRepaymentEveryAfter("2") //
	.withRepaymentFrequencyTypeAsWeeks() //
	.withInterestRatePerPeriod("2") //
	.withAmortizationTypeAsEqualInstallments() //
	.withTranches(tranches).withFixedEmiAmount("") //
	.withInterestTypeAsDecliningBalance() //
	.withInterestCalculationPeriodTypeAsDays() //
	.withInterestCalculationPeriodTypeAsDays() //
	.withExpectedDisbursementDate(disbursementDate) //
	.withSubmittedOnDate(disbursementDate) //
	.withRepaymentStrategy(repaymentStrategy) //
	.withCollaterals(collaterals).withCharges(charges)//
	.build(clientID.toString(), loanProductID.toString(), null);
	return this.loanTransactionHelper.getLoanId(loanApplicationJSON);
	}

	private List getDateAsArray(Calendar date, int addPeriod) {
	return getDateAsArray(date, addPeriod, Calendar.DAY_OF_MONTH);
	}

	private List getDateAsArray(Calendar date, int addvalue, int type) {
	date.add(type, addvalue);
	return new ArrayList<>(Arrays.asList(date.get(Calendar.YEAR), date.get(Calendar.MONTH) + 1, date.get(Calendar.DAY_OF_MONTH)));
	}
	}