http://jira.mfd.msk:8088/browse/CLS-280

---
registry service unit tests

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterServiceTest.java

@@ -0,0 +1,129 @@
+package ru.spcex.clearing.registry.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.register.AdmittedLiabilitiesRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        AdmittedLiabilitiesRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class AdmittedLiabilitiesRegisterServiceTest {
+    //consts
+
+    private static int requestCount = 0;
+    private static final String securitySymbol = "SYMBOL";
+    private static final Long companyId = 1L;
+    private static final String clearingCode = "CODE";
+    private static final String account = "ACCOUNT";
+    private static final BigDecimal balance = new BigDecimal(1);
+    private static final LocalDate clearingDate = LocalDate.now();
+    private static final String COMPANY_FULL_NAME = "ROGA";
+    private Long REGISTRY_SPY_ID;
+    private final Long sessionId = 0L;
+    private Imdg<Registry> registryMap;
+    private Imdg<Company> companyMap;
+    private Imdg<AdmittedLiabilitiesRegister> admittedLiabilitiesRegisterMap;
+    @Autowired
+    private AdmittedLiabilitiesRegisterService admittedLiabilitiesRegisterService;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        //initializing of imdg
+        companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        admittedLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class);
+        // initialing objects for imdg repos
+
+        Long securityId = 1L;
+        Registry registry = new Registry();
+        registry.setRegistryDesignation(RegistryDesignation.O.getKey());
+        registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
+        registry.setRegistryUnit(RegistryUnit.T.getKey());
+        registry.setRegistryStatus(RegistryStatus.OK.getKey());
+        registry.setSecurityId(securityId);
+        registry.setSessionId(sessionId);
+        registry.setSecuritySymbol(securitySymbol);
+        registry.setCompanyId(companyId);
+        registry.setClearingCode(clearingCode);
+        registry.setAccount(account);
+        registry.setBalance(balance);
+        registry.setClearingDate(clearingDate);
+        REGISTRY_SPY_ID = registryMap.insert(registry);
+
+        Company company = new Company();
+        company.setId(1L);
+        company.setFullName(COMPANY_FULL_NAME);
+        companyMap.insert(company);
+    }
+
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) admittedLiabilitiesRegisterService.getConsumer(),
+                Task.createRegistry_ADLR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<AdmittedLiabilitiesRegister> allValues = admittedLiabilitiesRegisterMap.getAllValues();
+        AdmittedLiabilitiesRegister admittedLiabilitiesRegister = allValues.iterator().next();
+        assertEquals(companyId, admittedLiabilitiesRegister.getCompanyId());
+        assertEquals(clearingCode, admittedLiabilitiesRegister.getClearingCode());
+        assertEquals(account, admittedLiabilitiesRegister.getAccount());
+        assertEquals(balance, admittedLiabilitiesRegister.getAmount());
+        assertEquals(clearingDate, admittedLiabilitiesRegister.getClearingDate());
+        assertEquals(COMPANY_FULL_NAME, admittedLiabilitiesRegister.getCompanyFullName());
+    }
+
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterServiceTest.java

@@ -0,0 +1,127 @@
+package ru.spcex.clearing.registry.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.register.CoveredLiabilitiesRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        CoveredLiabilitiesRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class CoveredLiabilitiesRegisterServiceTest {
+    private static int requestCount = 0;
+    private static final String securitySymbol = "SYMBOL";
+    private static final Long companyId = 1L;
+    private static final String clearingCode = "CODE";
+    private static final String account = "ACCOUNT";
+    private static final BigDecimal balance = new BigDecimal(1);
+    private static final LocalDate clearingDate = LocalDate.now();
+    private static final String COMPANY_FULL_NAME = "ROGA";
+    private Imdg<CoveredLiabilitiesRegister> coveredLiabilitiesRegisterMap;
+    private Imdg<Registry> registryMap;
+    private Imdg<Company> companyMap;
+    private Long REGISTRY_SPY_ID;
+    private final Long sessionId = 0L;
+
+    @Autowired
+    private CoveredLiabilitiesRegisterService coveredLiabilitiesRegisterService;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        //initializing of imdg
+        companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        coveredLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class);
+        // initialing objects for imdg repos
+
+        Long securityId = 1L;
+        Registry registry = new Registry();
+        registry.setRegistryDesignation(RegistryDesignation.O.getKey());
+        registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
+        registry.setRegistryUnit(RegistryUnit.T.getKey());
+        registry.setRegistryStatus(RegistryStatus.OK.getKey());
+        registry.setSecurityId(securityId);
+        registry.setSessionId(sessionId);
+        registry.setSecuritySymbol(securitySymbol);
+        registry.setCompanyId(companyId);
+        registry.setClearingCode(clearingCode);
+        registry.setAccount(account);
+        registry.setBalance(balance);
+        registry.setClearingDate(clearingDate);
+        REGISTRY_SPY_ID = registryMap.insert(registry);
+
+        Company company = new Company();
+        company.setId(1L);
+        company.setFullName(COMPANY_FULL_NAME);
+        companyMap.insert(company);
+    }
+
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) coveredLiabilitiesRegisterService.getConsumer(),
+                Task.createRegistry_CDLR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<CoveredLiabilitiesRegister> allValues = coveredLiabilitiesRegisterMap.getAllValues();
+        CoveredLiabilitiesRegister coveredLiabilitiesRegister = allValues.iterator().next();
+        assertEquals(companyId, coveredLiabilitiesRegister.getCompanyId());
+        assertEquals(clearingCode, coveredLiabilitiesRegister.getClearingCode());
+        assertEquals(account, coveredLiabilitiesRegister.getAccount());
+        assertEquals(balance, coveredLiabilitiesRegister.getAmount());
+        assertEquals(clearingDate, coveredLiabilitiesRegister.getClearingDate());
+        assertEquals(COMPANY_FULL_NAME, coveredLiabilitiesRegister.getCompanyFullName());
+    }
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterServiceTest.java

@@ -0,0 +1,113 @@
+package ru.spcex.clearing.registry.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.register.DepoBalanceRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        DepoBalanceRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class DepoBalanceRegisterServiceTest {
+    private static int requestCount = 0;
+
+    private static final Long companyId = 1L;
+    private static final Long sessionId = 1L;
+    private static final String account = "ACCOUNT";
+    private static final BigDecimal balance = new BigDecimal(1);
+    private static final String SECURITY_SYMBOL= "SECURITY_SYMBOL";
+
+    private Imdg<DepoBalanceRegister> depoBalanceRegisterMap;
+    private Imdg<Registry> registryMap;
+
+    @Autowired
+    private DepoBalanceRegisterService depoBalanceRegisterService;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        //initializing of imdg
+        registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class);
+        // initialing objects for imdg repos
+
+        Long securityId = 1L;
+        Registry registry = new Registry();
+        registry.setRegistryDesignation(RegistryDesignation.A.getKey());
+        registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
+        registry.setRegistryUnit(RegistryUnit.T.getKey());
+        registry.setRegistryStatus(RegistryStatus.OK.getKey());
+        registry.setSessionId(sessionId);
+        registry.setCompanyId(companyId);
+        registry.setAccountType(AccountType.Depo.getKey());
+        registry.setAccount(account);
+        registry.setBalance(balance);
+        registry.setSecuritySymbol(SECURITY_SYMBOL);
+        registryMap.insert(registry);
+    }
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) depoBalanceRegisterService.getConsumer(),
+                Task.createRegistry_GRRT.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<DepoBalanceRegister> allValues = depoBalanceRegisterMap.getAllValues();
+        DepoBalanceRegister depoBalanceRegister = allValues.iterator().next();
+        assertEquals(sessionId, depoBalanceRegister.getSessionId());
+        assertEquals(companyId, depoBalanceRegister.getCompanyId());
+        assertEquals(account, depoBalanceRegister.getDepoCode());
+        assertEquals(balance, depoBalanceRegister.getQuantity());
+        assertEquals(SECURITY_SYMBOL, depoBalanceRegister.getSecuritySymbol());
+    }
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterServiceTest.java

@@ -0,0 +1,133 @@
+package ru.spcex.clearing.registry.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.misc.Session;
+import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+import ru.clearing.classes.statics.data.register.DepoPaymentInstructionRegister;
+import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
+import ru.clearing.platform.dictionary.InOutDirectionDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.Task;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        DepoPaymentInstructionRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+class DepoPaymentInstructionRegisterServiceTest {
+    private Imdg<DepoPaymentInstructionRegister> depoPaymentInstructionRegisterMap;
+    private Imdg<PaymentInstruction> paymentInstructionMap;
+    private Imdg<Session> sessionMap;
+    private Imdg<TradingClearingRegistry> tradingClearingRegistryMap;
+    private Imdg<InOutDirectionDictionary> inOutDirectionDictionaryMap;
+    private static int requestCount = 0;
+    private static final Long SESSION_ID = 1L;
+    private static final String SESSION_SECTION = "FOND";
+    private static final Long TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID = 100L;
+    private static final Long TRADING_CLEARING_REGISTRY_COMPANY_ID = 101L;
+    private static final String TRADING_CLEARING_REGISTRY_TYPE = "TYPE";
+    private static final String TRADING_CLEARING_REGISTRY_CODE = "CODE";
+    private static final String SET_CREDIT_LEG_DIRECTION = "PAYMENT_INSTRUCTION_CREDIT_LEG";
+    private static final BigDecimal SET_CREDIT_LEG_AMOUNT = new BigDecimal(1);
+    private static final Long IN_OUT_DIRECTION_DICTIONARY_ID = 123L;
+    @Autowired
+    private DepoPaymentInstructionRegisterService depoPaymentInstructionRegisterService;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        //initializing of imdg
+        depoPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class);
+        paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
+        sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        tradingClearingRegistryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
+        inOutDirectionDictionaryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class);
+
+        // initialing objects for imdg repos
+
+    }
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+        Session session = new Session();
+        session.setSection(SESSION_SECTION);
+        session.setId(SESSION_ID);
+        sessionMap.update(session);
+
+        PaymentInstruction paymentInstruction = new PaymentInstruction();
+        paymentInstruction.setSessionId(SESSION_ID);
+        paymentInstruction.setCreditLeg_accountId(TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID);
+        paymentInstruction.setSenderId(TRADING_CLEARING_REGISTRY_COMPANY_ID);
+        paymentInstruction.setCreditLeg_direction(SET_CREDIT_LEG_DIRECTION);
+        paymentInstruction.setCreditLeg_amount(SET_CREDIT_LEG_AMOUNT);
+        paymentInstructionMap.insert(paymentInstruction);
+
+
+        TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry();
+        tradingClearingRegistry.setCompanyId(TRADING_CLEARING_REGISTRY_COMPANY_ID);
+        tradingClearingRegistry.setDepoAccountId(TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID);
+        tradingClearingRegistry.setTradingClearingRegistryType(TRADING_CLEARING_REGISTRY_TYPE);
+        tradingClearingRegistry.setCode(TRADING_CLEARING_REGISTRY_CODE);
+        tradingClearingRegistryMap.insert(tradingClearingRegistry);
+
+        InOutDirectionDictionary inOutDirectionDictionary = new InOutDirectionDictionary();
+        inOutDirectionDictionary.setCode(SET_CREDIT_LEG_DIRECTION);
+        inOutDirectionDictionary.setId(IN_OUT_DIRECTION_DICTIONARY_ID);
+        inOutDirectionDictionaryMap.update(inOutDirectionDictionary);
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) depoPaymentInstructionRegisterService.getConsumer(),
+                Task.createRegistry_GORD.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<DepoPaymentInstructionRegister> allValues = depoPaymentInstructionRegisterMap.getAllValues();
+        DepoPaymentInstructionRegister   depoPaymentInstructionRegister = allValues.iterator().next();
+        assertEquals(SESSION_ID, depoPaymentInstructionRegister.getSessionId());
+        assertEquals(TRADING_CLEARING_REGISTRY_COMPANY_ID, depoPaymentInstructionRegister.getCompanyId());
+        assertEquals(TRADING_CLEARING_REGISTRY_TYPE, depoPaymentInstructionRegister.getTradingClearingRegistryType());
+        assertEquals(TRADING_CLEARING_REGISTRY_CODE, depoPaymentInstructionRegister.getTradingClearingRegistry());
+        assertEquals(IN_OUT_DIRECTION_DICTIONARY_ID, depoPaymentInstructionRegister.getDirection());
+        assertEquals(SET_CREDIT_LEG_AMOUNT, depoPaymentInstructionRegister.getQuantity());
+    }
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java

@@ -1,34 +1,143 @@
 package ru.spcex.clearing.registry.service;
 
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.misc.Session;
 import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister;
-import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
+import ru.spcex.platform.utils.time.TimeUtil;
 
-import static org.junit.jupiter.api.Assertions.*;
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Collection;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        ExcludeLiabilitiesRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class ExcludeLiabilitiesRegisterServiceTest {
+    private static int requestCount = 0;
 
-    @Test
+    @Autowired
-    void getSqlForRegistries() {
+    private ExcludeLiabilitiesRegisterService excludeLiabilitiesRegisterService;
-        ExcludeLiabilitiesRegisterService svc = instance();
+    private Imdg<ExcludeLiabilitiesRegister> excludeLiabilitiesRegisterMap;
-        assertEquals("registryDesignation = 'O' and registryInstrumentType  in ('S','M') and registryUnit = 'T' and registryStatus in ('FAIL', 'UNCV')",
+    private Imdg<Registry> registryMap;
-                svc.getSqlForRegistries());
+    private Imdg<Session> sessionMap;
+    private Imdg<ru.clearing.classes.statics.data.company.CompanySymbols> companySymbolMap;
+
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        excludeLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class);
+        registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        companySymbolMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, ru.clearing.classes.statics.data.company.CompanySymbols.class);
     }
 
+    private static final Long SESSION_ID = 10L;
+    private static final Long SECURITY_ID = 101L;
+    private static final Long REGISTRY_COMPANY_ID = 10L;
+    private static final String REGISTRY_COMPANY_FULL_NAME = "full_nome";
+    private static final String REGISTRY_CODE    = "full_nome";
+    private static final String REGISTRY_ACCOUNT    = "full_nome";
+    private static final String REGISTRY_STATUS    = RegistryStatus.FAIL.getKey();
+    private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(1);
+    private static final LocalDate SESSION_CLEARING_DATE = LocalDate.now();
+    private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now();
+    private static final Instant  SESSION_UPDATED = Instant.now();
+    private static final String  COMPANY_SYMBOL_VALUE = "COMPANY_SYMBOL_VALUE";
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+        Registry registry = new Registry();
+        registry.setRegistryDesignation(RegistryDesignation.O.getKey());
+        registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
+        registry.setRegistryUnit(RegistryUnit.T.getKey());
+        registry.setRegistryStatus(REGISTRY_STATUS);
+        registry.setSessionId(SESSION_ID);
+        registry.setCompanyId(REGISTRY_COMPANY_ID);
+        registry.setFullName(REGISTRY_COMPANY_FULL_NAME);
+        registry.setRegistryCode(REGISTRY_CODE);
+        registry.setAccount(REGISTRY_ACCOUNT);
+        registry.setBalance(REGISTRY_BALANCE);
+        registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE);
+        registry.setSecurityId(SECURITY_ID);
+        registryMap.insert(registry);
 
-    ExcludeLiabilitiesRegisterService instance() {
+        Session session = new Session();
-        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
+        session.setId(SESSION_ID);
-        Imdg<ExcludeLiabilitiesRegister> map1 = Mockito.mock(Imdg.class);
+        session.setClearingDate(SESSION_CLEARING_DATE);
-        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        session.setUpdated(SESSION_UPDATED);
-        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class)).thenReturn(map1);
+        sessionMap.update(session);
+        CompanySymbols companySymbols = new CompanySymbols();
+        companySymbols.setCompanyId(REGISTRY_COMPANY_ID);
+        companySymbols.setCompanySymbol(CompanySymbol.INN.getKey());
+        companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE);
+        companySymbolMap.insert(companySymbols);
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) excludeLiabilitiesRegisterService.getConsumer(),
+                Task.createRegistry_EXLR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<ExcludeLiabilitiesRegister> allValues = excludeLiabilitiesRegisterMap.getAllValues();
+        ExcludeLiabilitiesRegister excludeLiabilitiesRegister = allValues.iterator().next();
+        assertEquals(SESSION_ID, excludeLiabilitiesRegister.getSessionId());
+        assertEquals(REGISTRY_COMPANY_ID, excludeLiabilitiesRegister.getCompanyId());
+        assertEquals(REGISTRY_COMPANY_FULL_NAME, excludeLiabilitiesRegister.getCompanyFullName());
+        assertEquals(REGISTRY_CODE, excludeLiabilitiesRegister.getRegistryCode());
+        assertEquals(REGISTRY_ACCOUNT, excludeLiabilitiesRegister.getAccount());
+        assertEquals(REGISTRY_STATUS, excludeLiabilitiesRegister.getRegistryStatus());
+        assertEquals(REGISTRY_BALANCE, excludeLiabilitiesRegister.getSumLiabilities());
+        assertEquals(SESSION_CLEARING_DATE, excludeLiabilitiesRegister.getValidFromDate());
+        assertEquals(REGISTRY_SETTLEMENT_DATE, excludeLiabilitiesRegister.getSettlementDate());
+        assertEquals(TimeUtil.toLocalDate(SESSION_UPDATED),  excludeLiabilitiesRegister.getValidToDate());
+        assertEquals(COMPANY_SYMBOL_VALUE, excludeLiabilitiesRegister.getInn());
 
-        return new ExcludeLiabilitiesRegisterService(null, null, imdg, null);
     }
 
 }

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExecutionRegisterServiceTest.java

@@ -24,12 +24,10 @@ import ru.spcex.clearing.test.TestUtils;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.platform.enumeration.CompanySymbol;
-import ru.spcex.platform.enumeration.MoneyFlowSide;
 import ru.spcex.platform.enumeration.Side;
 import ru.spcex.platform.enumeration.Task;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
 
 import javax.annotation.PostConstruct;
 import java.math.BigDecimal;
@@ -164,11 +162,10 @@ class ExecutionRegisterServiceTest {
         executionFond.setTradingClearingRegistryId(TKR_FOR_TKR_ID);
         executionFond.setCompanyId(COMPANY_ID);
         executionFond.setCounterPartyId(COUNTER_PARTY_ID);
-        executionFond.setSide(Side.SELL.getKey());
+        executionFond.setSide(Side.BUY.getKey());
         executionFond.setCounterPartyTradingClearingRegistry(COUNTER_PARTY_TKR);
         executionFond.setPartyTradingClearingRegistry(PARTY_TKR);
         executionFondImdg.insert(executionFond);
-        ((ImdgHazelcast)executionDepositImdg).clear(); // чтобы не влиял второй тест
 
         LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
 
@@ -188,16 +185,16 @@ class ExecutionRegisterServiceTest {
         assertEquals(executionRegister.getExchangeExecutionId(), EXCHANGE_EXECUTION_ID);
         assertEquals(executionRegister.getExchangeExecutionTime(), EXCHANGE_EXECUTION_TIME);
         assertEquals(executionRegister.getSecurityId(), SECURITY_ID);
-        assertEquals(executionRegister.getSellerId(), COMPANY_ID);
+        assertEquals(executionRegister.getSellerId(), COUNTER_PARTY_ID);
-        assertEquals(executionRegister.getSellerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COMPANY_ID);
+        assertEquals(executionRegister.getSellerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COUNTER_PARTY_ID);
-        assertEquals(executionRegister.getSellerTradingClearingRegister(), PARTY_TKR);
+        assertEquals(executionRegister.getSellerTradingClearingRegister(), COUNTER_PARTY_TKR);
-        assertEquals(executionRegister.getSellerMoneyAccount(), MONEY_ACCOUNT_FOR_TKR);
+        assertEquals(executionRegister.getSellerMoneyAccount(), MONEY_ACCOUNT_FOR_COUNTER_PARTY_TKR);
-        assertEquals(executionRegister.getSellerDepoAccount(), DEPO_ACCOUNT_FOR_TKR);
+        assertEquals(executionRegister.getSellerDepoAccount(), DEPO_ACCOUNT_FOR_COUNTER_PARTY_TKR);
-        assertEquals(executionRegister.getBuyerId(), COUNTER_PARTY_ID);
+        assertEquals(executionRegister.getBuyerId(), COMPANY_ID);
-        assertEquals(executionRegister.getBuyerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COUNTER_PARTY_ID);
+        assertEquals(executionRegister.getBuyerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COMPANY_ID);
-        assertEquals(executionRegister.getBuyerTradingClearingRegister(), COUNTER_PARTY_TKR);
+        assertEquals(executionRegister.getBuyerTradingClearingRegister(), PARTY_TKR);
-        assertEquals(executionRegister.getBuyerMoneyAccount(), MONEY_ACCOUNT_FOR_COUNTER_PARTY_TKR);
+        assertEquals(executionRegister.getBuyerMoneyAccount(), MONEY_ACCOUNT_FOR_TKR);
-        assertEquals(executionRegister.getBuyerDepoAccount(), DEPO_ACCOUNT_FOR_COUNTER_PARTY_TKR);
+        assertEquals(executionRegister.getBuyerDepoAccount(), DEPO_ACCOUNT_FOR_TKR);
         assertEquals(executionRegister.getAmount(), SETTLEMENT_AMOUNT);
         assertEquals(executionRegister.getQuantity(), QUANTITY);
         assertEquals(executionRegister.getClearingDate(), LocalDate.now());
@@ -220,11 +217,10 @@ class ExecutionRegisterServiceTest {
         executionDeposit.setTradingClearingRegistryId(TKR_FOR_TKR_ID);
         executionDeposit.setCompanyId(COMPANY_ID);
         executionDeposit.setCounterPartyId(COUNTER_PARTY_ID);
-        executionDeposit.setSide(MoneyFlowSide.SELL.getKey());
+        executionDeposit.setSide(Side.SELL.getKey());
         executionDeposit.setCounterPartyTradingClearingRegistry(COUNTER_PARTY_TKR);
         executionDeposit.setPartyTradingClearingRegistry(PARTY_TKR);
         executionDepositImdg.insert(executionDeposit);
-        ((ImdgHazelcast)executionFondImdg).clear(); // чтобы не влиял первый тест
 
         LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
 

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java

@@ -1,31 +1,143 @@
 package ru.spcex.clearing.registry.service;
 
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.misc.Session;
 import ru.clearing.classes.statics.data.register.LiabilitiesRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
+import ru.spcex.platform.utils.time.TimeUtil;
 
-import static org.junit.jupiter.api.Assertions.*;
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Collection;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        LiabilitiesRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class LiabilitiesRegisterServiceTest {
+    private static int requestCount = 0;
+    private static final String REGISTRY_DESIGNATION = RegistryDesignation.L.getKey();
+    private static final String REGISTRY_INSTRUMENT_TYPE = RegistryInstrumentType.S.getKey();
+    private static final String REGISTRY_UNIT = RegistryUnit.T.getKey();
+    private static final String REGISTRY_FULL_NAME = "MY FULLNAME";
+    private static final String REGISTRY_CODE = "ANY CODE";
+    private static final String REGISTRY_ACCOUNT = "ANY ACCOUNT";
+    private static final String REGISTRY_STATUS = "ANY STATUS";
+    private static final Long REGISTRY_SESSION_ID = 1234L;
+    private static final Long REGISTRY_COMPANY_ID = 10101L;
+    private static final Long REGISTRY_SECURITY_ID = 123411L;
+    private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(123411L);
+    private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now();
+    private static final LocalDate SESSION_CLEARING_DATE = LocalDate.now();
+    private static final Instant SESSION_UPDATE = Instant.now();
+    private static final String COMPANY_SYMBOL_INN = CompanySymbol.INN.getKey();
+    private static final String COMPANY_SYMBOL_VALUE = "ANY VALUE";
+
+    @Autowired
+    private LiabilitiesRegisterService liabilitiesRegisterService;
+    private Imdg<LiabilitiesRegister> liabilitiesRegisterMap;
+    private Imdg<Registry> registryMap;
+    private Imdg<Session> sessionMap;
+    private Imdg<CompanySymbols> companySymbolsMap;
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+
+        this.liabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class);
+        this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
+        this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+        this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+    }
 
     @Test
-    void getSqlForRegistries() {
+    @Order(1)
-        LiabilitiesRegisterService svc = instance();
+    void executionRegisterNewForClearingDate() {
-        assertEquals("registryDesignation = 'L' and registryInstrumentType  in ('S','M') and registryUnit = 'T'",
+        Registry registry = new Registry();
-                svc.getSqlForRegistries());
+        registry.setRegistryUnit(REGISTRY_UNIT);
-    }
+        registry.setRegistryInstrumentType(REGISTRY_INSTRUMENT_TYPE);
+        registry.setRegistryDesignation(REGISTRY_DESIGNATION);
+        registry.setSessionId(REGISTRY_SESSION_ID);
+        registry.setCompanyId(REGISTRY_COMPANY_ID);
+        registry.setFullName(REGISTRY_FULL_NAME);
+        registry.setRegistryCode(REGISTRY_CODE);
+        registry.setAccount(REGISTRY_ACCOUNT);
+        registry.setRegistryStatus(REGISTRY_STATUS);
+        registry.setBalance(REGISTRY_BALANCE);
+        registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE);
+        registry.setSecurityId(REGISTRY_SECURITY_ID);
+        registryMap.insert(registry);
 
+        Session session = new Session();
+        session.setId(REGISTRY_SESSION_ID);
+        session.setClearingDate(SESSION_CLEARING_DATE);
+        session.setUpdated(SESSION_UPDATE);
+        sessionMap.update(session);
 
-    LiabilitiesRegisterService instance() {
+        CompanySymbols companySymbols = new CompanySymbols();
-        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
+        companySymbols.setCompanyId(REGISTRY_COMPANY_ID);
-        Imdg<LiabilitiesRegister> map1 = Mockito.mock(Imdg.class);
+        companySymbols.setCompanySymbol(COMPANY_SYMBOL_INN);
-        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE);
-        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class)).thenReturn(map1);
+        companySymbolsMap.insert(companySymbols);
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
 
-        return new LiabilitiesRegisterService(null, null, imdg, null);
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) liabilitiesRegisterService.getConsumer(),
+                Task.createRegistry_LBSR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<LiabilitiesRegister> allValues = liabilitiesRegisterMap.getAllValues();
+        LiabilitiesRegister liabilitiesRegister = allValues.iterator().next();
+        assertEquals(REGISTRY_COMPANY_ID, liabilitiesRegister.getCompanyId());
+        assertEquals(REGISTRY_FULL_NAME, liabilitiesRegister.getCompanyFullName());
+        assertEquals(REGISTRY_CODE, liabilitiesRegister.getRegistryCode());
+        assertEquals(REGISTRY_ACCOUNT, liabilitiesRegister.getAccount());
+        assertEquals(REGISTRY_STATUS, liabilitiesRegister.getRegistryStatus());
+        assertEquals(REGISTRY_BALANCE, liabilitiesRegister.getSumLiabilities());
+        assertEquals(REGISTRY_SETTLEMENT_DATE, liabilitiesRegister.getSettlementDate());
+        assertEquals(SESSION_CLEARING_DATE, liabilitiesRegister.getValidFromDate());
+        assertEquals(TimeUtil.toLocalDate(SESSION_UPDATE), liabilitiesRegister.getValidToDate());
+        assertEquals(COMPANY_SYMBOL_VALUE, liabilitiesRegister.getInn());
     }
 }

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java

@@ -1,123 +1,154 @@
 package ru.spcex.clearing.registry.service;
 
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+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.Company;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
-import ru.spcex.platform.enumeration.RegistryUnit;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
 
-import java.util.ArrayList;
+import javax.annotation.PostConstruct;
-import java.util.List;
+import java.math.BigDecimal;
-import java.util.stream.Collectors;
+import java.time.LocalDate;
+import java.util.Collection;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        MoneyBalanceRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class MoneyBalanceRegisterServiceTest {
+    private static final String REGISTRY_DESIGNATION = RegistryDesignation.A.getKey();
+    private static final String REGISTRY_INSTRUMENT_TYPE = RegistryInstrumentType.M.getKey();
+    private static final String REGISTRY_FULL_NAME = "MY FULLNAME";
+    private static final String REGISTRY_CODE = "ANY CODE";
+    private static final String REGISTRY_ACCOUNT = "CLRN VALUE";
+    private static final String ACCOUNT_ACCOUNT = "ACCOUNT";
+    private static final String REGISTRY_ACCOUNT_TYPE = "CLRN";
+    private static final String REGISTRY_STATUS = "ANY STATUS";
+    private static final Long REGISTRY_SESSION_ID = 1234L;
+    private static final Long REGISTRY_COMPANY_ID = 10101L;
+    private static final Long REGISTRY_SECURITY_ID = 123411L;
+    private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(123411L);
+    private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now();
+     private static final String COMPANY_SYMBOL_INN = CompanySymbol.INN.getKey();
+    private static final String COMPANY_SYMBOL_VALUE = "ANY VALUE";
+    private static final String COMPANY_SHORTNAME = "ANY VALUE";
+    private static int requestCount = 0;
+    @Autowired
+    private MoneyBalanceRegisterService moneyBalanceRegisterService;
+    private Imdg<MoneyBalanceRegister> moneyBalanceRegisterMap;
+    private Imdg<Registry> registryMap;
+    private Imdg<CompanySymbols> companySymbolsMap;
+    private Imdg<Company> companyMap;
+    private Imdg<Account> accountMap;
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
 
-    @Test
+    @Autowired
-    void groupingRegistry() {
+    @Qualifier("mockProducer")
-        MoneyBalanceRegisterService svc = testInstance();
+    private Producer<String, Object> producer;
-        ArrayList<Registry> regs1 = new ArrayList<>();
-        assertEquals(0, svc.groupingRegistry(regs1).size());
-        {
-            Registry r = new Registry();
-            r.setId(1001L);
-            r.setCompanyId(10L);
-            r.setAccount("A100");
-            r.setAccountId(100L);
-            r.setRegistryUnit(RegistryUnit.T.getKey());
-            regs1.add(r);
-        }
-        {
-            Registry r = new Registry();
-            r.setId(1002L);
-            r.setCompanyId(10L);
-            r.setAccount("A100");
-            r.setAccountId(100L);
-            r.setRegistryUnit(RegistryUnit.B.getKey());
-            regs1.add(r);
-        }
-        {
-            Registry r = new Registry();
-            r.setId(1003L);
-            r.setCompanyId(10L);
-            r.setAccount("A100");
-            r.setAccountId(100L);
-            r.setRegistryUnit(RegistryUnit.F.getKey());
-            regs1.add(r);
-        }
-        {
-            Registry r = new Registry();
-            r.setId(1004L);
-            r.setCompanyId(110L);
-            r.setAccount("A103");
-            r.setAccountId(103L);
-            r.setRegistryUnit(RegistryUnit.F.getKey());
-            regs1.add(r);
-        }
-        {
-            Registry r = new Registry();
-            r.setId(1005L);
-            r.setCompanyId(10L);
-            r.setAccount("A101");
-            r.setAccountId(101L);
-            r.setRegistryUnit(RegistryUnit.F.getKey());
-            regs1.add(r);
-        }
 
-        List<List<Registry>> out = svc.groupingRegistry(regs1);
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
 
-        assertEquals("[[Registry{id=1004}], [Registry{id=1001}, Registry{id=1002}, Registry{id=1003}], [Registry{id=1005}]]",
+        moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class);
-                "[" + out.stream().map(lst -> "[" + lst.stream().map(v -> v.toString()).collect(Collectors.joining(", ")) + "]")
+        registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-                        .collect(Collectors.joining(", ")) + "]");
+        companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
     }
 
     @Test
-    void getSqlForRegistries() {
+    @Order(1)
-        MoneyBalanceRegisterService svc = testInstance();
+    void executionRegisterNewForClearingDate() {
-        assertEquals("(companyId=1000 AND (registryDesignation=A AND registryInstrumentType=M))",
+        Registry registry = new Registry();
-                svc.getSqlForRegistries(1000L).toString());
+        registry.setRegistryUnit(RegistryUnit.T.getKey());
+        registry.setRegistryInstrumentType(REGISTRY_INSTRUMENT_TYPE);
+        registry.setRegistryDesignation(REGISTRY_DESIGNATION);
+        registry.setSessionId(REGISTRY_SESSION_ID);
+        registry.setCompanyId(REGISTRY_COMPANY_ID);
+        registry.setFullName(REGISTRY_FULL_NAME);
+        registry.setRegistryCode(REGISTRY_CODE);
+        registry.setAccount(REGISTRY_ACCOUNT);
+        registry.setAccountType(REGISTRY_ACCOUNT_TYPE);
+        registry.setRegistryStatus(REGISTRY_STATUS);
+        registry.setBalance(REGISTRY_BALANCE);
+        registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE);
+        registry.setSecurityId(REGISTRY_SECURITY_ID);
+        registryMap.insert(registry);
+        registry.setId(null);
+        registry.setRegistryUnit(RegistryUnit.B.getKey());
+        registryMap.insert(registry);
+        registry.setId(null);
+        registry.setRegistryUnit(RegistryUnit.F.getKey());
+        registryMap.insert(registry);
+        Company company = new Company();
+        company.setId(2L);
+        company.setShortName(COMPANY_SHORTNAME);
+        companyMap.insert(company);
+
+        CompanySymbols companySymbols = new CompanySymbols();
+        companySymbols.setCompanyId(REGISTRY_COMPANY_ID);
+        companySymbols.setCompanySymbol(COMPANY_SYMBOL_INN);
+        companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE);
+        companySymbolsMap.insert(companySymbols);
+
+        Account account = new Account();
+        account.setCompanyId(REGISTRY_COMPANY_ID);
+        account.setAccountType(AccountType.Info.getKey());
+        account.setAccount(ACCOUNT_ACCOUNT);
+        accountMap.insert(account);
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+        launcherCommandRequest.setCompanyId(REGISTRY_COMPANY_ID);
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) moneyBalanceRegisterService.getConsumer(),
+                Task.createRegistry_GBRR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<MoneyBalanceRegister> allValues = moneyBalanceRegisterMap.getAllValues();
+        MoneyBalanceRegister moneyBalanceRegister = allValues.iterator().next();
+        assertEquals(REGISTRY_COMPANY_ID, moneyBalanceRegister.getCompanyId());
+        assertEquals(REGISTRY_FULL_NAME, moneyBalanceRegister.getCompanyFullName());
+        assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getRemainderSum());
+        assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getBlockedSum());
+        assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getUnblockedSum());
+        assertEquals(REGISTRY_ACCOUNT, moneyBalanceRegister.getAccount());
+        assertEquals(ACCOUNT_ACCOUNT, moneyBalanceRegister.getInfoAccount());
+        assertEquals(COMPANY_SHORTNAME, moneyBalanceRegister.getSetHouseName());
+        assertEquals(COMPANY_SYMBOL_VALUE, moneyBalanceRegister.getInn());
     }
-
-    @Test
-    void getSqlForRemainderSum() {
-        MoneyBalanceRegisterService svc = testInstance();
-        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=T))",
-                svc.getSqlForRemainderSum(1000L, "ACC-2").toString());
-    }
-
-    @Test
-    void getSqlForBlockedSum() {
-        MoneyBalanceRegisterService svc = testInstance();
-        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=B))",
-                svc.getSqlForBlockedSum(1000L, "ACC-2").toString());
-    }
-
-    @Test
-    void getSqlForUnblockedSum() {
-        MoneyBalanceRegisterService svc = testInstance();
-        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=F))",
-                svc.getSqlForUnblockedSum(1000L, "ACC-2").toString());
-    }
-
-    static MoneyBalanceRegisterService testInstance() {
-        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
-        Imdg<MoneyBalanceRegister> map1 = Mockito.mock(Imdg.class);
-        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
-        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class)).thenReturn(map1);
-        Imdg<Registry> map2 = Mockito.mock(Imdg.class);
-        Mockito.when(map2.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
-        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_Registry, Registry.class)).thenReturn(map2);
-
-        MoneyBalanceRegisterService instance = new MoneyBalanceRegisterService(null, null, imdg, null);
-        return instance;
-
-        //todo тесты с выборкой с реальным тестовым Imdg, чтобы провалидировать типы данных в SQL
-    }
-
 }

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterServiceTest.java

@@ -0,0 +1,123 @@
+package ru.spcex.clearing.registry.service;
+
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.producer.Producer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.misc.Session;
+import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+import ru.clearing.classes.statics.data.register.MoneyPaymentInstructionRegister;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.clearing.registry.config.ValidationConfig;
+import ru.spcex.clearing.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.platform.enumeration.Task;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.util.Collection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+        ValidationConfig.class,
+        MoneyPaymentInstructionRegisterService.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
+})
+class MoneyPaymentInstructionRegisterServiceTest {
+    private static int requestCount = 0;
+    private Imdg<MoneyPaymentInstructionRegister> moneyPaymentInstructionRegisterMap;
+    private Imdg<PaymentInstruction> paymentInstructionMap;
+    private Imdg<Session> sessionMap;
+    private Imdg<Company> companyMap;
+    private final String CREDITLEG_ACCOUNT_CONST = "CREDITLEG_ACCOUNT_CONST";
+    private final BigDecimal CREDITLEG_AMOUNT_CONST = new BigDecimal(1);
+    private final String CREDITLEG_CURRENCYCODE_CONST = "CREDITLEG_CURRENCYCODE_CONST";
+    private final String DEBITLEG_ACCOUNT_CONST = "DEBITLEG_ACCOUNT_CONST";
+    private final String COMPANY_SHORT_NAME_SENDER_CONST = "COMPANY_SHORT_NAME_SENDER_CONST";
+    private final String COMPANY_SHORT_NAME_ADDRESSEE_CONST = "COMPANY_SHORT_NAME_ADDRESSEE_CONST";
+    @Autowired
+    @Qualifier("hazelcastServiceTest")
+    private ImdgProvider imdgProvider;
+
+    @Autowired
+    @Qualifier("mockProducer")
+    private Producer<String, Object> producer;
+
+    @Autowired
+    private MoneyPaymentInstructionRegisterService moneyPaymentInstructionRegisterService;
+
+    @PostConstruct
+    private void init() {
+        ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
+        companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        moneyPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class);
+        paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
+        sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
+
+
+    }
+
+    @Test
+    @Order(1)
+    void executionRegisterNewForClearingDate() {
+        Long sessionId = 1L;
+        Long companySenderId = 1L;
+        Long companyAddresseeId = 2L;
+        Session sessionMkr = new Session();
+        sessionMkr.setSection("MKR");
+        sessionMkr.setId(sessionId);
+        sessionMap.update(sessionMkr);
+        PaymentInstruction paymentInstruction = new PaymentInstruction();
+        paymentInstruction.setSessionId(sessionId);
+        paymentInstruction.setCreditLeg_account(CREDITLEG_ACCOUNT_CONST);
+        paymentInstruction.setCreditLeg_amount(CREDITLEG_AMOUNT_CONST);
+        paymentInstruction.setCreditLeg_currencyCode(CREDITLEG_CURRENCYCODE_CONST);
+        paymentInstruction.setDebitLeg_account(DEBITLEG_ACCOUNT_CONST);
+        paymentInstruction.setSenderId(companySenderId);
+        paymentInstruction.setAddresseeId(companyAddresseeId);
+        paymentInstructionMap.insert(paymentInstruction);
+        Company companySender = new Company();
+        companySender.setId(companySenderId);
+        companySender.setShortName(COMPANY_SHORT_NAME_SENDER_CONST);
+        companyMap.update(companySender);
+        Company companyAddressee = new Company();
+        companyAddressee.setId(companyAddresseeId);
+        companyAddressee.setShortName(COMPANY_SHORT_NAME_ADDRESSEE_CONST);
+        companyMap.update(companyAddressee);
+        //making launcherCommand
+        LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
+
+        String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L);
+
+        TestUtils.addRecordToKafka((MockConsumer) moneyPaymentInstructionRegisterService.getConsumer(),
+                Task.createRegistry_GORR.topic(),
+                requestCount++,
+                0,
+                jsonString);
+
+        TestUtils.waitingSendAndCheckRecord(0L, producer);
+
+        //take all values is procceed imdg
+        Collection<MoneyPaymentInstructionRegister> allValues = moneyPaymentInstructionRegisterMap.getAllValues();
+        MoneyPaymentInstructionRegister moneyPaymentInstructionRegister = allValues.iterator().next();
+        assertEquals(CREDITLEG_ACCOUNT_CONST, moneyPaymentInstructionRegister.getCreditLegAccount());
+        assertEquals(CREDITLEG_AMOUNT_CONST, moneyPaymentInstructionRegister.getCreditLegAmount());
+        assertEquals(CREDITLEG_CURRENCYCODE_CONST, moneyPaymentInstructionRegister.getCreditLegCurrencyCode());
+        assertEquals(DEBITLEG_ACCOUNT_CONST, moneyPaymentInstructionRegister.getDebitLegAccount());
+        assertEquals(COMPANY_SHORT_NAME_SENDER_CONST, moneyPaymentInstructionRegister.getSender());
+        assertEquals(COMPANY_SHORT_NAME_ADDRESSEE_CONST, moneyPaymentInstructionRegister.getAddressee());
+    }
+}