AccountServiceTest (update/new)

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java

@@ -1,6 +1,7 @@
 package ru.spcex.clearing.account.service;
 
 import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
@@ -39,10 +40,7 @@ import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
 import java.util.function.Function;
 
 @Service
@@ -61,6 +59,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
 
     @Autowired
     public AccountService(Consumer<String, Object> kafkaQueue,
+                          Producer<String, Object> kafkaProducer,
                           ImdgProvider imdgProvider,
                           KafkaSender kafkaSender,
                           IMessageResolver messageResolver,
@@ -72,7 +71,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
                                   Function<AccountCorrespondentUpdateRequest, IValidator> accountUpdateRequestValidator,
                           @Qualifier("accountCorrespondentBlockRequestValidator")
                                   Function<CommonDeleteRequest, IValidator> accountBlockRequestValidator) {
-        super(kafkaQueue);
+        super(kafkaQueue, kafkaProducer);
         this.accountMap = imdgProvider.getImdg(
                 IMDGDistributedNames.Map_Account, Account.class
         );
@@ -155,12 +154,15 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         }
         Relation relation = relations.iterator().next();
 
+        Collection<Account> companies = accountMap.getCollectionObjectsByFieldValues(Map.of("companyId", companyId));
+
         Account account = new Account();
         account.setAccount(req.getAccount());
         account.setAccountType(req.getAccountType());
         account.setRelationId(relation.getId());
         account.setStatus(req.getStatus());
-        account.setProcessingSign(Allowed.ALLOWED.getKey());
+        // todo выяснить у репортера, что писать в это поле если это не первый счет компании
+        account.setProcessingSign(companies.isEmpty() ? Allowed.ALLOWED.getKey() : null);
         account.setCompanyId(req.getCompanyId());
         Long id = accountMap.insert(account);
 
@@ -181,9 +183,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
 
         Account account = accountMap.getSingleObjectByID(request.getId());
 
-        if (request.getAccount() != null && !account.getAccount().equalsIgnoreCase(request.getAccount()))
+        if (request.getAccount() != null) account.setAccount(request.getAccount());
-            return makeError(AccountError.WrongFieldValue, "account", userRequest.getId());
-        account.setAccount(request.getAccount());
 
         if (request.getCompanyId() != null && !Objects.equals(account.getCompanyId(), request.getCompanyId()))
             return makeError(AccountError.WrongFieldValue, "companyId", userRequest.getId());

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/AccountServiceTest.java

@@ -15,34 +15,50 @@ 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.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.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.ValidationConfig;
 import ru.spcex.clearing.account.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountCorrespondentNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.AccountCorrespondentUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdf01Request;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.AccountSdfToStatementRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
 import ru.spcex.clearing.platform.messaging.service.RequestInfo;
 import ru.spcex.clearing.platform.messaging.service.Status;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 
+import javax.annotation.PostConstruct;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
 import static ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration.currentID;
 import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
-import static ru.spcex.clearing.account.utils.TestUtils.addRecordToKafka;
+import static ru.spcex.clearing.account.utils.TestUtils.*;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
+        BeanConfiguration.class,
+        ValidationConfig.class,
+        AccountValidationConfig.class,
         AccountService.class,
         HazelcastServiceTestConfiguration.class,
         KafkaConfigTest.class})
@@ -52,6 +68,8 @@ class AccountServiceTest {
     private static final int PARTITION = 0;
     private static final String TOPIC_ACCOUNT_NEW = Consts.ACCOUNT_NEW_SDF01;
     private static final String account = "123456789123";
+    private static final Long companyId = 0L;
+    private static final Long relationId = 0L;
     @Autowired
     AccountService accountService;
     @Autowired
@@ -63,14 +81,120 @@ class AccountServiceTest {
     @SpyBean
     private MockProducer<String, Object> producer;
 
+    private Imdg<Account> accountImdg;
+    private Imdg<Company> companyImdg;
+    private Imdg<AccountTypeDictionary> accountTypeDictionaryImdg;
+    private Imdg<ClearingMemberCategory> clearingMemberCategoryImdg;
+    private Imdg<Relation> relationImdg;
+
+    @PostConstruct
+    private void init() {
+        hazelcastServiceTest.waitAvailable();
+        accountImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Account, Account.class
+        );
+        companyImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_Company, Company.class
+        );
+        accountTypeDictionaryImdg = hazelcastServiceTest.getImdg(
+                IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.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.Corr.getKey());
+        accountTypeDictionary.setName(AccountType.Corr.getKey());
+        accountTypeDictionaryImdg.insert(accountTypeDictionary);
+
+        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 accountCorrespondentNew() {
+        AccountCorrespondentNewRequest accountCorrespondentNewRequest = new AccountCorrespondentNewRequest();
+        accountCorrespondentNewRequest.setAccount(account);
+        accountCorrespondentNewRequest.setAccountType(AccountType.Corr.getKey());
+        accountCorrespondentNewRequest.setCompanyId(companyId);
+        accountCorrespondentNewRequest.setStatus(AccountStatus.ACTIVE.getKey());
+
+        Account predictableAccount = new Account();
+        predictableAccount.setAccount(account);
+        predictableAccount.setAccountType(AccountType.Corr.getKey());
+        predictableAccount.setCompanyId(companyId);
+        predictableAccount.setProcessingSign(Allowed.ALLOWED.getKey());
+        predictableAccount.setStatus(AccountStatus.ACTIVE.getKey());
+        predictableAccount.setRelationId(relationId);
+
+        String jsonString = getJsonStringForNew(accountCorrespondentNewRequest, 0L);
+
+        addRecordToKafka((MockConsumer) accountService.getConsumer(),
+                Consts.DESTINATION_ACCOUNT_CORRESPONDENT_NEW,
+                PARTITION,
+                0,
+                jsonString);
+
+        waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
+
+        Account resultNew = accountImdg.getCollectionObjectsByFieldValues(Map.of("companyId", companyId)).iterator().next();
+        predictableAccount.setId(resultNew.getId());
+        ACCOUNT_MATCHER.assertMatch(resultNew, predictableAccount);
 
     }
 
     @Test
     void accountCorrespondentUpdate() {
+        String updatedAccount = account + "_updated";
 
+        Account existAccount = new Account();
+        existAccount.setAccount(account);
+        existAccount.setAccountType(AccountType.Corr.getKey());
+        existAccount.setStatus(AccountStatus.ACTIVE.getKey());
+        existAccount.setCompanyId(companyId);
+        Long accountId = accountImdg.insert(existAccount);
+
+        AccountCorrespondentUpdateRequest accountCorrespondentUpdateRequest = new AccountCorrespondentUpdateRequest();
+        accountCorrespondentUpdateRequest.setAccount(updatedAccount);
+        accountCorrespondentUpdateRequest.setAccountType(AccountType.Corr.getKey());
+        accountCorrespondentUpdateRequest.setStatus(AccountStatus.ACTIVE.getKey());
+        accountCorrespondentUpdateRequest.setCompanyId(companyId);
+        accountCorrespondentUpdateRequest.setId(accountId);
+
+
+        String jsonString = getJsonStringForUPDATE(accountCorrespondentUpdateRequest, 0);
+
+        //ACT
+        addRecordToKafka((MockConsumer) accountService.getConsumer(),
+                Consts.DESTINATION_ACCOUNT_CORRESPONDENT_UPDATE,
+                PARTITION,
+                0,
+                jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(0L, producer, producerRecord);
+
+        existAccount.setAccount(updatedAccount);
+
+        Account resultUpdating = accountImdg.getSingleObjectByID(accountId);
+        ACCOUNT_MATCHER.assertMatch(resultUpdating, existAccount);
     }
 
     @Test

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java

@@ -360,7 +360,7 @@ public class BankAccountServiceTest {
         bankAccountImdg.insert(bankAccountExists);
         Account account = new Account();
         account.setId(accountId);
-        account.setAccountStatus(WorkflowStatus.Active.getKey());
+        account.setStatus(WorkflowStatus.Active.getKey());
         accountImdg.insert(account);
 
         CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();