From 09b65585c450cc4eb48e42b2bd0109138bf348bb Mon Sep 17 00:00:00 2001 From: akulikov Date: Tue, 2 May 2023 16:00:39 +0300 Subject: [PATCH] clearingAccountNew test --- .../ClearingAccountValidationConfig.java | 14 +- .../config/validation/ValidationConfig.java | 2 + .../service/ClearingAccountService.java | 1 + .../service/ClearingAccountServiceTest.java | 178 ++++++++++++++++++ .../InformationAccountServiceTest.java | 4 +- 5 files changed, 194 insertions(+), 5 deletions(-) create mode 100644 clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java index 3c1b42b0b..29b3a3e98 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java @@ -4,10 +4,12 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.clearing.classes.statics.data.account.Account; import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountNewRequest; import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountUpdateRequest; +import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; import ru.spcex.clearing.validation.common.rules.FieldRequiredRule; import ru.spcex.clearing.validation.common.rules.IdPresentRule; import ru.spcex.platform.classes.base.SpcexObjectBase; @@ -29,6 +31,7 @@ import java.util.function.Function; @Configuration public class ClearingAccountValidationConfig { + // todo add validation for clearingAccountType from dictionary @Bean("clearingAccountNewRequestValidator") public Function clearingAccountNewRequestValidator( Map> imdgForValidation @@ -37,8 +40,10 @@ public class ClearingAccountValidationConfig { ImdgValidationContext context = new ImdgValidationContext<>(); context.setValidatedObject(clearingAccountNewRequest); Consumer addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s)); + addImdg.accept(IMDGDistributedNames.Map_Account); addImdg.accept(IMDGDistributedNames.Map_Company); addImdg.accept(IMDGDistributedNames.Map_ClearingAccount); + addImdg.accept(IMDGDistributedNames.Map_ClearingAccountTypeDictionary); return new ValidatorImpl<>(context, IdPresentRule.instance("companyId", ClearingAccountNewRequest::getCompanyId, @@ -62,12 +67,15 @@ public class ClearingAccountValidationConfig { accountStatusPredicate, accountTypePredicate); Collection accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate); - if (!accounts.isEmpty()) return null; + if (accounts.isEmpty()) return null; return AccountError.AccountAlreadyExist; }), - FieldRequiredRule.instance("clearingAccountType", + DictionaryPresentRule.instance("clearingAccountType", ClearingAccountNewRequest::getClearingAccountType, - AccountError.RequiredFieldEmpty) + IMDGDistributedNames.Map_ClearingAccountTypeDictionary, + ClearingAccountTypeDictionary.class, + AccountError.RequiredFieldEmpty, + AccountError.WrongFieldValue) ); }; } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java index ccf3d40b1..36cebc49d 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java @@ -9,6 +9,7 @@ import ru.clearing.classes.statics.data.account.ClearingAccount; import ru.clearing.classes.statics.data.account.InformationAccount; import ru.clearing.classes.statics.data.company.ClearingMemberCategory; import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; import ru.clearing.platform.dictionary.CurrencyCodeDictionary; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.validation.common.ValidationHelper; @@ -31,6 +32,7 @@ public class ValidationConfig { addImdg.accept(IMDGDistributedNames.Map_Company, Company.class); addImdg.accept(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class); + addImdg.accept(IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class); addImdg.accept(IMDGDistributedNames.Map_Account, Account.class); addImdg.accept(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class); addImdg.accept(IMDGDistributedNames.Map_AccountTypeDictionary, Account.class); diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java index 96e509797..03f148353 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/ClearingAccountService.java @@ -110,6 +110,7 @@ public class ClearingAccountService extends QueueConsumer implements Initializin ClearingAccount clearingAccount = new ClearingAccount(); clearingAccount.setCompanyId(req.getCompanyId()); clearingAccount.setAccountId(accountId); + clearingAccount.setClearingAccountType(req.getClearingAccountType()); clearingAccountId = clearingAccountImdg.insert(clearingAccount); txOk = true; } finally { diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java new file mode 100644 index 000000000..c50e7b194 --- /dev/null +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/ClearingAccountServiceTest.java @@ -0,0 +1,178 @@ +package ru.spcex.clearing.account.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.ClearingAccount; +import ru.clearing.classes.statics.data.company.ClearingMemberCategory; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.relation.Relation; +import ru.clearing.platform.dictionary.AccountTypeDictionary; +import ru.clearing.platform.dictionary.ClearingAccountTypeDictionary; +import ru.spcex.clearing.account.config.BeanConfiguration; +import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration; +import ru.spcex.clearing.account.config.KafkaConfigTest; +import ru.spcex.clearing.account.config.validation.AccountValidationConfig; +import ru.spcex.clearing.account.config.validation.ClearingAccountValidationConfig; +import ru.spcex.clearing.account.config.validation.ValidationConfig; +import ru.spcex.clearing.account.utils.MatcherFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.Consts; +import ru.spcex.clearing.platform.messaging.domain.cud.account.ClearingAccountNewRequest; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService; + +import javax.annotation.PostConstruct; +import java.util.Map; + +import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator; +import static ru.spcex.clearing.account.utils.TestUtils.*; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + BeanConfiguration.class, + ValidationConfig.class, + ClearingAccountValidationConfig.class, + AccountValidationConfig.class, + AccountService.class, + ClearingAccountService.class, + HazelcastServiceTestConfiguration.class, + KafkaConfigTest.class}) +class ClearingAccountServiceTest { + public static final MatcherFactory.Matcher INFORMATION_ACCOUNT_MATCHER = usingIgnoringFieldsComparator(); + public static final MatcherFactory.Matcher ACCOUNT_MATCHER = usingIgnoringFieldsComparator("created", "updated"); + private static final int PARTITION = 0; + private static final Long companyId = 0L; + private static final Long relationId = 0L; + private static final String CLEARING_ACCOUNT_TYPE_DICT = "A"; + private static final String ACCOUNT_VALUE = "account-value"; + + @Autowired + ClearingAccountService clearingAccountService; + + @Autowired + @Qualifier("hazelcastServiceTest") + private HazelcastService hazelcastServiceTest; + + @Captor + private ArgumentCaptor producerRecord; + @SpyBean + private MockProducer producer; + + private Imdg clearingAccountImdg; + private Imdg accountImdg; + private Imdg companyImdg; + private Imdg clearingAccountTypeDictionaryImdg; + private Imdg accountTypeDictionaryImdg; + private Imdg clearingMemberCategoryImdg; + private Imdg relationImdg; + + + @PostConstruct + private void init() { + hazelcastServiceTest.waitAvailable(); + clearingAccountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class + ); + accountImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_Account, Account.class + ); + + companyImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_Company, Company.class + ); + accountTypeDictionaryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class + ); + clearingAccountTypeDictionaryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class + ); + clearingMemberCategoryImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class + ); + relationImdg = hazelcastServiceTest.getImdg( + IMDGDistributedNames.Map_Relation, Relation.class + ); + + Company company = new Company(); + company.setId(companyId); + company.setWorkflowStatus(WorkflowStatus.Active.getKey()); + companyImdg.insert(company); + + AccountTypeDictionary accountTypeDictionary = new AccountTypeDictionary(); + accountTypeDictionary.setCode(AccountType.Clrn.getKey()); + accountTypeDictionary.setName(AccountType.Clrn.getKey()); + accountTypeDictionaryImdg.insert(accountTypeDictionary); + + ClearingAccountTypeDictionary clearingAccountTypeDictionary = new ClearingAccountTypeDictionary(); + clearingAccountTypeDictionary.setName(CLEARING_ACCOUNT_TYPE_DICT); + clearingAccountTypeDictionary.setCode(CLEARING_ACCOUNT_TYPE_DICT); + clearingAccountTypeDictionaryImdg.insert(clearingAccountTypeDictionary); + + ClearingMemberCategory clearingMemberCategory = new ClearingMemberCategory(); + clearingMemberCategory.setClearingMemberCategory(ClearingCategory.B.getKey()); + clearingMemberCategory.setCompanyId(companyId); + clearingMemberCategoryImdg.insert(clearingMemberCategory); + + Relation relation = new Relation(); + relation.setId(relationId); + relation.setConsumerId(companyId); + relation.setService(Service.MKR.getKey()); + relationImdg.insert(relation); + + } + + @Test + void clearingAccountNew() { + ClearingAccountNewRequest clearingAccountNewRequest = new ClearingAccountNewRequest(); + clearingAccountNewRequest.setAccount(ACCOUNT_VALUE); + clearingAccountNewRequest.setCompanyId(companyId); + clearingAccountNewRequest.setClearingAccountType(CLEARING_ACCOUNT_TYPE_DICT); + + String jsonString = getJsonStringForNew(clearingAccountNewRequest, 0L); + + addRecordToKafka((MockConsumer) clearingAccountService.getConsumer(), + Consts.DESTINATION_CLEARING_ACCOUNT_NEW, + PARTITION, + 0, + jsonString); + + waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord); + + Account predictableAccount = new Account(); + predictableAccount.setAccount(ACCOUNT_VALUE); + predictableAccount.setAccountType(AccountType.Clrn.getKey()); + predictableAccount.setStatus(AccountStatus.ACTIVE.getKey()); + predictableAccount.setRelationId(relationId); + predictableAccount.setCompanyId(companyId); + + ClearingAccount predictableClearingAccount = new ClearingAccount(); + predictableClearingAccount.setCompanyId(companyId); + predictableClearingAccount.setClearingAccountType(CLEARING_ACCOUNT_TYPE_DICT); + + Account resultAccountNew = accountImdg.getSingleObjectByFieldValues(Map.of("accountType", AccountType.Clrn.getKey())); + ClearingAccount resultClearingAccountNew = clearingAccountImdg.getSingleObjectByFieldValues(Map.of("accountId", resultAccountNew.getId())); + + predictableAccount.setId(resultAccountNew.getId()); + predictableClearingAccount.setAccountId(resultAccountNew.getId()); + predictableClearingAccount.setId(resultClearingAccountNew.getId()); + + ACCOUNT_MATCHER.assertMatch(resultAccountNew, predictableAccount); + INFORMATION_ACCOUNT_MATCHER.assertMatch(resultClearingAccountNew, predictableClearingAccount); + + clearingAccountImdg.delete(resultClearingAccountNew); + accountImdg.delete(resultAccountNew); + } + +} \ No newline at end of file diff --git a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java index 5d8b6b124..176245ab5 100644 --- a/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java +++ b/clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/InformationAccountServiceTest.java @@ -106,8 +106,8 @@ class InformationAccountServiceTest { companyImdg.insert(company); AccountTypeDictionary accountTypeDictionary = new AccountTypeDictionary(); - accountTypeDictionary.setCode(AccountType.Corr.getKey()); - accountTypeDictionary.setName(AccountType.Corr.getKey()); + accountTypeDictionary.setCode(AccountType.Info.getKey()); + accountTypeDictionary.setName(AccountType.Info.getKey()); accountTypeDictionaryImdg.insert(accountTypeDictionary); ClearingMemberCategory clearingMemberCategory = new ClearingMemberCategory();