treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Adding test ClearingServiceTest for clearing-service.

Browse source
This commit is contained in:
psemenkov 2023-03-10 10:15:18 +03:00
parent a8a4d99113
commit d8bed72ea2
4 changed files with 292 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/validation/ExecutionDepositValidationRule.java
View file

@ -37,6 +37,9 @@ public enum ExecutionDepositValidationRule implements IValidationRule<ImdgValida
@Override
public Optional<EnumMessage> validate(ImdgValidationContext<ExecutionDeposit> context) {
ExecutionDeposit validatedObject = context.getValidatedObject();
if (validatedObject.getAccountId() == null) {
return of(ClearingErrorInternal.AccountNotActive);
}
Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
Relation relation = context.getStoredObject(ClrngValidationStored.relation);
Account account = accountImdg.getSingleObjectByFieldValues(

58
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/AbstractClearingTest.java Normal file
View file

@ -0,0 +1,58 @@
package ru.spcex.clearing.service;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.spcex.clearing.config.*;
import ru.spcex.clearing.service.builder.LiabilitiesClaimsAssetsCreator;
import ru.spcex.clearing.service.builder.LiabilitiesClaimsMoneyCreator;
import ru.spcex.clearing.service.order.ExecutionDepositSorter;
import ru.spcex.clearing.service.order.PaymentInstructionSorter;
import ru.spcex.clearing.utils.TestUtils;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
SdfCreatorBySTLDPayment.class,
PaymentUpdateBySdf04.class,
VerificationResultComponent.class,
ExecutionDepositComponent.class,
ExecutionDepositSorter.class,
LiabilitiesClaimsAssetsCreator.class,
LiabilitiesClaimsMoneyCreator.class,
EventsReceiver.class,
ClearingService.class,
Clearing.class,
SortingConfig.class,
PaymentInstructionSorter.class,
MessageResolverConfig.class,
PaymentInstructionCreatorConfigTest.class,
ValidationConfig.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
public abstract class AbstractClearingTest {
@Autowired
@Qualifier("hazelcastServiceTest")
protected HazelcastService hazelcastServiceTest;
@Captor
protected ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
protected MockProducer<String, Object> mockProducer;
protected void init() {
hazelcastServiceTest.waitAvailable();
TestUtils.FutureRecordMetadata future = spy(TestUtils.FutureRecordMetadata.class);
doReturn(future).when(mockProducer).send(producerRecord.capture());
}
}

259
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/ClearingServiceTest.java
View file

@ -1,17 +1,9 @@
package ru.spcex.clearing.service;
import org.apache.kafka.clients.consumer.MockConsumer;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.mock.mockito.SpyBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.account.AccountBalance;
import ru.clearing.classes.statics.data.company.Company;
@ -21,7 +13,6 @@ import ru.clearing.classes.statics.data.generated.ClearingMemberCategory;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.spcex.clearing.config.*;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.Consts;
@ -30,13 +21,10 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.DealRegisterNewR
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.service.builder.LiabilitiesClaimsAssetsCreator;
import ru.spcex.clearing.service.builder.LiabilitiesClaimsMoneyCreator;
import ru.spcex.clearing.service.order.ExecutionDepositSorter;
import ru.spcex.clearing.service.order.PaymentInstructionSorter;
import ru.spcex.clearing.utils.MatcherFactory;
import ru.spcex.clearing.utils.TestUtils;
import ru.spcex.platform.enumeration.*;
import ru.spcex.platform.imdg.api.Imdg;
import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import javax.annotation.PostConstruct;
@ -45,34 +33,17 @@ import java.time.Instant;
import java.time.LocalDate;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static ru.spcex.clearing.config.HazelcastServiceTestConfiguration.currentID;
import static ru.spcex.clearing.utils.MatcherFactory.usingIgnoringFieldsComparator;
import static ru.spcex.clearing.utils.TestUtils.addRecordToKafka;
import static ru.spcex.clearing.utils.TestUtils.getJsonStringForNew;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {
SdfCreatorBySTLDPayment.class,
PaymentUpdateBySdf04.class,
VerificationResultComponent.class,
ExecutionDepositComponent.class,
ExecutionDepositSorter.class,
LiabilitiesClaimsAssetsCreator.class,
LiabilitiesClaimsMoneyCreator.class,
EventsReceiver.class,
ClearingService.class,
Clearing.class,
SortingConfig.class,
PaymentInstructionSorter.class,
MessageResolverConfig.class,
PaymentInstructionCreatorConfigTest.class,
ValidationConfig.class,
KafkaConfigTest.class,
HazelcastServiceTestConfiguration.class})
class ClearingServiceTest {
class ClearingServiceTest extends AbstractClearingTest {
public static final MatcherFactory.Matcher<LiabilitiesClaimsAssets> LIABILITIES_CLAIMS_ASSETS_MATCHER = usingIgnoringFieldsComparator("created", "updated");
public static final MatcherFactory.Matcher<LiabilitiesClaimsMoney> LIABILITIES_CLAIMS_MONEY_MATCHER = usingIgnoringFieldsComparator("created", "updated");
public static final MatcherFactory.Matcher<PaymentInstruction> PAYMENT_INSTRUCTION_MATCHER = usingIgnoringFieldsComparator("created", "updated");
@ -80,7 +51,9 @@ class ClearingServiceTest {
private static final int PARTITION = 0;
private static final String TOPIC_START_CLEARING = Task.startOfClearing.topic();
private static final String TOPIC_CONTINUE_CLEARING = Consts.CONTINUE_CLEARING;
private static final Long ID = currentID.getAndIncrement();
private static final Long FIRST_ID = currentID.getAndIncrement();
private static final Long SECOND_ID = currentID.getAndIncrement();
private static final AtomicInteger currentInteger = new AtomicInteger(1);
@Autowired
EventsReceiver eventsReceiver;
@ -94,10 +67,6 @@ class ClearingServiceTest {
@Autowired
LiabilitiesClaimsMoneyCreator lbltsClmsMoneyCreator;
@Autowired
@Qualifier("hazelcastServiceTest")
private HazelcastService hazelcastServiceTest;
private Imdg<ExecutionDeposit> executionDepositImdg;
private Imdg<LiabilitiesClaimsAssets> liabilitiesClaimsAssetsImdg;
private Imdg<LiabilitiesClaimsMoney> liabilitiesClaimsMoneyImdg;
@ -108,15 +77,14 @@ class ClearingServiceTest {
private Imdg<AccountBalance> accountBalanceImdg;
private ClearingCategory category;
private ExecutionDeposit executionDeposit;
@Captor
private ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
private MockProducer<String, Object> mockProducer;
private Relation relation;
private Account account;
private Company company;
private AccountBalance accountBalance;
@PostConstruct
private void init() {
hazelcastServiceTest.waitAvailable();
protected void init() {
super.init();
this.executionDepositImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class);
this.clearingCategoryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
this.liabilitiesClaimsAssetsImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class);
@ -126,17 +94,21 @@ class ClearingServiceTest {
this.companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.accountImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.accountBalanceImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
TestUtils.FutureRecordMetadata future = spy(TestUtils.FutureRecordMetadata.class);
doReturn(future).when(mockProducer).send(producerRecord.capture());
}
/**
* {@link ClearingService#executeClearing()} <br>
* Тест проверяет создание сущности {@link LauncherCommandRequest} в Hazelcast при передаче из Apache Kafka.<br>
* Тест проверяет создание сущностей
* {@link LauncherCommandRequest}
* {@link LiabilitiesClaimsMoney}
* {@link PaymentInstruction}
* {@link ExecutionDeposit}
* в Hazelcast при передаче из Apache Kafka.<br>
*/
@Test
void startClearingNew() {
//ARRANGE
int times = currentInteger.getAndIncrement();
Long companyIdI1 = 11L;
Long relationIdI1 = 111L;
Long accountIdI1 = 1111L;
@ -149,7 +121,7 @@ class ClearingServiceTest {
//ACT
//stage executeClearing(startClearing)
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, 0, getJsonStringForNew(new DealRegisterNewRequest(), ID));
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
//waiting for kafka producer send message
verify(mockProducer, timeout(230_000L).times(1))
@ -160,7 +132,7 @@ class ClearingServiceTest {
//stage continueClearing
CommonIdRequest requestPayload = new CommonIdRequest();
requestPayload.setId(baseRequestResult.getId());
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, 0, getJsonStringForNew(requestPayload, ID));
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
//waiting for kafka producer send message (finale event)
verify(mockProducer, timeout(230_000L).times(2))
@ -207,6 +179,165 @@ class ClearingServiceTest {
EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
}
/**
* {@link ClearingService#executeClearing()} <br>
* Тест проверяет обновление сущностей
* {@link LauncherCommandRequest}
* {@link LiabilitiesClaimsMoney}
* {@link PaymentInstruction}
* {@link ExecutionDeposit}
* в Hazelcast при передаче из Apache Kafka.<br>
*/
@Test
void startClearingUpdate() {
//ARRANGE
int times = currentInteger.getAndIncrement();
Long companyIdI1 = 21L;
Long relationIdI1 = 211L;
Long accountIdI1 = 2111L;
Long securityIdI1 = 21111L;
LocalDate firstSettlementDateI1 = LocalDate.now();
LocalDate secondSettlementDateI2 = LocalDate.ofYearDay(2022, 31);
preparOptimisticCase(companyIdI1, relationIdI1, accountIdI1,
securityIdI1, firstSettlementDateI1, secondSettlementDateI2, "I");
LiabilitiesClaimsAssets predictableFirstClaimsAssets = lbltsClmsAssetsCreator.createFirstLegLCA(category, executionDeposit);
predictableFirstClaimsAssets.setId(FIRST_ID);
liabilitiesClaimsAssetsImdg.insert(predictableFirstClaimsAssets);
LiabilitiesClaimsMoney predictableFirstClaimsMoney = lbltsClmsMoneyCreator.createFirstLegLcm(predictableFirstClaimsAssets, category);
predictableFirstClaimsMoney.setId(FIRST_ID);
liabilitiesClaimsMoneyImdg.insert(predictableFirstClaimsMoney);
LiabilitiesClaimsAssets predictableSecondClaimsAssets = lbltsClmsAssetsCreator.createSecondLegLCA(category, executionDeposit);
predictableSecondClaimsAssets.setId(SECOND_ID);
liabilitiesClaimsAssetsImdg.insert(predictableSecondClaimsAssets);
LiabilitiesClaimsMoney predictableSecondClaimsMoney = lbltsClmsMoneyCreator.createSecondLegLcm(predictableSecondClaimsAssets, category);
predictableSecondClaimsMoney.setId(SECOND_ID);
liabilitiesClaimsMoneyImdg.insert(predictableSecondClaimsMoney);
//ACT
//stage executeClearing(startClearing)
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
//waiting for kafka producer send message
verify(mockProducer, timeout(230_000L).times(1))
.send(producerRecord.capture());
assertEquals(Consts.BALANCE_ACCOUNT_UPDATE, producerRecord.getValue().topic());
BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
//stage continueClearing
CommonIdRequest requestPayload = new CommonIdRequest();
requestPayload.setId(baseRequestResult.getId());
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
//waiting for kafka producer send message (finale event)
verify(mockProducer, timeout(230_000L).times(2))
.send(producerRecord.capture());
//ASSERT
assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
//First LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
LiabilitiesClaimsAssets resultFirstClaimsAssets = liabilitiesClaimsAssetsImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
LiabilitiesClaimsMoney resultFirstClaimsMoney = liabilitiesClaimsMoneyImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
predictableFirstClaimsAssets.setPaymentId(resultFirstClaimsAssets.getPaymentId());
predictableFirstClaimsAssets.setLiabilitiesClaimsMoneyId(resultFirstClaimsMoney.getId());
lbltsClmsAssetsCreator.updateFirstLegLca(predictableFirstClaimsAssets, executionDeposit, category);
lbltsClmsMoneyCreator.updateFirstLegLcm(predictableFirstClaimsMoney, predictableFirstClaimsAssets, executionDeposit, category);
LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultFirstClaimsAssets, predictableFirstClaimsAssets);
LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultFirstClaimsMoney, predictableFirstClaimsMoney);
//Second LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
LiabilitiesClaimsAssets resultSecondClaimsAssets = liabilitiesClaimsAssetsImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
LiabilitiesClaimsMoney resultSecondClaimsMoney = liabilitiesClaimsMoneyImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
predictableSecondClaimsAssets.setLiabilitiesClaimsMoneyId(resultSecondClaimsMoney.getId());
lbltsClmsAssetsCreator.updateSecondLegLca(predictableSecondClaimsAssets, executionDeposit, category);
lbltsClmsMoneyCreator.updateSecondLegLcm(predictableSecondClaimsMoney, predictableSecondClaimsAssets, executionDeposit, category);
LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultSecondClaimsAssets, predictableSecondClaimsAssets);
LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultSecondClaimsMoney, predictableSecondClaimsMoney);
//PaymentInstruction
PaymentInstruction resultPaymentInstruction = paymentInstructionCreator.searchExistPaymentInstructionsFirstI(predictableFirstClaimsAssets);
PaymentInstruction predictablePaymentInstruction = paymentInstructionCreator.createPaymentInstruction(executionDeposit, predictableFirstClaimsAssets, Collections.singleton(category));
predictablePaymentInstruction.setId(resultPaymentInstruction.getId());
predictablePaymentInstruction.setDocumentNumber(resultPaymentInstruction.getDocumentNumber());
PAYMENT_INSTRUCTION_MATCHER.assertMatch(resultPaymentInstruction, predictablePaymentInstruction);
//ExecutionDeposit
ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getSingleObjectByFieldValues(
Map.of("accountId", accountIdI1, "securityId", securityIdI1));
executionDeposit.setSessionId(resultExecutionDeposit.getSessionId());
EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
}
/**
* {@link ClearingService#executeClearing()} <br>
* Тест проверяет обновление сущностей
* {@link LauncherCommandRequest}
* {@link LiabilitiesClaimsMoney}
* {@link PaymentInstruction}
* {@link ExecutionDeposit}
* в Hazelcast при передаче из Apache Kafka.<br>
*/
@Test
void startClearingValidatError() {
//ARRANGE
Long companyId = 31L;
Long relationId = 311L;
Long accountId = 3111L;
Long securityId = 31111L;
LocalDate firstSettlementDate = LocalDate.now();
LocalDate secondSettlementDate = LocalDate.ofYearDay(2022, 31);
preparOptimisticCase(companyId, relationId, accountId,
securityId, firstSettlementDate, secondSettlementDate, "V");
//ClearingIsAllowed
relation.setServiceStatus(ServiceStatus.Blocked.getKey());
relationImdg.insert(relation);
checkHaveSomeError(currentInteger.getAndIncrement());
//AccountIsNotBlocked
relation.setServiceStatus(ServiceStatus.Active.getKey());
relationImdg.insert(relation);
executionDeposit = getExecutionDeposit(companyId, null, securityId, firstSettlementDate, secondSettlementDate);
executionDepositImdg.insert(executionDeposit);
checkHaveSomeError(currentInteger.getAndIncrement());
executionDeposit = getExecutionDeposit(companyId, accountId, securityId, firstSettlementDate, secondSettlementDate);
executionDepositImdg.insert(executionDeposit);
account.setAccountStatus(AccountStatus.BLOCKED.getKey());
accountImdg.insert(account);
checkHaveSomeError(currentInteger.getAndIncrement());
//CompanyIsNotBlocked
account.setAccountStatus(AccountStatus.ACTIVE.getKey());
accountImdg.insert(account);
company.setWorkflowStatus(WorkflowStatus.Blocked.getKey());
companyImdg.insert(company);
checkHaveSomeError(currentInteger.getAndIncrement());
company.setWorkflowStatus(null);
companyImdg.insert(company);
checkHaveSomeError(currentInteger.getAndIncrement());
//FinancialObligationSecurity
company.setWorkflowStatus(WorkflowStatus.Active.getKey());
companyImdg.insert(company);
accountBalance.setAccountId(0L);
accountBalanceImdg.insert(accountBalance);
checkHaveSomeError(currentInteger.getAndIncrement());
accountBalance.setAccountId(accountId);
accountBalance.setFreeBalanceAmount(new BigDecimal(19));
accountBalanceImdg.insert(accountBalance);
executionDeposit.setFirstLegAmount(new BigDecimal(200));
executionDepositImdg.insert(executionDeposit);
checkHaveSomeError(currentInteger.getAndIncrement());
}
void preparOptimisticCase(Long companyId, Long relationId, Long accountId,
Long securityId, LocalDate dtF, LocalDate dtS, String memberCategory) {
category = IEnumKey.getEnumByKey(ClearingCategory.class, memberCategory);
@ -219,24 +350,24 @@ class ClearingServiceTest {
clearingMemberCategory.setClearingMemberCategory(memberCategory);
clearingCategoryImdg.insert(clearingMemberCategory);
Relation relation = new Relation();
relation = new Relation();
relation.setId(relationId);
relation.setConsumerId(companyId);
relation.setServiceStatus(ServiceStatus.Active.getKey());
relationImdg.insert(relation);
Account account = new Account();
account = new Account();
account.setId(accountId);
account.setRelationId(relationId);
account.setAccountStatus(AccountStatus.ACTIVE.getKey());
accountImdg.insert(account);
Company company = new Company();
company = new Company();
company.setId(companyId);
company.setWorkflowStatus(WorkflowStatus.Active.getKey());
companyImdg.insert(company);
AccountBalance accountBalance = new AccountBalance();
accountBalance = new AccountBalance();
accountBalance.setAccountId(accountId);
accountBalance.setCompanyId(companyId);
accountBalanceImdg.insert(accountBalance);
@ -256,7 +387,7 @@ class ClearingServiceTest {
executionDeposit.setSecondLegAmount(new BigDecimal(6));
executionDeposit.setInterestAmount(new BigDecimal(5));
executionDeposit.setSide("side");
executionDeposit.setSettlementCurrency("settlement");
executionDeposit.setSettlementCurrency("settlementCurrency");
executionDeposit.setCompanyId(companyId);
executionDeposit.setDuration(1L);
executionDeposit.setFirstLegSettlementDate(dtF);
@ -270,6 +401,24 @@ class ClearingServiceTest {
executionDeposit.setCoverageStatus(Allowed.ALLOWED.getKey());
executionDeposit.setSessionId(null);
executionDeposit.setClearingDate(LocalDate.now());
executionDeposit.setId(FIRST_ID);
return executionDeposit;
}
void checkHaveSomeError(long times) {
//ACT
//stage executeClearing(startClearing)
addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
//waiting for kafka producer send message
verify(mockProducer, timeout(230_000L).times((int) times))
.send(producerRecord.capture());
//ASSERT
assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getSingleObjectBySQL("settlementCurrency = 'settlementCurrency'");
executionDeposit.setUpdated(resultExecutionDeposit.getUpdated());
executionDeposit.setCoverageStatus(Allowed.DENIED.getKey());
EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
}
}

27
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/PaymentUpdateBySdf04Test.java Normal file
View file

@ -0,0 +1,27 @@
package ru.spcex.clearing.service;
import org.junit.jupiter.api.Test;
import ru.clearing.classes.statics.data.payment.PaymentInstruction;
import ru.clearing.classes.statics.data.sdf.SDf04;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.platform.imdg.api.Imdg;
import javax.annotation.PostConstruct;
class PaymentUpdateBySdf04Test extends AbstractClearingTest {
private Imdg<PaymentInstruction> paymentImdgs;
private Imdg<SDf04> sdf04Imdg;
@PostConstruct
protected void init() {
super.init();
this.paymentImdgs = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
this.sdf04Imdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_SDf04, SDf04.class);
}
@Test
void updatePayments() {
SDf04 sDf04s = new SDf04();
PaymentInstruction payment = new PaymentInstruction();
}
}