integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.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 static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;

 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.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.UUID;
 import org.apache.fineract.client.models.GetDelinquencyBucketsResponse;
 import org.apache.fineract.client.models.GetLoanProductsProductIdResponse;
 import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest;
 import org.apache.fineract.client.models.PostLoansLoanIdTransactionsResponse;
 import org.apache.fineract.infrastructure.businessdate.domain.BusinessDateType;
 import org.apache.fineract.infrastructure.core.service.DateUtils;
 import org.apache.fineract.integrationtests.common.BusinessDateHelper;
 import org.apache.fineract.integrationtests.common.ClientHelper;
 import org.apache.fineract.integrationtests.common.GlobalConfigurationHelper;
 import org.apache.fineract.integrationtests.common.Utils;
 import org.apache.fineract.integrationtests.common.accounting.Account;
 import org.apache.fineract.integrationtests.common.accounting.AccountHelper;
 import org.apache.fineract.integrationtests.common.accounting.PeriodicAccrualAccountingHelper;
 import org.apache.fineract.integrationtests.common.charges.ChargesHelper;
 import org.apache.fineract.integrationtests.common.loans.LoanApplicationTestBuilder;
 import org.apache.fineract.integrationtests.common.loans.LoanProductTestBuilder;
 import org.apache.fineract.integrationtests.common.loans.LoanTestLifecycleExtension;
 import org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper;
 import org.apache.fineract.integrationtests.common.products.DelinquencyBucketsHelper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;

 @ExtendWith(LoanTestLifecycleExtension.class)
 public class LoanAccrualTransactionReversalTest {

     private ResponseSpecification responseSpec;
     private RequestSpecification requestSpec;
     private LoanTransactionHelper loanTransactionHelper;
     private ClientHelper clientHelper;
     private DateTimeFormatter dateFormatter = new DateTimeFormatterBuilder().appendPattern("dd MMMM yyyy").toFormatter();
     private PeriodicAccrualAccountingHelper periodicAccrualAccountingHelper;
     private AccountHelper accountHelper;

     @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.clientHelper = new ClientHelper(this.requestSpec, this.responseSpec);
         this.periodicAccrualAccountingHelper = new PeriodicAccrualAccountingHelper(this.requestSpec, this.responseSpec);
         this.accountHelper = new AccountHelper(this.requestSpec, this.responseSpec);
     }

     @Test
     public void testNoAccrualTransactionReversalForMultipleDisbursementWithChargeForLoanAccountWithNoInterestBearingSchedulePeriodicAccrual() {

         // Accounts for periodic accrual
         final Account assetAccount = this.accountHelper.createAssetAccount();
         final Account incomeAccount = this.accountHelper.createIncomeAccount();
         final Account expenseAccount = this.accountHelper.createExpenseAccount();
         final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();

         // Loan ExternalId
         String loanExternalIdStr = UUID.randomUUID().toString();

         // Delinquency Bucket
         final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec);
         final GetDelinquencyBucketsResponse delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec,
                 delinquencyBucketId);

         // Client and Loan account creation

         final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue();
         final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProductWithMultipleDisbursement(
                 loanTransactionHelper, delinquencyBucketId, assetAccount, incomeAccount, expenseAccount, overpaymentAccount);
         assertNotNull(getLoanProductsProductResponse);

         final Integer loanId = createLoanAccount(clientId, getLoanProductsProductResponse.getId(), loanExternalIdStr);
         // 1st disbursement
         loanTransactionHelper.disburseLoanWithTransactionAmount("03 September 2022", loanId, "100");
         // 2nd disbursement
         loanTransactionHelper.disburseLoanWithTransactionAmount("04 September 2022", loanId, "300");

         // Add Charge
         Integer penalty = ChargesHelper.createCharges(requestSpec, responseSpec,
                 ChargesHelper.getLoanSpecifiedDueDateJSON(ChargesHelper.CHARGE_CALCULATION_TYPE_FLAT, "10", true));

         LocalDate targetDate = LocalDate.of(2022, 9, 4);
         final String penaltyCharge1AddedDate = dateFormatter.format(targetDate);

         Integer penalty1LoanChargeId = this.loanTransactionHelper.addChargesForLoan(loanId,
                 LoanTransactionHelper.getSpecifiedDueDateChargesForLoanAsJSON(String.valueOf(penalty), penaltyCharge1AddedDate, "10"));

         // Run accrual till charge date
         this.periodicAccrualAccountingHelper.runPeriodicAccrualAccounting(penaltyCharge1AddedDate);

         // verify accrual transaction created
         checkAccrualTransaction(targetDate, 0.0f, 0.0f, 10.0f, loanId);

         // 3rd disbursement
         loanTransactionHelper.disburseLoanWithTransactionAmount("05 September 2022", loanId, "600");

         // verify accrual transaction exists with same date,amount and is not reversed by regeneration of repayment
         // schedule
         checkAccrualTransaction(targetDate, 0.0f, 0.0f, 10.0f, loanId);

     }

     @Test
     public void testLastAccrualTransactionReversalRecalculationForLoanAccountWithInterestBearingScheduleWithDecliningBalance() {

         try {
             // Set business date
             LocalDate currentDate = LocalDate.of(2022, 05, 8);
             final String accrualRunTillDate = dateFormatter.format(currentDate);

             GlobalConfigurationHelper.updateIsBusinessDateEnabled(requestSpec, responseSpec, Boolean.TRUE);
             BusinessDateHelper.updateBusinessDate(requestSpec, responseSpec, BusinessDateType.BUSINESS_DATE, currentDate);

             // Accounts oof periodic accrual
             final Account assetAccount = this.accountHelper.createAssetAccount();
             final Account incomeAccount = this.accountHelper.createIncomeAccount();
             final Account expenseAccount = this.accountHelper.createExpenseAccount();
             final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();

             // Loan ExternalId
             String loanExternalIdStr = UUID.randomUUID().toString();

             // Client and Loan account creation

             final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue();

             // create loan product
             final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProductWithInterestRecalculation(assetAccount,
                     incomeAccount, expenseAccount, overpaymentAccount);
             assertNotNull(getLoanProductsProductResponse);
             // create loan account
             final Integer loanId = createLoanAccountWithInterestRecalculation(clientId, getLoanProductsProductResponse.getId(),
                     loanExternalIdStr);
             // run accruals till business date
             this.periodicAccrualAccountingHelper.runPeriodicAccrualAccounting(accrualRunTillDate);
             // check amount for last accrual on business date
             checkAccrualTransaction(currentDate, 0.82f, 0.0f, 0.0f, loanId);
             // make repayment on due date
             final PostLoansLoanIdTransactionsResponse repaymentTransaction = loanTransactionHelper.makeLoanRepayment(loanExternalIdStr,
                     new PostLoansLoanIdTransactionsRequest().dateFormat("dd MMMM yyyy").transactionDate("5 February 2022").locale("en")
                             .transactionAmount(106.57));
             // check previous accrual is reversed and new accrual created for same date and different amount.
             checkAccrualTransaction(currentDate, 0.71f, 0.0f, 0.0f, loanId);
         } finally {
             GlobalConfigurationHelper.updateIsBusinessDateEnabled(requestSpec, responseSpec, Boolean.FALSE);
         }

     }

     private Integer createLoanAccountWithInterestRecalculation(final Integer clientID, final Long loanProductID, final String externalId) {

         final String loanApplicationJSON = new LoanApplicationTestBuilder().withPrincipal("1000").withLoanTermFrequency("12")
                 .withLoanTermFrequencyAsMonths().withNumberOfRepayments("12").withRepaymentEveryAfter("1")
                 .withRepaymentFrequencyTypeAsMonths().withAmortizationTypeAsEqualInstallments().withInterestCalculationPeriodTypeAsDays()
                 .withInterestRatePerPeriod("12").withInterestTypeAsDecliningBalance().withPrincipalGrace("2").withInterestGrace("2")
                 .withExpectedDisbursementDate("05 January 2022").withSubmittedOnDate("05 January 2022").withLoanType("individual")
                 .withExternalId(externalId).build(clientID.toString(), loanProductID.toString(), null);

         final Integer loanId = loanTransactionHelper.getLoanId(loanApplicationJSON);
         loanTransactionHelper.approveLoan("05 January 2022", "1000", loanId, null);
         loanTransactionHelper.disburseLoanWithNetDisbursalAmount("05 January 2022", loanId, "1000");
         return loanId;
     }

     private GetLoanProductsProductIdResponse createLoanProductWithInterestRecalculation(final Account... accounts) {

         final String interestRecalculationCompoundingMethod = LoanProductTestBuilder.RECALCULATION_COMPOUNDING_METHOD_NONE;
         final String rescheduleStrategyMethod = LoanProductTestBuilder.RECALCULATION_STRATEGY_REDUCE_NUMBER_OF_INSTALLMENTS;
         final String recalculationRestFrequencyType = LoanProductTestBuilder.RECALCULATION_FREQUENCY_TYPE_DAILY;
         final String recalculationRestFrequencyInterval = "0";
         final String preCloseInterestCalculationStrategy = LoanProductTestBuilder.INTEREST_APPLICABLE_STRATEGY_ON_PRE_CLOSE_DATE;
         final String recalculationCompoundingFrequencyType = null;
         final String recalculationCompoundingFrequencyInterval = null;
         final Integer recalculationCompoundingFrequencyOnDayType = null;
         final Integer recalculationCompoundingFrequencyDayOfWeekType = null;
         final Integer recalculationRestFrequencyOnDayType = null;
         final Integer recalculationRestFrequencyDayOfWeekType = null;

         final String loanProductJSON = new LoanProductTestBuilder().withPrincipal("1000").withNumberOfRepayments("12")
                 .withinterestRatePerPeriod("12").withInterestRateFrequencyTypeAsYear().withInterestTypeAsDecliningBalance()
                 .withInterestCalculationPeriodTypeAsDays()
                 .withInterestRecalculationDetails(interestRecalculationCompoundingMethod, rescheduleStrategyMethod,
                         preCloseInterestCalculationStrategy)
                 .withInterestRecalculationRestFrequencyDetails(recalculationRestFrequencyType, recalculationRestFrequencyInterval,
                         recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType)
                 .withInterestRecalculationCompoundingFrequencyDetails(recalculationCompoundingFrequencyType,
                         recalculationCompoundingFrequencyInterval, recalculationCompoundingFrequencyOnDayType,
                         recalculationCompoundingFrequencyDayOfWeekType)
                 .withAccountingRulePeriodicAccrual(accounts).build(null);

         final Integer loanProductId = this.loanTransactionHelper.getLoanProductId(loanProductJSON);
         return loanTransactionHelper.getLoanProduct(loanProductId);
     }

     private GetLoanProductsProductIdResponse createLoanProductWithMultipleDisbursement(final LoanTransactionHelper loanTransactionHelper,
             final Integer delinquencyBucketId, final Account... accounts) {

         final HashMap<String, Object> loanProductMap = new LoanProductTestBuilder().withPrincipal("1000").withRepaymentTypeAsMonth()
                 .withRepaymentAfterEvery("1").withNumberOfRepayments("1").withRepaymentTypeAsMonth().withinterestRatePerPeriod("0")
                 .withInterestRateFrequencyTypeAsMonths().withAmortizationTypeAsEqualPrincipalPayment().withInterestTypeAsDecliningBalance()
                 .withAccountingRulePeriodicAccrual(accounts).withInterestCalculationPeriodTypeAsRepaymentPeriod(true).withDaysInMonth("30")
                 .withDaysInYear("365").withMoratorium("0", "0").withMultiDisburse().withDisallowExpectedDisbursements(true)
                 .build(null, delinquencyBucketId);
         final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap));
         return loanTransactionHelper.getLoanProduct(loanProductId);
     }

     private Integer createLoanAccount(final Integer clientID, final Long loanProductID, final String externalId) {

         String loanApplicationJSON = new LoanApplicationTestBuilder().withPrincipal("1000").withLoanTermFrequency("1")
                 .withLoanTermFrequencyAsMonths().withNumberOfRepayments("1").withRepaymentEveryAfter("1")
                 .withRepaymentFrequencyTypeAsMonths().withInterestRatePerPeriod("0").withInterestTypeAsFlatBalance()
                 .withAmortizationTypeAsEqualPrincipalPayments().withInterestCalculationPeriodTypeSameAsRepaymentPeriod()
                 .withExpectedDisbursementDate("03 September 2022").withSubmittedOnDate("01 September 2022").withLoanType("individual")
                 .withExternalId(externalId).build(clientID.toString(), loanProductID.toString(), null);

         final Integer loanId = loanTransactionHelper.getLoanId(loanApplicationJSON);
         loanTransactionHelper.approveLoan("02 September 2022", "1000", loanId, null);
         return loanId;
     }

     private void checkAccrualTransaction(final LocalDate transactionDate, final Float interestPortion, final Float feePortion,
             final Float penaltyPortion, final Integer loanID) {

         ArrayList<HashMap> transactions = (ArrayList<HashMap>) loanTransactionHelper.getLoanTransactions(this.requestSpec,
                 this.responseSpec, loanID);
         boolean isTransactionFound = false;
         for (int i = 0; i < transactions.size(); i++) {
             HashMap transactionType = (HashMap) transactions.get(i).get("type");
             boolean isAccrualTransaction = (Boolean) transactionType.get("accrual");

             if (isAccrualTransaction) {
                 ArrayList<Integer> accrualEntryDateAsArray = (ArrayList<Integer>) transactions.get(i).get("date");
                 LocalDate accrualEntryDate = LocalDate.of(accrualEntryDateAsArray.get(0), accrualEntryDateAsArray.get(1),
                         accrualEntryDateAsArray.get(2));

                 if (DateUtils.isEqual(transactionDate, accrualEntryDate)) {
                     isTransactionFound = true;
                     assertEquals(interestPortion, Float.valueOf(String.valueOf(transactions.get(i).get("interestPortion"))),
                             "Mismatch in transaction amounts");
                     assertEquals(feePortion, Float.valueOf(String.valueOf(transactions.get(i).get("feeChargesPortion"))),
                             "Mismatch in transaction amounts");
                     assertEquals(penaltyPortion, Float.valueOf(String.valueOf(transactions.get(i).get("penaltyChargesPortion"))),
                             "Mismatch in transaction amounts");
                     break;
                 }
             }
         }
         assertTrue(isTransactionFound, "No Accrual entries are posted");
     }

 }
	/**
	* 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 static org.junit.jupiter.api.Assertions.assertNotNull;
	import static org.junit.jupiter.api.Assertions.assertTrue;

	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.time.LocalDate;
	import java.time.format.DateTimeFormatter;
	import java.time.format.DateTimeFormatterBuilder;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.UUID;
	import org.apache.fineract.client.models.GetDelinquencyBucketsResponse;
	import org.apache.fineract.client.models.GetLoanProductsProductIdResponse;
	import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest;
	import org.apache.fineract.client.models.PostLoansLoanIdTransactionsResponse;
	import org.apache.fineract.infrastructure.businessdate.domain.BusinessDateType;
	import org.apache.fineract.infrastructure.core.service.DateUtils;
	import org.apache.fineract.integrationtests.common.BusinessDateHelper;
	import org.apache.fineract.integrationtests.common.ClientHelper;
	import org.apache.fineract.integrationtests.common.GlobalConfigurationHelper;
	import org.apache.fineract.integrationtests.common.Utils;
	import org.apache.fineract.integrationtests.common.accounting.Account;
	import org.apache.fineract.integrationtests.common.accounting.AccountHelper;
	import org.apache.fineract.integrationtests.common.accounting.PeriodicAccrualAccountingHelper;
	import org.apache.fineract.integrationtests.common.charges.ChargesHelper;
	import org.apache.fineract.integrationtests.common.loans.LoanApplicationTestBuilder;
	import org.apache.fineract.integrationtests.common.loans.LoanProductTestBuilder;
	import org.apache.fineract.integrationtests.common.loans.LoanTestLifecycleExtension;
	import org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper;
	import org.apache.fineract.integrationtests.common.products.DelinquencyBucketsHelper;
	import org.junit.jupiter.api.BeforeEach;
	import org.junit.jupiter.api.Test;
	import org.junit.jupiter.api.extension.ExtendWith;

	@ExtendWith(LoanTestLifecycleExtension.class)
	public class LoanAccrualTransactionReversalTest {

	private ResponseSpecification responseSpec;
	private RequestSpecification requestSpec;
	private LoanTransactionHelper loanTransactionHelper;
	private ClientHelper clientHelper;
	private DateTimeFormatter dateFormatter = new DateTimeFormatterBuilder().appendPattern("dd MMMM yyyy").toFormatter();
	private PeriodicAccrualAccountingHelper periodicAccrualAccountingHelper;
	private AccountHelper accountHelper;

	@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.clientHelper = new ClientHelper(this.requestSpec, this.responseSpec);
	this.periodicAccrualAccountingHelper = new PeriodicAccrualAccountingHelper(this.requestSpec, this.responseSpec);
	this.accountHelper = new AccountHelper(this.requestSpec, this.responseSpec);
	}

	@Test
	public void testNoAccrualTransactionReversalForMultipleDisbursementWithChargeForLoanAccountWithNoInterestBearingSchedulePeriodicAccrual() {

	// Accounts for periodic accrual
	final Account assetAccount = this.accountHelper.createAssetAccount();
	final Account incomeAccount = this.accountHelper.createIncomeAccount();
	final Account expenseAccount = this.accountHelper.createExpenseAccount();
	final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();

	// Loan ExternalId
	String loanExternalIdStr = UUID.randomUUID().toString();

	// Delinquency Bucket
	final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec);
	final GetDelinquencyBucketsResponse delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec,
	delinquencyBucketId);

	// Client and Loan account creation

	final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue();
	final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProductWithMultipleDisbursement(
	loanTransactionHelper, delinquencyBucketId, assetAccount, incomeAccount, expenseAccount, overpaymentAccount);
	assertNotNull(getLoanProductsProductResponse);

	final Integer loanId = createLoanAccount(clientId, getLoanProductsProductResponse.getId(), loanExternalIdStr);
	// 1st disbursement
	loanTransactionHelper.disburseLoanWithTransactionAmount("03 September 2022", loanId, "100");
	// 2nd disbursement
	loanTransactionHelper.disburseLoanWithTransactionAmount("04 September 2022", loanId, "300");

	// Add Charge
	Integer penalty = ChargesHelper.createCharges(requestSpec, responseSpec,
	ChargesHelper.getLoanSpecifiedDueDateJSON(ChargesHelper.CHARGE_CALCULATION_TYPE_FLAT, "10", true));

	LocalDate targetDate = LocalDate.of(2022, 9, 4);
	final String penaltyCharge1AddedDate = dateFormatter.format(targetDate);

	Integer penalty1LoanChargeId = this.loanTransactionHelper.addChargesForLoan(loanId,
	LoanTransactionHelper.getSpecifiedDueDateChargesForLoanAsJSON(String.valueOf(penalty), penaltyCharge1AddedDate, "10"));

	// Run accrual till charge date
	this.periodicAccrualAccountingHelper.runPeriodicAccrualAccounting(penaltyCharge1AddedDate);

	// verify accrual transaction created
	checkAccrualTransaction(targetDate, 0.0f, 0.0f, 10.0f, loanId);

	// 3rd disbursement
	loanTransactionHelper.disburseLoanWithTransactionAmount("05 September 2022", loanId, "600");

	// verify accrual transaction exists with same date,amount and is not reversed by regeneration of repayment
	// schedule
	checkAccrualTransaction(targetDate, 0.0f, 0.0f, 10.0f, loanId);

	}

	@Test
	public void testLastAccrualTransactionReversalRecalculationForLoanAccountWithInterestBearingScheduleWithDecliningBalance() {

	try {
	// Set business date
	LocalDate currentDate = LocalDate.of(2022, 05, 8);
	final String accrualRunTillDate = dateFormatter.format(currentDate);

	GlobalConfigurationHelper.updateIsBusinessDateEnabled(requestSpec, responseSpec, Boolean.TRUE);
	BusinessDateHelper.updateBusinessDate(requestSpec, responseSpec, BusinessDateType.BUSINESS_DATE, currentDate);

	// Accounts oof periodic accrual
	final Account assetAccount = this.accountHelper.createAssetAccount();
	final Account incomeAccount = this.accountHelper.createIncomeAccount();
	final Account expenseAccount = this.accountHelper.createExpenseAccount();
	final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();

	// Loan ExternalId
	String loanExternalIdStr = UUID.randomUUID().toString();

	// Client and Loan account creation

	final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue();

	// create loan product
	final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProductWithInterestRecalculation(assetAccount,
	incomeAccount, expenseAccount, overpaymentAccount);
	assertNotNull(getLoanProductsProductResponse);
	// create loan account
	final Integer loanId = createLoanAccountWithInterestRecalculation(clientId, getLoanProductsProductResponse.getId(),
	loanExternalIdStr);
	// run accruals till business date
	this.periodicAccrualAccountingHelper.runPeriodicAccrualAccounting(accrualRunTillDate);
	// check amount for last accrual on business date
	checkAccrualTransaction(currentDate, 0.82f, 0.0f, 0.0f, loanId);
	// make repayment on due date
	final PostLoansLoanIdTransactionsResponse repaymentTransaction = loanTransactionHelper.makeLoanRepayment(loanExternalIdStr,
	new PostLoansLoanIdTransactionsRequest().dateFormat("dd MMMM yyyy").transactionDate("5 February 2022").locale("en")
	.transactionAmount(106.57));
	// check previous accrual is reversed and new accrual created for same date and different amount.
	checkAccrualTransaction(currentDate, 0.71f, 0.0f, 0.0f, loanId);
	} finally {
	GlobalConfigurationHelper.updateIsBusinessDateEnabled(requestSpec, responseSpec, Boolean.FALSE);
	}

	}

	private Integer createLoanAccountWithInterestRecalculation(final Integer clientID, final Long loanProductID, final String externalId) {

	final String loanApplicationJSON = new LoanApplicationTestBuilder().withPrincipal("1000").withLoanTermFrequency("12")
	.withLoanTermFrequencyAsMonths().withNumberOfRepayments("12").withRepaymentEveryAfter("1")
	.withRepaymentFrequencyTypeAsMonths().withAmortizationTypeAsEqualInstallments().withInterestCalculationPeriodTypeAsDays()
	.withInterestRatePerPeriod("12").withInterestTypeAsDecliningBalance().withPrincipalGrace("2").withInterestGrace("2")
	.withExpectedDisbursementDate("05 January 2022").withSubmittedOnDate("05 January 2022").withLoanType("individual")
	.withExternalId(externalId).build(clientID.toString(), loanProductID.toString(), null);

	final Integer loanId = loanTransactionHelper.getLoanId(loanApplicationJSON);
	loanTransactionHelper.approveLoan("05 January 2022", "1000", loanId, null);
	loanTransactionHelper.disburseLoanWithNetDisbursalAmount("05 January 2022", loanId, "1000");
	return loanId;
	}

	private GetLoanProductsProductIdResponse createLoanProductWithInterestRecalculation(final Account... accounts) {

	final String interestRecalculationCompoundingMethod = LoanProductTestBuilder.RECALCULATION_COMPOUNDING_METHOD_NONE;
	final String rescheduleStrategyMethod = LoanProductTestBuilder.RECALCULATION_STRATEGY_REDUCE_NUMBER_OF_INSTALLMENTS;
	final String recalculationRestFrequencyType = LoanProductTestBuilder.RECALCULATION_FREQUENCY_TYPE_DAILY;
	final String recalculationRestFrequencyInterval = "0";
	final String preCloseInterestCalculationStrategy = LoanProductTestBuilder.INTEREST_APPLICABLE_STRATEGY_ON_PRE_CLOSE_DATE;
	final String recalculationCompoundingFrequencyType = null;
	final String recalculationCompoundingFrequencyInterval = null;
	final Integer recalculationCompoundingFrequencyOnDayType = null;
	final Integer recalculationCompoundingFrequencyDayOfWeekType = null;
	final Integer recalculationRestFrequencyOnDayType = null;
	final Integer recalculationRestFrequencyDayOfWeekType = null;

	final String loanProductJSON = new LoanProductTestBuilder().withPrincipal("1000").withNumberOfRepayments("12")
	.withinterestRatePerPeriod("12").withInterestRateFrequencyTypeAsYear().withInterestTypeAsDecliningBalance()
	.withInterestCalculationPeriodTypeAsDays()
	.withInterestRecalculationDetails(interestRecalculationCompoundingMethod, rescheduleStrategyMethod,
	preCloseInterestCalculationStrategy)
	.withInterestRecalculationRestFrequencyDetails(recalculationRestFrequencyType, recalculationRestFrequencyInterval,
	recalculationRestFrequencyOnDayType, recalculationRestFrequencyDayOfWeekType)
	.withInterestRecalculationCompoundingFrequencyDetails(recalculationCompoundingFrequencyType,
	recalculationCompoundingFrequencyInterval, recalculationCompoundingFrequencyOnDayType,
	recalculationCompoundingFrequencyDayOfWeekType)
	.withAccountingRulePeriodicAccrual(accounts).build(null);

	final Integer loanProductId = this.loanTransactionHelper.getLoanProductId(loanProductJSON);
	return loanTransactionHelper.getLoanProduct(loanProductId);
	}

	private GetLoanProductsProductIdResponse createLoanProductWithMultipleDisbursement(final LoanTransactionHelper loanTransactionHelper,
	final Integer delinquencyBucketId, final Account... accounts) {

	final HashMap<String, Object> loanProductMap = new LoanProductTestBuilder().withPrincipal("1000").withRepaymentTypeAsMonth()
	.withRepaymentAfterEvery("1").withNumberOfRepayments("1").withRepaymentTypeAsMonth().withinterestRatePerPeriod("0")
	.withInterestRateFrequencyTypeAsMonths().withAmortizationTypeAsEqualPrincipalPayment().withInterestTypeAsDecliningBalance()
	.withAccountingRulePeriodicAccrual(accounts).withInterestCalculationPeriodTypeAsRepaymentPeriod(true).withDaysInMonth("30")
	.withDaysInYear("365").withMoratorium("0", "0").withMultiDisburse().withDisallowExpectedDisbursements(true)
	.build(null, delinquencyBucketId);
	final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap));
	return loanTransactionHelper.getLoanProduct(loanProductId);
	}

	private Integer createLoanAccount(final Integer clientID, final Long loanProductID, final String externalId) {

	String loanApplicationJSON = new LoanApplicationTestBuilder().withPrincipal("1000").withLoanTermFrequency("1")
	.withLoanTermFrequencyAsMonths().withNumberOfRepayments("1").withRepaymentEveryAfter("1")
	.withRepaymentFrequencyTypeAsMonths().withInterestRatePerPeriod("0").withInterestTypeAsFlatBalance()
	.withAmortizationTypeAsEqualPrincipalPayments().withInterestCalculationPeriodTypeSameAsRepaymentPeriod()
	.withExpectedDisbursementDate("03 September 2022").withSubmittedOnDate("01 September 2022").withLoanType("individual")
	.withExternalId(externalId).build(clientID.toString(), loanProductID.toString(), null);

	final Integer loanId = loanTransactionHelper.getLoanId(loanApplicationJSON);
	loanTransactionHelper.approveLoan("02 September 2022", "1000", loanId, null);
	return loanId;
	}

	private void checkAccrualTransaction(final LocalDate transactionDate, final Float interestPortion, final Float feePortion,
	final Float penaltyPortion, final Integer loanID) {

	ArrayList<HashMap> transactions = (ArrayList<HashMap>) loanTransactionHelper.getLoanTransactions(this.requestSpec,
	this.responseSpec, loanID);
	boolean isTransactionFound = false;
	for (int i = 0; i < transactions.size(); i++) {
	HashMap transactionType = (HashMap) transactions.get(i).get("type");
	boolean isAccrualTransaction = (Boolean) transactionType.get("accrual");

	if (isAccrualTransaction) {
	ArrayList<Integer> accrualEntryDateAsArray = (ArrayList<Integer>) transactions.get(i).get("date");
	LocalDate accrualEntryDate = LocalDate.of(accrualEntryDateAsArray.get(0), accrualEntryDateAsArray.get(1),
	accrualEntryDateAsArray.get(2));

	if (DateUtils.isEqual(transactionDate, accrualEntryDate)) {
	isTransactionFound = true;
	assertEquals(interestPortion, Float.valueOf(String.valueOf(transactions.get(i).get("interestPortion"))),
	"Mismatch in transaction amounts");
	assertEquals(feePortion, Float.valueOf(String.valueOf(transactions.get(i).get("feeChargesPortion"))),
	"Mismatch in transaction amounts");
	assertEquals(penaltyPortion, Float.valueOf(String.valueOf(transactions.get(i).get("penaltyChargesPortion"))),
	"Mismatch in transaction amounts");
	break;
	}
	}
	}
	assertTrue(isTransactionFound, "No Accrual entries are posted");
	}

	}