Fix tests.

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/HazelcastServiceTestConfiguration.java

@@ -1,68 +0,0 @@
-package ru.spcex.clearing.backendapi.controller.config;
-
-import com.hazelcast.config.*;
-import com.hazelcast.core.Hazelcast;
-import com.hazelcast.core.HazelcastInstance;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
-import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
-import ru.spcex.platform.imdg.iml.hazelcast.util.HazelcastHelper;
-
-import java.util.List;
-import java.util.Random;
-
-@Configuration
-public class HazelcastServiceTestConfiguration {
-    private HazelcastInstance hazelcastInstance;
-
-    private static ThreadPoolTaskExecutor createThreadPoolTaskExecutor(int maxPoolSz, boolean waitForCompletion) {
-        ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
-        if (maxPoolSz > 2) {
-            pool.setKeepAliveSeconds(60);
-            pool.setAllowCoreThreadTimeOut(true);
-        }
-        pool.setCorePoolSize(maxPoolSz);
-        pool.setWaitForTasksToCompleteOnShutdown(waitForCompletion);
-        return pool;
-    }
-
-    @Bean(name = "hazelcastServiceTest")
-    public HazelcastService hazelcastService(@Qualifier("taskExecutorHazelcastClientInitializer") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer, @Qualifier("taskExecutorIdGeneratorAwaiter") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter, HazelcastClientParams params) {
-        Config cfg = new Config();
-        cfg.setInstanceName("localhost");
-
-        NetworkConfig networkConfig = new NetworkConfig();
-        JoinConfig joinConfig = new JoinConfig();
-        joinConfig.setMulticastConfig(new MulticastConfig().setEnabled(false));
-        joinConfig.setTcpIpConfig(new TcpIpConfig().setEnabled(true).setMembers(List.of("127.0.0.1")));
-        networkConfig.setJoin(joinConfig);
-        cfg.setNetworkConfig(networkConfig);
-        hazelcastInstance = Hazelcast.newHazelcastInstance(cfg);
-        HazelcastHelper.imdgSystem_setStorageState(true, hazelcastInstance);
-        return new HazelcastService(taskExecutorHazelcastClientInitializer, taskExecutorIdGeneratorAwaiter, params);
-    }
-
-    @Bean(name = "taskExecutorHazelcastClientInitializer")
-    public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer() {
-        return createThreadPoolTaskExecutor(1, true);
-    }
-
-    @Bean(name = "taskExecutorIdGeneratorAwaiter")
-    public ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter() {
-        return createThreadPoolTaskExecutor(1, false);
-    }
-
-    @Bean(name = "hazelcastClientParams")
-    public HazelcastClientParams getHazelcastClientParams() {
-        HazelcastClientParams params = new HazelcastClientParams();
-        params.setLogin("dev");
-        params.setPassword("dev-pass");
-        params.setClusterMembers("127.0.0.1");
-        params.setInstanceName("hzTestClient" + new Random().nextInt());
-        params.setNearCacheConfig(new NearCacheConfig());
-        return params;
-    }
-}

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/IOperatorTest.java

@@ -9,18 +9,18 @@ import ru.spcex.clearing.backendapi.meta.MetaServer;
 import ru.spcex.clearing.backendapi.service.impl.OperatorImpl;
 import ru.spcex.clearing.backendapi.service.validation.ActionMetaValidation;
 import ru.spcex.clearing.backendapi.service.validation.ActionValidationProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 
 @Configuration
 public class IOperatorTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
+    private ImdgProvider hazelcastServiceTest;
 
     @Autowired
     @Bean("iOperatorTest")
-    public OperatorImpl createIOperator(Producer<String, Object> kafka,
+    public OperatorImpl createIOperator(@Qualifier("mockProducer") Producer<String, Object> kafka,
                                         ActionMetaValidation actionMetaValidation, ActionValidationProvider validationProvider) {
         return new OperatorImpl(kafka, hazelcastServiceTest, actionMetaValidation, validationProvider);
     }

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/KafkaTestConfig.java

@@ -1,18 +0,0 @@
-package ru.spcex.clearing.backendapi.controller.config;
-
-import org.apache.kafka.clients.producer.MockProducer;
-import org.apache.kafka.clients.producer.Producer;
-import org.apache.kafka.common.serialization.StringSerializer;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import ru.spcex.clearing.platform.messaging.serialization.JsonSerializer;
-
-@Configuration
-public class KafkaTestConfig {
-
-    @Bean
-    public Producer<String, Object> createProducer() {
-        return new MockProducer<>(true, new StringSerializer(), new JsonSerializer());
-    }
-
-}

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/TestConfig.java

@@ -0,0 +1,12 @@
+package ru.spcex.clearing.backendapi.controller.config;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.FilterType;
+import ru.spcex.clearing.backendapi.controller.queue.QueueExceptionHandler;
+
+@Configuration
+@ComponentScan(basePackages = {"ru.spcex.clearing.backendapi.controller.queue"},
+        excludeFilters = @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE, value = QueueExceptionHandler.class))
+public class TestConfig {
+}

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/AbstractControllerTest.java

@@ -1,6 +1,6 @@
 package ru.spcex.clearing.backendapi.controller.queue;
 
-import org.apache.kafka.clients.producer.MockProducer;
+import org.apache.kafka.clients.producer.Producer;
 import org.apache.kafka.clients.producer.ProducerRecord;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.keycloak.KeycloakPrincipal;
@@ -9,11 +9,9 @@ import org.keycloak.adapters.spi.KeycloakAccount;
 import org.keycloak.adapters.springsecurity.token.KeycloakAuthenticationToken;
 import org.keycloak.representations.AccessToken;
 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.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.http.MediaType;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.test.context.ContextConfiguration;
@@ -28,23 +26,6 @@ import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.filter.CharacterEncodingFilter;
 import ru.clearing.classes.statics.data.user.User;
 import ru.spcex.clearing.backendapi.controller.config.*;
-import ru.spcex.clearing.backendapi.controller.queue.account.*;
-import ru.spcex.clearing.backendapi.controller.queue.company.*;
-import ru.spcex.clearing.backendapi.controller.queue.execution.ExecutionDepositController;
-import ru.spcex.clearing.backendapi.controller.queue.execution.ExecutionFondController;
-import ru.spcex.clearing.backendapi.controller.queue.journal.InDocumentJournalController;
-import ru.spcex.clearing.backendapi.controller.queue.journal.ManagementJournalController;
-import ru.spcex.clearing.backendapi.controller.queue.journal.OutDocumentJournalController;
-import ru.spcex.clearing.backendapi.controller.queue.misc.*;
-import ru.spcex.clearing.backendapi.controller.queue.payment.PaymentInstructionController;
-import ru.spcex.clearing.backendapi.controller.queue.register.*;
-import ru.spcex.clearing.backendapi.controller.queue.registry.TradingClearingRegistryController;
-import ru.spcex.clearing.backendapi.controller.queue.scheduler.*;
-import ru.spcex.clearing.backendapi.controller.queue.securities.*;
-import ru.spcex.clearing.backendapi.controller.queue.user.UserController;
-import ru.spcex.clearing.backendapi.controller.queue.user.UserRoleSessionController;
-import ru.spcex.clearing.backendapi.controller.queue.utilities.StatementController;
-import ru.spcex.clearing.backendapi.controller.queue.utilities.UserSettingsController;
 import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
 import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.controller.response.cud.CudResponseTest;
@@ -55,11 +36,12 @@ import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
 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.test.TestUtils;
+import ru.spcex.clearing.test.config.ImdgTestConfig;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.clearing.test.json.MatcherFactoryWithJson;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
+import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
 import javax.annotation.PostConstruct;
@@ -71,92 +53,29 @@ import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static ru.spcex.clearing.test.TestUtils.clearImdg;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.getCaptor;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 import static ru.spcex.clearing.test.json.JsonUtil.readValue;
 import static ru.spcex.clearing.test.json.JsonUtil.writeValue;
 import static ru.spcex.clearing.test.json.MatcherFactoryWithJson.usingIgnoringFieldsComparatorForClass;
 
 
 @ContextConfiguration(classes = {
-        //account
+        TestConfig.class,
-        AccountController.class,
-        BankAccountController.class,
-        ClearingAccountController.class,
-        DepoAccountController.class,
-        //account misc
-        ClientCodeController.class,
-        //company
-        CompanyRoleSetController.class,
-        CompanyController.class,
-        ClearingMemberCategoryController.class,
-        CompanyInfoController.class,
-        CompanySymbolController.class,
-        ContactController.class,
-        ProfileDocumentController.class,
-        RelationController.class,
-        //execution
-        ExecutionDepositController.class,
-        ExecutionFondController.class,
-        //journal
-        InDocumentJournalController.class,
-        ManagementJournalController.class,
-        OutDocumentJournalController.class,
-        //liabilities
-        //misc
-        CurrencyController.class,
-        ErrorTextController.class,
-        ListingController.class,
-        MarketController.class,
-        NotificationController.class,
-        SessionController.class,
-        //payment
-        PaymentInstructionController.class,
-        //register
-        AdmittedLiabilitiesRegisterController.class,
-        CoveredLiabilitiesRegisterController.class,
-        DepoBalanceRegisterController.class,
-        DepoPaymentInstructionRegisterController.class,
-        ExcludeLiabilitiesRegisterController.class,
-        ExecutionRegisterController.class,
-        LiabilitiesRegisterController.class,
-        MoneyBalanceRegisterController.class,
-        ContractRegisterController.class,
-        ReportRegisterController.class,
-        //registry
-        RegistryController.class,
-        TradingClearingRegistryController.class,
-        //scheduler
-        ClearingCalendarController.class,
-        LauncherController.class,
-        PlannerAllTodayController.class,
-        PlannerController.class,
-        PlannerTemplateController.class,
-        //securities
-        MoneyMarketSecurityController.class,
-        CouponPeriodController.class,
-        EquitySecurityController.class,
-        FixedIncomeCashFlowController.class,
-        FixedIncomeSecurityController.class,
-        InformationAccountController.class,
-        SecurityController.class,
-        //user
-        UserController.class,
-        UserRoleSessionController.class,
-        //utilities
-        StatementController.class,
-        UserSettingsController.class,
-        //******* common configs *******
         WebTestConfig.class,
         IOperatorTest.class,
-        HazelcastServiceTestConfiguration.class,
+        ImdgTestConfig.class,
+        KafkaTestConfig.class,
         StateLoaderImplTestConfig.class,
         WebSecurityTestConfigurer.class,
         MessagesTestConfig.class,
         Jackson2HttpConverterTestConfig.class})
-//todo может быть указать пакедж а не список контроллеров
 @ExtendWith(SpringExtension.class)
 @WebMvcTest
 //@TestPropertySource(properties = "spring.config.location=D:/repo/mfd/clearing/clearing-parent/backend-api/src/main/resources/")
@@ -181,15 +100,16 @@ public abstract class AbstractControllerTest {
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    protected HazelcastService hazelcastServiceTest;
+    protected ImdgProvider hazelcastServiceTest;
 
     @Autowired
     @Qualifier("responseFactoryTest")
     protected GetResponseFactory responseFactory;
-    @Captor
+
-    protected ArgumentCaptor<ProducerRecord> producerRecord;
+    @Autowired
-    @MockBean
+    @Qualifier("mockProducer")
-    protected MockProducer<String, Object> producer;
+    protected Producer<String, Object> producer;
+
     protected Imdg<User> userImdg;
     @Autowired
     private WebApplicationContext webApplicationContext;
@@ -202,8 +122,6 @@ public abstract class AbstractControllerTest {
                 .addFilter(CHARACTER_ENCODING_FILTER)
 //                .apply(springSecurity())
                 .build();
-        TestUtils.FutureRecordMetadata future = spy(TestUtils.FutureRecordMetadata.class);
-        doReturn(future).when(producer).send(producerRecord.capture());
         userImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_User, User.class);
     }
 
@@ -215,6 +133,7 @@ public abstract class AbstractControllerTest {
         BaseRequest<Object> predictableBaseRequest = new BaseRequest<>();
         predictableBaseRequest.setActionType(action.getActionType());
         predictableBaseRequest.setRequestPayload(action.toRequest());
+        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(producer);
         assertEquals(topic, producerRecord.getValue().topic());
         BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
         predictableBaseRequest.setId(baseRequestResult.getId());
@@ -222,6 +141,7 @@ public abstract class AbstractControllerTest {
     }
 
     protected void checkAddingByRestApi(String REST_URL, IAction action) throws Exception {
+        setMockFuture(producer);
         CudResponse expected = new CudResponse();
         expected.setCode(0L);
         expected.setMessage("success");
@@ -241,6 +161,7 @@ public abstract class AbstractControllerTest {
     }
 
     protected void checkUpdatingByRestApi(String REST_URL, IAction action, Long existsId) throws Exception {
+        setMockFuture(producer);
         CudResponse expected = new CudResponse();
         expected.setCode(0L);
         expected.setMessage("success");
@@ -269,6 +190,7 @@ public abstract class AbstractControllerTest {
     }
 
     protected void checkUpdatingWithoutIdByRestApi(String REST_URL, IAction action) throws Exception {
+        setMockFuture(producer);
         CudResponse expected = new CudResponse();
         expected.setCode(0L);
         expected.setMessage("success");
@@ -290,6 +212,7 @@ public abstract class AbstractControllerTest {
     }
 
     protected void checkDeletingByRestApi(String REST_URL, Long existsId) throws Exception {
+        setMockFuture(producer);
         CudResponse expected = new CudResponse();
         expected.setCode(0L);
         expected.setMessage("success");
@@ -311,6 +234,7 @@ public abstract class AbstractControllerTest {
     }
 
     protected <T extends SpcexObjectBase> void checkDeletingWithIdVolidationByRestApi(String imdgDistributedNames, T existsObj, String REST_URL, Long existsId) throws Exception {
+        setMockFuture(producer);
         Class<T> clazz = (Class<T>) existsObj.getClass();
         Imdg<T> inDocumentJournalImdg = hazelcastServiceTest.getImdg(imdgDistributedNames, clazz);
         inDocumentJournalImdg.insert(existsObj);
@@ -318,9 +242,10 @@ public abstract class AbstractControllerTest {
     }
 
     protected <T extends SpcexObjectBase> void checkGettingAllFromRestApi(String imdgDistributedNames, T existsObj, String restUrl) throws Exception {
+        setMockFuture(producer);
         Class<T> clazz = (Class<T>) existsObj.getClass();
         Imdg<T> testingImdg = hazelcastServiceTest.getImdg(imdgDistributedNames, clazz);
-        // ((ImdgHazelcast<T>)testingImdg).clear(); // предварительная очистка
+        clearImdg(testingImdg);
         testingImdg.insert(existsObj);
 
         Collection<T> values = testingImdg.getAllValues();

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/account/BankAccountControllerTest.java

@@ -9,7 +9,6 @@ import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountNewAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountUpdateAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
-import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetByIdResponse;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.ActionValidationException;
@@ -79,15 +78,10 @@ class BankAccountControllerTest extends AbstractControllerTest {
      */
     @Test
     void addWithException() {
-        assertThrowsFor(getBankAccountNewAction(0, "", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
+        assertThrowsFor(getBankAccountNewAction(0, null, "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
+        assertThrowsFor(getBankAccountNewAction(0, "044525776", null, "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "", "correspondent", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
+        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", null, "destination", "3664011397", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
+        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", null));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "", "destination", "3664011397", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "", "3664011397", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "", "01", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "", "11111222223333344444"));
-        assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", ""));
     }
 
     /**

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/account/ClientCodeControllerTest.java

@@ -13,6 +13,7 @@ import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.ActionValidationException;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.ClientCodeNewRequest;
 
 import java.time.Instant;
 
@@ -60,7 +61,6 @@ class ClientCodeControllerTest extends AbstractControllerTest {
      */
     @Test
     void addWithException() {
-        assertThrowsFor(getClientCodeNewAction(0, "", "ACTV", 1000L, 1010L, 1020L, 1030L));
         assertThrowsFor(getClientCodeNewAction(0, null, "ACTV", 1000L, 1010L, 1020L, 1030L));
         assertThrowsFor(getClientCodeNewAction(0, "044525776", "ACTV", null, 1010L, 1020L, 1030L));
     }

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/misc/NotificationControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.misc;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -8,8 +7,8 @@ import ru.clearing.classes.statics.data.misc.Notification;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
 
-import java.time.Instant;
 import java.time.LocalDate;
 import java.util.Collection;
 import java.util.Map;
@@ -40,10 +39,10 @@ class NotificationControllerTest extends AbstractControllerTest {
         profileDocument.setNotificationStatus("Status");
         profileDocument.setId(currentId.get());
 
-        IMap<Long, Notification> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_Notification);
+        Imdg<Notification> iMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Notification, Notification.class);
-        iMap.put(profileDocument.getId(), profileDocument);
+        iMap.insert(profileDocument);
 
-        Collection<Notification> values = iMap.values();
+        Collection<Notification> values = iMap.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/misc/SessionControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.misc;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -8,6 +7,7 @@ import ru.clearing.classes.statics.data.misc.Session;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
 
 import java.time.LocalDate;
 import java.util.Collection;
@@ -35,10 +35,10 @@ class SessionControllerTest extends AbstractControllerTest {
         session.setSessionStatus("Ok");
         session.setId(currentId.get());
 
-        IMap<Long, Session> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_Session);
+        Imdg<Session> sessionImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Session, Session.class);
-        iMap.put(session.getId(), session);
+        sessionImdg.insert(session);
 
-        Collection<Session> values = iMap.values();
+        Collection<Session> values = sessionImdg.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.payment;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -10,6 +9,7 @@ import ru.spcex.clearing.backendapi.controller.request.cud.payment.PIClearingOut
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.platform.imdg.api.Imdg;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -65,10 +65,10 @@ class PaymentInstructionControllerTest extends AbstractControllerTest {
         paymentInstruction.setSessionId(555L);
         paymentInstruction.setId(currentId.get());
 
-        IMap<Long, PaymentInstruction> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_PaymentInstruction);
+        Imdg<PaymentInstruction> paymentInstructionImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
-        iMap.put(paymentInstruction.getId(), paymentInstruction);
+        paymentInstructionImdg.insert(paymentInstruction);
 
-        Collection<PaymentInstruction> values = iMap.values();
+        Collection<PaymentInstruction> values = paymentInstructionImdg.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.scheduler;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MvcResult;
@@ -29,6 +28,7 @@ import java.util.Map;
 import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 import static ru.spcex.clearing.test.json.JsonUtil.readValue;
 import static ru.spcex.clearing.test.json.JsonUtil.writeValue;
 
@@ -52,10 +52,10 @@ class LauncherControllerTest extends AbstractControllerTest {
         taskRunner.setSenderId(10210L);
         taskRunner.setId(currentId.get());
 
-        IMap<Long, Launcher> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_Launcher);
+        Imdg<Launcher> iMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Launcher, Launcher.class);
-        iMap.put(taskRunner.getId(), taskRunner);
+        iMap.insert(taskRunner);
 
-        Collection<Launcher> values = iMap.values();
+        Collection<Launcher> values = iMap.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);
@@ -76,6 +76,7 @@ class LauncherControllerTest extends AbstractControllerTest {
     @Test
     void add() throws Exception {
         //ARRANGE
+        setMockFuture(producer);
         TaskDictionary taskDictionary = new TaskDictionary();
         taskDictionary.setCode(CODE);
         taskDictionary.setId(ID);
@@ -135,6 +136,7 @@ class LauncherControllerTest extends AbstractControllerTest {
     @Test
     void addSpecific() throws Exception {
         //ARRANGE
+        setMockFuture(producer);
         LauncherNew launcherCommand = new LauncherNew();
         launcherCommand.setTask(START_OF_CLEARING);
         launcherCommand.setUserId(ID);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlannerAllTodayControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.scheduler;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -8,6 +7,7 @@ import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
 
 import java.time.LocalDate;
 import java.time.LocalTime;
@@ -42,10 +42,10 @@ class PlannerAllTodayControllerTest extends AbstractControllerTest {
         schedulerAllToday.setParentId(1010L);
         schedulerAllToday.setId(currentId.get());
 
-        IMap<Long, PlannerAllToday> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_PlannerAllToday);
+        Imdg<PlannerAllToday> plannerAllTodayImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class);
-        iMap.put(schedulerAllToday.getId(), schedulerAllToday);
+        plannerAllTodayImdg.insert(schedulerAllToday);
 
-        Collection<PlannerAllToday> values = iMap.values();
+        Collection<PlannerAllToday> values = plannerAllTodayImdg.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/PlannerControllerTest.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.backendapi.controller.queue.scheduler;
 
-import com.hazelcast.core.IMap;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -8,6 +7,7 @@ import ru.clearing.classes.statics.data.scheduler.Planner;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
 
 import java.time.LocalDate;
 import java.time.LocalTime;
@@ -40,10 +40,10 @@ class PlannerControllerTest extends AbstractControllerTest {
         scheduler.setSecurityId(10210L);
         scheduler.setId(currentId.get());
 
-        IMap<Long, Planner> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_Planner);
+        Imdg<Planner> plannerImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
-        iMap.put(scheduler.getId(), scheduler);
+        plannerImdg.insert(scheduler);
 
-        Collection<Planner> values = iMap.values();
+        Collection<Planner> values = plannerImdg.getAllValues();
         Collection<Map<String, Object>> all = responseFactory.responseFromObjectCollection(values);
         CommonGetAllResponse expected = new CommonGetAllResponse();
         expected.fromEntity(all);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityControllerTest.java

@@ -1,7 +1,9 @@
 package ru.spcex.clearing.backendapi.controller.queue.securities;
 
 import org.junit.jupiter.api.Test;
-import ru.clearing.classes.statics.data.security.Security;
+import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
+import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractControllerTest;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 
@@ -17,7 +19,7 @@ class SecurityControllerTest extends AbstractControllerTest {
     @Test
     void getAll() throws Exception {
         //ARRANGE
-        Security security = new Security();
+        MoneyMarketSecurity security = new MoneyMarketSecurity();
         security.setId(currentId.get());
         security.setInstrumentType("name");
         security.setIssuerId(currentId.get());
@@ -27,7 +29,9 @@ class SecurityControllerTest extends AbstractControllerTest {
         security.setFullNameEng("name");
         security.setSecuritySymbol("name");
         security.setWorkflowStatus("name");
-        clearAll(IMDGDistributedNames.Map_MoneyMarketSecurity, Security.class);
+        clearAll(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        clearAll(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
+        clearAll(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
 
         //ACT and ASSERT
         checkGettingAllFromRestApi(IMDGDistributedNames.Map_MoneyMarketSecurity, security, REST_URL);

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/queue/utilities/UserSettingsControllerTest.java

@@ -19,9 +19,13 @@ class UserSettingsControllerTest extends AbstractControllerTest {
     @Test
     void getAll() throws Exception {
         //ARRANGE
+        Long id = currentId.getAndIncrement();
+        String identifier = "usersIdentifier";
+
+        setUserNameInMockSecurityContextAndMapUser(identifier, id);
         UserSettings userSettings = new UserSettings();
-        userSettings.setId(currentId.get());
+        userSettings.setId(id);
-        userSettings.setUserId(currentId.get()); // отдаются по userId CLS-64, todo в тесте null
+        userSettings.setUserId(id); // отдаются по userId CLS-64, todo в тесте null
         userSettings.setJson("json");
         userSettings.setVersion("version");
 

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/meta/GetResponseFactoryTest.java

@@ -7,8 +7,10 @@ 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.profile.CompanyInfo;
 
 import java.util.*;
+import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
 @ExtendWith(SpringExtension.class)
@@ -16,6 +18,9 @@ import java.util.stream.Collectors;
 public class GetResponseFactoryTest {
     private final MetaServer meta;
 
+    private final Map<Class, List<String>> nonCheckerFields = Map.of(
+            CompanyInfo.class, List.of("shortName", "fullName", "tradingCode", "clearingCode", "registrationCode", "workflowStatus")
+    );
     @Autowired
     public GetResponseFactoryTest(@Qualifier("metaJsonTest") MetaServer meta) {
         this.meta = meta;
@@ -33,6 +38,8 @@ public class GetResponseFactoryTest {
             if (className == null) {
                 error.computeIfAbsent(ent.getKey(), v -> new ArrayList<>()).add(ent.getKey() + " no class property");
                 continue;
+            } else if (ent.getKey().equals("dbVersion")) {
+                continue;
             }
             try {
                 classByName = Class.forName(className);
@@ -42,8 +49,16 @@ public class GetResponseFactoryTest {
             }
             Object object = classByName.newInstance();
             ObjectExtracted objectExtracted = meta.getObjectsExtractedByClazz().get(className);
+
+            BiFunction<Class, FieldExtracted, Boolean> fieldNonChecked = (clazz, fieldExtracted) -> {
+                List<String> fields = nonCheckerFields.get(clazz);
+                if (fields == null) return false;
+                return fields.contains(fieldExtracted.getMemberName());
+            };
+
             for (FieldExtracted fieldExtracted : objectExtracted.getFields()) {
                 try {
+                    if(fieldNonChecked.apply(classByName, fieldExtracted)) continue;
                     fieldExtracted.extractValue(object);
                 } catch (Exception e) {
                     error.computeIfAbsent(ent.getKey(), v -> new ArrayList<>()).add(

clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/service/validation/ActionMetaValidationTest.java

@@ -8,15 +8,12 @@ import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.spcex.clearing.backendapi.controller.request.cud.account.BankAccountNewAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.common.CommonDeleteAction;
-import ru.spcex.clearing.backendapi.controller.request.cud.company.ListingNewAction;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.meta.GetResponseFactoryTestConfiguration;
 import ru.spcex.clearing.backendapi.meta.MetaServer;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
-import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.validation.IValidator;
 
-import java.util.ArrayList;
 import java.util.Collection;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -33,12 +30,6 @@ class ActionMetaValidationTest {
         ActionMetaValidation metaValidator = new ActionMetaValidation(meta);
         metaValidator.afterPropertiesSet();
 
-        {
-            IAction<?> action = new ListingNewAction();
-            assertTrue(action.validate().isEmpty());
-            IValidator v = metaValidator.getValidator(null, action);
-            assertNull(v, "Пока не прописан в мете");
-        }
         {
             IAction<?> action = new CommonDeleteAction();
             assertFalse(action.validate().isEmpty()); // стандартный валидатор - требуется id

clearing-parent/balance-service/pom.xml

@@ -45,6 +45,11 @@
             <artifactId>platform-enum</artifactId>
         </dependency>
         <!-- TEST -->
+        <dependency>
+            <groupId>ru.spcex.clearing</groupId>
+            <artifactId>test-clearing</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/config/ImdgTestConfig.java

@@ -1,75 +0,0 @@
-package ru.spcex.clearing.balance.config;
-
-import com.hazelcast.config.*;
-import com.hazelcast.core.Hazelcast;
-import com.hazelcast.core.HazelcastInstance;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
-import ru.spcex.platform.imdg.iml.hazelcast.util.HazelcastHelper;
-
-import java.util.List;
-import java.util.Random;
-
-@Configuration
-public class ImdgTestConfig {
-
-    private HazelcastInstance hazelcastInstance;
-
-    private static ThreadPoolTaskExecutor createThreadPoolTestTaskExecutor(int maxPoolSz, boolean waitForCompletion) {
-        ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
-        if (maxPoolSz > 2) {
-            pool.setKeepAliveSeconds(60);
-            pool.setAllowCoreThreadTimeOut(true);
-        }
-        pool.setCorePoolSize(maxPoolSz);
-        pool.setWaitForTasksToCompleteOnShutdown(waitForCompletion);
-        return pool;
-    }
-
-    @Bean(name = "taskExecutorHazelcastTestClientInitializer")
-    public ThreadPoolTaskExecutor taskExecutorHazelcastTestClientInitializer() {
-        return createThreadPoolTestTaskExecutor(1, true);
-    }
-
-    @Bean(name = "taskExecutorTestIdGeneratorAwaiter")
-    public ThreadPoolTaskExecutor taskExecutorTestIdGeneratorAwaiter() {
-        return createThreadPoolTestTaskExecutor(1, false);
-    }
-
-    @Autowired
-    @Bean(name = "hazelcastServiceTest")
-    public ImdgProvider imdgTestProvider(
-            @Qualifier("taskExecutorHazelcastTestClientInitializer") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer,
-            @Qualifier("taskExecutorTestIdGeneratorAwaiter") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter,
-            HazelcastClientParams params) {
-        Config cfg = new Config();
-        cfg.setInstanceName("localhost");
-
-        NetworkConfig networkConfig = new NetworkConfig();
-        JoinConfig joinConfig = new JoinConfig();
-        joinConfig.setMulticastConfig(new MulticastConfig().setEnabled(false));
-        joinConfig.setTcpIpConfig(new TcpIpConfig().setEnabled(true).setMembers(List.of("127.0.0.1")));
-        networkConfig.setJoin(joinConfig);
-        cfg.setNetworkConfig(networkConfig);
-        hazelcastInstance = Hazelcast.getOrCreateHazelcastInstance(cfg);
-        HazelcastHelper.imdgSystem_setStorageState(true, hazelcastInstance);
-        return new HazelcastService(taskExecutorHazelcastClientInitializer, taskExecutorIdGeneratorAwaiter, params);
-    }
-
-    @Bean(name = "hazelcastClientParams")
-    public HazelcastClientParams getHazelcastClientParams() {
-        HazelcastClientParams params = new HazelcastClientParams();
-        params.setLogin("dev");
-        params.setPassword("dev-pass");
-        params.setClusterMembers("127.0.0.1");
-        params.setInstanceName("hzTestClient" + new Random().nextInt());
-        params.setNearCacheConfig(new NearCacheConfig());
-        return params;
-    }
-}

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/config/KafkaTestConfig.java

@@ -1,42 +0,0 @@
-package ru.spcex.clearing.balance.config;
-
-import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.consumer.OffsetResetStrategy;
-import org.apache.kafka.clients.producer.Producer;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.config.ConfigurableBeanFactory;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Scope;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.service.RequestInfo;
-import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
-import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.api.ImdgId;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-
-@Configuration
-public class KafkaTestConfig {
-
-    @Autowired
-    @Bean
-    public KafkaSender kafkaSender(Producer<String, Object> kafkaProducer,
-                                   ImdgProvider imdgProvider) {
-        ImdgId imdgIdGenerator = imdgProvider.getImdgIdGenerator();
-        return KafkaSender
-                .setup()
-                .producer(kafkaProducer)
-                .idGenerator(imdgIdGenerator::nextId)
-                .imdgProvider(s -> {
-                    Imdg<RequestInfo> imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_RequestInfo, RequestInfo.class);
-                    return imdg::insert;
-                })
-                .build();
-    }
-
-    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-    @Bean
-    public MockConsumer<String, Object> createTestConsumer() {
-        return new MockConsumer<>(OffsetResetStrategy.EARLIEST);
-    }
-}

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AbstractServiceTest.java

@@ -12,10 +12,14 @@ import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.sdf.*;
 import ru.clearing.classes.statics.data.statement.Statement;
-import ru.spcex.clearing.balance.config.*;
+import ru.spcex.clearing.balance.config.MessagesConfig;
+import ru.spcex.clearing.balance.config.SdfExecutorsConfig;
+import ru.spcex.clearing.balance.config.ValidationConfig;
 import ru.spcex.clearing.balance.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.service.RequestInfo;
+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.ImdgProvider;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf08ServiceTest.java

@@ -3,13 +3,12 @@ package ru.spcex.clearing.balance.service;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 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.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.kafka.core.KafkaTemplate;
 import ru.clearing.classes.statics.data.sdf.SDf08;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
@@ -25,6 +24,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
 import static ru.spcex.clearing.balance.utils.MockKafkaUtils.addRecordToKafka;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.getCaptor;
 
 class Sdf08ServiceTest extends AbstractServiceTest {
     //    private static final MatcherFactory.Matcher<SDf08> SDF_08_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
@@ -32,11 +32,12 @@ class Sdf08ServiceTest extends AbstractServiceTest {
     private static final int PARTITION = 1;
     @Autowired
     Sdf08Service sdf08Service;
-    @Captor
+
-    ArgumentCaptor<ProducerRecord> producerRecord;
     private MockConsumer<String, Object> mockConsumer;
-    @SpyBean
+
-    private MockProducer<String, Object> producer;
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    private KafkaTemplate<String, Object> producer;
 
     @PostConstruct
     void init() {
@@ -66,6 +67,7 @@ class Sdf08ServiceTest extends AbstractServiceTest {
         addRecordToKafka(mockConsumer, TOPIC, PARTITION, 0, jsonBaseNewRequest);
 
         //waiting for kafka producer send message (finale event)
+        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(producer);
         verify(producer, timeout(30_000L).times(1))
                 .send(producerRecord.capture());
 

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf16ExecutorTest.java

@@ -1,12 +1,11 @@
 package ru.spcex.clearing.balance.service;
 
-import org.apache.kafka.clients.producer.MockProducer;
 import org.apache.kafka.clients.producer.ProducerRecord;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.kafka.core.KafkaTemplate;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.AccountBalance;
 import ru.clearing.classes.statics.data.company.Company;
@@ -16,7 +15,6 @@ import ru.clearing.classes.statics.data.sdf.SDf17;
 import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.balance.errors.BalanceError;
 import ru.spcex.clearing.balance.utils.MatcherFactory;
-import ru.spcex.clearing.balance.utils.MockKafkaUtils;
 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.sdf01.AccountSdfRequestPart;
@@ -34,9 +32,8 @@ import java.util.Collections;
 import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.spy;
 import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.getCaptor;
 
 class Sdf16ExecutorTest extends AbstractServiceTest {
     private static final MatcherFactory.Matcher<SDf17> SDF_17_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
@@ -44,13 +41,14 @@ class Sdf16ExecutorTest extends AbstractServiceTest {
     private final String acc = "323456789";
     @Autowired
     Sdf16Executor sdf16Executor;
-    @Captor
+
-    ArgumentCaptor<ProducerRecord> producerRecord;
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    private KafkaTemplate<String, Object> producer;
+
     private SDf16 sdf16;
     private StatementRequest statementRequest;
 
-    @MockBean
-    private MockProducer<String, Object> producer;
 
     @PostConstruct
     void init() {
@@ -94,9 +92,9 @@ class Sdf16ExecutorTest extends AbstractServiceTest {
         SDf17 predictableSdf17 = getTestSdf17(currentId.getAndIncrement(), sdf16, ID);
         predictableStatement.setOutSDfId(predictableSdf17.getId());
         AccountResult predictableNewResult = getTestAccountResult(currentId.getAndIncrement(), account, company);
+        predictableNewResult.getAccount().setCurrencyCode(null);
 
-        MockKafkaUtils.FutureRecordMetadata future = spy(MockKafkaUtils.FutureRecordMetadata.class);
+        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(producer);
-        doReturn(future).when(producer).send(producerRecord.capture());
         Result result = sdf16Executor.execute(Collections.singletonList(sdf16), statementRequest);
 
         BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();

clearing-parent/clearing-service/pom.xml

@@ -73,6 +73,11 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>ru.spcex.clearing</groupId>
+            <artifactId>test-clearing</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <resources>

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/config/ConfigTest.java

@@ -0,0 +1,91 @@
+package ru.spcex.clearing.config;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.consumer.OffsetResetStrategy;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.*;
+import org.springframework.kafka.core.KafkaTemplate;
+import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
+import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
+import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+import ru.spcex.clearing.config.element.ClearingServiceSettings;
+import ru.spcex.clearing.error.ClearingError;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.clearing.service.builder.PaymentInstructionCreator;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
+import ru.spcex.clearing.util.services.IMDGMessageResolver;
+import ru.spcex.clearing.util.services.RequestHelper;
+import ru.spcex.platform.enumeration.ClearingCategory;
+import ru.spcex.platform.imdg.api.ImdgId;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Supplier;
+
+@Configuration
+@ComponentScan(basePackages = {"ru.spcex.clearing.service", "ru.spcex.clearing.session.stage",
+        "ru.spcex.clearing.notification", "ru.spcex.clearing.statement"})
+@Import(KafkaTestConfig.class)
+public class ConfigTest {
+
+    @Bean
+    public RequestHelper reqHelper(IMessageResolver msgRslv) {
+        return new RequestHelper(msgRslv, ClearingError.GeneralError);
+    }
+
+    @Bean
+    public IMessageResolver messageResolver(ImdgProvider imdgProvider) {
+        return new IMDGMessageResolver(imdgProvider);
+    }
+
+    @Bean
+    public ClearingServiceSettings clearingServiceSettings() {
+        return new ClearingServiceSettings();
+    }
+
+    @Bean(name = "paymentInstructionCreatorTest")
+    public PaymentInstructionCreatorTest createPaymentInstructionCreator(@Qualifier("hazelcastServiceTest") ImdgProvider hazelcastServiceTest) {
+        return new PaymentInstructionCreatorTest(hazelcastServiceTest);
+    }
+
+    public static class PaymentInstructionCreatorTest extends PaymentInstructionCreator {
+        public PaymentInstructionCreatorTest(ImdgProvider imdgProvider) {
+            super(imdgProvider);
+        }
+
+        public PaymentInstruction createPaymentInstruction(ExecutionDeposit executionDeposit, LiabilitiesClaimsAssets liabilitiesClaimsAssets,
+                                                           Collection<ClearingCategory> clearingCategory) {
+            List<PaymentInstruction> list = super.createPaymentInstructions(executionDeposit, liabilitiesClaimsAssets, clearingCategory);
+            return list.stream().findFirst().orElseGet(PaymentInstruction::new);
+        }
+    }
+
+
+    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+    @Bean("kafkaConsumer")
+    public MockConsumer<String, Object> createMockConsumer() {
+        return new MockConsumer<>(OffsetResetStrategy.EARLIEST);
+    }
+
+    @Bean("kafkaConsumerGateway")
+    public Supplier<Consumer<String, Object>> getwaySessionConsumer() {
+        return () -> new MockConsumer<>(OffsetResetStrategy.EARLIEST);
+    }
+
+    @Autowired
+    @Bean("kafkaSenderWithoutRequestInfo")
+    public KafkaSender kafkaSenderWithoutRequestInfo(KafkaTemplate<String, Object> kafkaTemplate, ImdgProvider imdgProvider) {
+        ImdgId imdgIdGenerator = imdgProvider.getImdgIdGenerator();
+        return KafkaSender
+                .setup()
+                .setKafkaTemplate(kafkaTemplate)
+                .idGenerator(imdgIdGenerator::nextId)
+                .saveRequestInfo(false)
+                .build();
+    }
+}

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/config/HazelcastServiceTestConfiguration.java

@@ -1,71 +0,0 @@
-package ru.spcex.clearing.config;
-
-import com.hazelcast.config.*;
-import com.hazelcast.core.Hazelcast;
-import com.hazelcast.core.HazelcastInstance;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
-import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
-import ru.spcex.platform.imdg.iml.hazelcast.util.HazelcastHelper;
-
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.atomic.AtomicLong;
-
-@Configuration
-public class HazelcastServiceTestConfiguration {
-
-    public static final AtomicLong currentID = new AtomicLong(0L);
-    private HazelcastInstance hazelcastInstance;
-
-    private static ThreadPoolTaskExecutor createThreadPoolTaskExecutor(int maxPoolSz, boolean waitForCompletion) {
-        ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
-        if (maxPoolSz > 2) {
-            pool.setKeepAliveSeconds(60);
-            pool.setAllowCoreThreadTimeOut(true);
-        }
-        pool.setCorePoolSize(maxPoolSz);
-        pool.setWaitForTasksToCompleteOnShutdown(waitForCompletion);
-        return pool;
-    }
-
-    @Bean(name = "hazelcastServiceTest")
-    public HazelcastService hazelcastService(@Qualifier("taskExecutorHazelcastClientInitializer") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer, @Qualifier("taskExecutorIdGeneratorAwaiter") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter, HazelcastClientParams params) {
-        Config cfg = new Config();
-        cfg.setInstanceName("localhost");
-
-        NetworkConfig networkConfig = new NetworkConfig();
-        JoinConfig joinConfig = new JoinConfig();
-        joinConfig.setMulticastConfig(new MulticastConfig().setEnabled(false));
-        joinConfig.setTcpIpConfig(new TcpIpConfig().setEnabled(true).setMembers(List.of("127.0.0.1")));
-        networkConfig.setJoin(joinConfig);
-        cfg.setNetworkConfig(networkConfig);
-        hazelcastInstance = Hazelcast.getOrCreateHazelcastInstance(cfg);
-        HazelcastHelper.imdgSystem_setStorageState(true, hazelcastInstance);
-        return new HazelcastService(taskExecutorHazelcastClientInitializer, taskExecutorIdGeneratorAwaiter, params);
-    }
-
-    @Bean(name = "taskExecutorHazelcastClientInitializer")
-    public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer() {
-        return createThreadPoolTaskExecutor(1, true);
-    }
-
-    @Bean(name = "taskExecutorIdGeneratorAwaiter")
-    public ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter() {
-        return createThreadPoolTaskExecutor(1, false);
-    }
-
-    @Bean(name = "hazelcastClientParams")
-    public HazelcastClientParams getHazelcastClientParams() {
-        HazelcastClientParams params = new HazelcastClientParams();
-        params.setLogin("dev");
-        params.setPassword("dev-pass");
-        params.setClusterMembers("127.0.0.1");
-        params.setInstanceName("hzTestClient" + new Random().nextInt());
-        params.setNearCacheConfig(new NearCacheConfig());
-        return params;
-    }
-}

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/config/KafkaConfigTest.java

@@ -1,44 +0,0 @@
-package ru.spcex.clearing.config;
-
-
-import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.consumer.OffsetResetStrategy;
-import org.apache.kafka.clients.producer.Producer;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.config.ConfigurableBeanFactory;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Scope;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.service.RequestInfo;
-import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
-import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.api.ImdgId;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-
-@Configuration
-public class KafkaConfigTest {
-
-    @Autowired
-    @Bean(name = "kafkaSenderTest")
-    public KafkaSender kafkaSender(Producer<String, Object> kafkaProducer, @Qualifier("hazelcastServiceTest") ImdgProvider imdgProvider) {
-        ImdgId imdgIdGenerator = imdgProvider.getImdgIdGenerator();
-        return KafkaSender
-                .setup()
-                .producer(kafkaProducer)
-                .idGenerator(imdgIdGenerator::nextId)
-                .imdgProvider(s -> {
-                    Imdg<RequestInfo> imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_RequestInfo, RequestInfo.class);
-                    return imdg::insert;
-                })
-                .build();
-    }
-
-    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-    @Bean(name = "mockConsumerTest")
-    public MockConsumer<String, Object> createConsumer() {
-        return new MockConsumer<>(OffsetResetStrategy.EARLIEST);
-    }
-
-}

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/config/PaymentInstructionCreatorConfigTest.java

@@ -1,15 +0,0 @@
-package ru.spcex.clearing.config;
-
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.context.annotation.Bean;
-import ru.spcex.clearing.utils.TestUtils;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
-
-public class PaymentInstructionCreatorConfigTest {
-
-    @Bean(name = "paymentInstructionCreatorTest")
-    public TestUtils.PaymentInstructionCreatorTest createPaymentInstructionCreator(@Qualifier("hazelcastServiceTest") HazelcastService hazelcastServiceTest) {
-        return new TestUtils.PaymentInstructionCreatorTest(hazelcastServiceTest);
-    }
-
-}

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/AbstractClearingTest.java

@@ -1,54 +1,38 @@
 package ru.spcex.clearing.service;
 
-import org.apache.kafka.clients.producer.MockProducer;
+import org.apache.kafka.clients.producer.Producer;
-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.kafka.core.KafkaTemplate;
 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.test.config.ImdgTestConfig;
-import ru.spcex.clearing.service.builder.LiabilitiesClaimsMoneyCreator;
+import ru.spcex.clearing.test.config.KafkaTestConfig;
-import ru.spcex.clearing.service.execution.ExecutionDepositComponent;
+import ru.spcex.platform.imdg.api.ImdgProvider;
-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,
+        ConfigTest.class,
+        MarketCodesBySessionConfig.class,
         ValidationConfig.class,
-        KafkaConfigTest.class,
+        KafkaTestConfig.class,
-        HazelcastServiceTestConfiguration.class})
+        ImdgTestConfig.class})
 public abstract class AbstractClearingTest {
     @Autowired
     @Qualifier("hazelcastServiceTest")
-    protected HazelcastService hazelcastServiceTest;
+    protected ImdgProvider hazelcastServiceTest;
-    @Captor
+
-    protected ArgumentCaptor<ProducerRecord> producerRecord;
+    @Autowired
-    @SpyBean
+    @Qualifier("mockProducer")
-    protected MockProducer<String, Object> mockProducer;
+    protected Producer<String, Object> mockProducer;
+
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    protected KafkaTemplate<String, Object> kafkaTemplate;
 
     @Autowired
     protected PaymentUpdateBySdf04 paymentUpdateBySdf04;
@@ -58,8 +42,6 @@ public abstract class AbstractClearingTest {
 
     protected void init() {
         hazelcastServiceTest.waitAvailable();
-        TestUtils.FutureRecordMetadata future = spy(TestUtils.FutureRecordMetadata.class);
-        doReturn(future).when(mockProducer).send(producerRecord.capture());
     }
 
 }

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

@@ -1,425 +1,390 @@
 package ru.spcex.clearing.service;
 
-import org.apache.kafka.clients.consumer.MockConsumer;
+//todo ClearingService не используется тест пока не нужен..
-import org.junit.jupiter.api.Test;
+class ClearingServiceTest{
-import org.springframework.beans.factory.annotation.Autowired;
+       // extends AbstractClearingTest {
-import org.springframework.beans.factory.annotation.Qualifier;
+//    public static final MatcherFactory.Matcher<LiabilitiesClaimsAssets> LIABILITIES_CLAIMS_ASSETS_MATCHER = usingIgnoringFieldsComparator("created", "updated");
-import ru.clearing.classes.statics.data.account.Account;
+//    public static final MatcherFactory.Matcher<LiabilitiesClaimsMoney> LIABILITIES_CLAIMS_MONEY_MATCHER = usingIgnoringFieldsComparator("created", "updated");
-import ru.clearing.classes.statics.data.account.AccountBalance;
+//    public static final MatcherFactory.Matcher<PaymentInstruction> PAYMENT_INSTRUCTION_MATCHER = usingIgnoringFieldsComparator("created", "updated");
-import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
+//    public static final MatcherFactory.Matcher<ExecutionDeposit> EXECUTION_DEPOSIT_MATCHER = usingIgnoringFieldsComparator("created", "updated");
-import ru.clearing.classes.statics.data.company.Company;
+//    private static final int PARTITION = 0;
-import ru.clearing.classes.statics.data.company.relation.Relation;
+//    private static final String TOPIC_START_CLEARING = Task.startOfClearing.topic();
-import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
+//    private static final String TOPIC_CONTINUE_CLEARING = Consts.CONTINUE_CLEARING;
-import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
+//    private static final Long FIRST_ID = currentID.getAndIncrement();
-import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
+//    private static final Long SECOND_ID = currentID.getAndIncrement();
-import ru.clearing.classes.statics.data.payment.PaymentInstruction;
+//    private static final AtomicInteger currentInteger = new AtomicInteger(1);
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
+//
-import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
+//    @Autowired
-import ru.spcex.clearing.platform.messaging.domain.Consts;
+//    EventsReceiver eventsReceiver;
-import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonIdRequest;
+//
-import ru.spcex.clearing.platform.messaging.domain.cud.registry.DealRegisterNewRequest;
+//    @Autowired
-import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+//    LiabilitiesClaimsAssetsCreator lbltsClmsAssetsCreator;
-import ru.spcex.clearing.service.builder.LiabilitiesClaimsAssetsCreator;
+//
-import ru.spcex.clearing.service.builder.LiabilitiesClaimsMoneyCreator;
+//    @Autowired
-import ru.spcex.clearing.utils.MatcherFactory;
+//    @Qualifier("paymentInstructionCreatorTest")
-import ru.spcex.clearing.utils.TestUtils;
+//    ConfigTest.PaymentInstructionCreatorTest paymentInstructionCreator;
-import ru.spcex.platform.enumeration.*;
+//
-import ru.spcex.platform.imdg.api.Imdg;
+//    @Autowired
-import ru.spcex.platform.utils.enumeration.IEnumKey;
+//    LiabilitiesClaimsMoneyCreator lbltsClmsMoneyCreator;
-
+//    private Imdg<ExecutionDeposit> executionDepositImdg;
-import javax.annotation.PostConstruct;
+//    private Imdg<LiabilitiesClaimsAssets> liabilitiesClaimsAssetsImdg;
-import java.math.BigDecimal;
+//    private Imdg<LiabilitiesClaimsMoney> liabilitiesClaimsMoneyImdg;
-import java.time.Instant;
+//    private Imdg<ClearingMemberCategory> clearingCategoryImdg;
-import java.time.LocalDate;
+//    private Imdg<Relation> relationImdg;
-import java.util.Collections;
+//    private Imdg<Company> companyImdg;
-import java.util.Map;
+//    private Imdg<Account> accountImdg;
-import java.util.concurrent.atomic.AtomicInteger;
+//    private Imdg<AccountBalance> accountBalanceImdg;
-
+//    private ClearingCategory category;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+//    private ExecutionDeposit executionDeposit;
-import static org.mockito.Mockito.timeout;
+//    private Relation relation;
-import static org.mockito.Mockito.verify;
+//    private Account account;
-import static ru.spcex.clearing.config.HazelcastServiceTestConfiguration.currentID;
+//    private Company company;
-import static ru.spcex.clearing.utils.MatcherFactory.usingIgnoringFieldsComparator;
+//    private AccountBalance accountBalance;
-import static ru.spcex.clearing.utils.TestUtils.addRecordToKafka;
+//
-import static ru.spcex.clearing.utils.TestUtils.getJsonStringForNew;
+//    @PostConstruct
-
+//    protected void init() {
-class ClearingServiceTest extends AbstractClearingTest {
+//        super.init();
-    public static final MatcherFactory.Matcher<LiabilitiesClaimsAssets> LIABILITIES_CLAIMS_ASSETS_MATCHER = usingIgnoringFieldsComparator("created", "updated");
+//        this.executionDepositImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class);
-    public static final MatcherFactory.Matcher<LiabilitiesClaimsMoney> LIABILITIES_CLAIMS_MONEY_MATCHER = usingIgnoringFieldsComparator("created", "updated");
+//        this.clearingCategoryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
-    public static final MatcherFactory.Matcher<PaymentInstruction> PAYMENT_INSTRUCTION_MATCHER = usingIgnoringFieldsComparator("created", "updated");
+//        this.liabilitiesClaimsAssetsImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class);
-    public static final MatcherFactory.Matcher<ExecutionDeposit> EXECUTION_DEPOSIT_MATCHER = usingIgnoringFieldsComparator("created", "updated");
+//        this.liabilitiesClaimsMoneyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsMoney, LiabilitiesClaimsMoney.class);
-    private static final int PARTITION = 0;
+//
-    private static final String TOPIC_START_CLEARING = Task.startOfClearing.topic();
+//        this.relationImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
-    private static final String TOPIC_CONTINUE_CLEARING = Consts.CONTINUE_CLEARING;
+//        this.companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-    private static final Long FIRST_ID = currentID.getAndIncrement();
+//        this.accountImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);
-    private static final Long SECOND_ID = currentID.getAndIncrement();
+//        this.accountBalanceImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
-    private static final AtomicInteger currentInteger = new AtomicInteger(1);
+//    }
-
+//
-    @Autowired
+//    /**
-    EventsReceiver eventsReceiver;
+//     * {@link ClearingService#executeClearing()} <br>
-
+//     * Тест проверяет создание сущностей
-    @Autowired
+//     * {@link LauncherCommandRequest}
-    LiabilitiesClaimsAssetsCreator lbltsClmsAssetsCreator;
+//     * {@link LiabilitiesClaimsMoney}
-
+//     * {@link PaymentInstruction}
-    @Autowired
+//     * {@link ExecutionDeposit}
-    @Qualifier("paymentInstructionCreatorTest")
+//     * в Hazelcast при передаче из Apache Kafka.<br>
-    TestUtils.PaymentInstructionCreatorTest paymentInstructionCreator;
+//     */
-
+////    @Test
-    @Autowired
+//    void startClearingNew() {
-    LiabilitiesClaimsMoneyCreator lbltsClmsMoneyCreator;
+//        //ARRANGE
-    private Imdg<ExecutionDeposit> executionDepositImdg;
+//        int times = currentInteger.getAndIncrement();
-    private Imdg<LiabilitiesClaimsAssets> liabilitiesClaimsAssetsImdg;
+//        Long companyIdI1 = 11L;
-    private Imdg<LiabilitiesClaimsMoney> liabilitiesClaimsMoneyImdg;
+//        Long relationIdI1 = 111L;
-    private Imdg<ClearingMemberCategory> clearingCategoryImdg;
+//        Long accountIdI1 = 1111L;
-    private Imdg<Relation> relationImdg;
+//        Long securityIdI1 = 11111L;
-    private Imdg<Company> companyImdg;
+//        LocalDate firstSettlementDateI1 = LocalDate.now();
-    private Imdg<Account> accountImdg;
+//        LocalDate secondSettlementDateI2 = LocalDate.ofYearDay(2022, 31);
-    private Imdg<AccountBalance> accountBalanceImdg;
+//
-    private ClearingCategory category;
+//        preparOptimisticCase(companyIdI1, relationIdI1, accountIdI1,
-    private ExecutionDeposit executionDeposit;
+//                securityIdI1, firstSettlementDateI1, secondSettlementDateI2, "I");
-    private Relation relation;
+//
-    private Account account;
+//        //ACT
-    private Company company;
+//        LauncherCommandRequest accountRequest = new LauncherCommandRequest();
-    private AccountBalance accountBalance;
+//        accountRequest.setSessionType(TRDT.getKey());
-
+//        accountRequest.setSection(MKR.getKey());
-    @PostConstruct
+//        String jsonString = getJsonStringForNew(accountRequest, FIRST_ID);
-    protected void init() {
+//        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, jsonString);
-        super.init();
+//
-        this.executionDepositImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class);
+//        //waiting for kafka producer send message
-        this.clearingCategoryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class);
+//        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(kafkaTemplate);
-        this.liabilitiesClaimsAssetsImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsAssets, LiabilitiesClaimsAssets.class);
+//        verify(kafkaTemplate, timeout(30_000L).times(1))
-        this.liabilitiesClaimsMoneyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_LiabilitiesClaimsMoney, LiabilitiesClaimsMoney.class);
+//                .send(producerRecord.capture());
-
+//        assertEquals(Consts.BALANCE_ACCOUNT_UPDATE, producerRecord.getValue().topic());
-        this.relationImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
+//        BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
-        this.companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+//
-        this.accountImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+//        //stage continueClearing
-        this.accountBalanceImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+//        CommonIdRequest requestPayload = new CommonIdRequest();
-    }
+//        requestPayload.setId(baseRequestResult.getId());
-
+//        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
-    /**
+//
-     * {@link ClearingService#executeClearing()} <br>
+//        //waiting for kafka producer send message (finale event)
-     * Тест проверяет создание сущностей
+//        verify(kafkaTemplate, timeout(30_000L).times(2))
-     * {@link LauncherCommandRequest}
+//                .send(producerRecord.capture());
-     * {@link LiabilitiesClaimsMoney}
+//
-     * {@link PaymentInstruction}
+//        //ASSERT
-     * {@link ExecutionDeposit}
+//        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
-     * в Hazelcast при передаче из Apache Kafka.<br>
+//
-     */
+//        //First LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
-    @Test
+//        LiabilitiesClaimsAssets resultFirstClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
-    void startClearingNew() {
+//                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
-        //ARRANGE
+//        LiabilitiesClaimsMoney resultFirstClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
-        int times = currentInteger.getAndIncrement();
+//                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
-        Long companyIdI1 = 11L;
+//        LiabilitiesClaimsAssets predictableFirstClaimsAssets = lbltsClmsAssetsCreator.createFirstLegLCA(category, executionDeposit);
-        Long relationIdI1 = 111L;
+//        predictableFirstClaimsAssets.setId(resultFirstClaimsAssets.getId());
-        Long accountIdI1 = 1111L;
+//        predictableFirstClaimsAssets.setPaymentId(resultFirstClaimsAssets.getPaymentId());
-        Long securityIdI1 = 11111L;
+//        predictableFirstClaimsAssets.setLiabilitiesClaimsMoneyId(resultFirstClaimsMoney.getId());
-        LocalDate firstSettlementDateI1 = LocalDate.now();
+//        LiabilitiesClaimsMoney predictableFirstClaimsMoney = lbltsClmsMoneyCreator.createFirstLegLcm(predictableFirstClaimsAssets, category);
-        LocalDate secondSettlementDateI2 = LocalDate.ofYearDay(2022, 31);
+//        predictableFirstClaimsMoney.setId(resultFirstClaimsMoney.getId());
-
+//        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultFirstClaimsAssets, predictableFirstClaimsAssets);
-        preparOptimisticCase(companyIdI1, relationIdI1, accountIdI1,
+//        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultFirstClaimsMoney, predictableFirstClaimsMoney);
-                securityIdI1, firstSettlementDateI1, secondSettlementDateI2, "I");
+//        //Second LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
-
+//        LiabilitiesClaimsAssets resultSecondClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
-        //ACT
+//                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
-        //stage executeClearing(startClearing)
+//        LiabilitiesClaimsMoney resultSecondClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
-        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
+//                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
-
+//        LiabilitiesClaimsAssets predictableSecondClaimsAssets = lbltsClmsAssetsCreator.createSecondLegLCA(category, executionDeposit);
-        //waiting for kafka producer send message
+//        predictableSecondClaimsAssets.setId(resultSecondClaimsAssets.getId());
-        verify(mockProducer, timeout(30_000L).times(1))
+//        predictableSecondClaimsAssets.setLiabilitiesClaimsMoneyId(resultSecondClaimsMoney.getId());
-                .send(producerRecord.capture());
+//        LiabilitiesClaimsMoney predictableSecondClaimsMoney = lbltsClmsMoneyCreator.createSecondLegLcm(predictableSecondClaimsAssets, category);
-        assertEquals(Consts.BALANCE_ACCOUNT_UPDATE, producerRecord.getValue().topic());
+//        predictableSecondClaimsMoney.setId(resultSecondClaimsMoney.getId());
-        BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
+//        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultSecondClaimsAssets, predictableSecondClaimsAssets);
-
+//        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultSecondClaimsMoney, predictableSecondClaimsMoney);
-        //stage continueClearing
+//        //PaymentInstruction
-        CommonIdRequest requestPayload = new CommonIdRequest();
+//        PaymentInstruction resultPaymentInstruction = paymentInstructionCreator.searchExistPaymentInstructionsFirstI(predictableFirstClaimsAssets);
-        requestPayload.setId(baseRequestResult.getId());
+//        PaymentInstruction predictablePaymentInstruction = paymentInstructionCreator.createPaymentInstruction(executionDeposit, predictableFirstClaimsAssets, Collections.singleton(category));
-        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
+//        predictablePaymentInstruction.setId(resultPaymentInstruction.getId());
-
+//        predictablePaymentInstruction.setDocumentNumber(resultPaymentInstruction.getDocumentNumber());
-        //waiting for kafka producer send message (finale event)
+//        PAYMENT_INSTRUCTION_MATCHER.assertMatch(resultPaymentInstruction, predictablePaymentInstruction);
-        verify(mockProducer, timeout(30_000L).times(2))
+//        //ExecutionDeposit
-                .send(producerRecord.capture());
+//        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectByFieldValues(
-
+//                Map.of("accountId", accountIdI1, "securityId", securityIdI1));
-        //ASSERT
+//        executionDeposit.setSessionId(resultExecutionDeposit.getSessionId());
-        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
+//        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
-
+//    }
-        //First LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
+//
-        LiabilitiesClaimsAssets resultFirstClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
+//    /**
-                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
+//     * {@link ClearingService#executeClearing()} <br>
-        LiabilitiesClaimsMoney resultFirstClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
+//     * Тест проверяет обновление сущностей
-                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
+//     * {@link LauncherCommandRequest}
-        LiabilitiesClaimsAssets predictableFirstClaimsAssets = lbltsClmsAssetsCreator.createFirstLegLCA(category, executionDeposit);
+//     * {@link LiabilitiesClaimsMoney}
-        predictableFirstClaimsAssets.setId(resultFirstClaimsAssets.getId());
+//     * {@link PaymentInstruction}
-        predictableFirstClaimsAssets.setPaymentId(resultFirstClaimsAssets.getPaymentId());
+//     * {@link ExecutionDeposit}
-        predictableFirstClaimsAssets.setLiabilitiesClaimsMoneyId(resultFirstClaimsMoney.getId());
+//     * в Hazelcast при передаче из Apache Kafka.<br>
-        LiabilitiesClaimsMoney predictableFirstClaimsMoney = lbltsClmsMoneyCreator.createFirstLegLcm(predictableFirstClaimsAssets, category);
+//     */
-        predictableFirstClaimsMoney.setId(resultFirstClaimsMoney.getId());
+////    @Test
-        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultFirstClaimsAssets, predictableFirstClaimsAssets);
+//    void startClearingUpdate() {
-        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultFirstClaimsMoney, predictableFirstClaimsMoney);
+//        //ARRANGE
-        //Second LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
+//        int times = currentInteger.getAndIncrement();
-        LiabilitiesClaimsAssets resultSecondClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
+//        Long companyIdI1 = 21L;
-                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
+//        Long relationIdI1 = 211L;
-        LiabilitiesClaimsMoney resultSecondClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
+//        Long accountIdI1 = 2111L;
-                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
+//        Long securityIdI1 = 21111L;
-        LiabilitiesClaimsAssets predictableSecondClaimsAssets = lbltsClmsAssetsCreator.createSecondLegLCA(category, executionDeposit);
+//        LocalDate firstSettlementDateI1 = LocalDate.now();
-        predictableSecondClaimsAssets.setId(resultSecondClaimsAssets.getId());
+//        LocalDate secondSettlementDateI2 = LocalDate.ofYearDay(2022, 31);
-        predictableSecondClaimsAssets.setLiabilitiesClaimsMoneyId(resultSecondClaimsMoney.getId());
+//
-        LiabilitiesClaimsMoney predictableSecondClaimsMoney = lbltsClmsMoneyCreator.createSecondLegLcm(predictableSecondClaimsAssets, category);
+//        preparOptimisticCase(companyIdI1, relationIdI1, accountIdI1,
-        predictableSecondClaimsMoney.setId(resultSecondClaimsMoney.getId());
+//                securityIdI1, firstSettlementDateI1, secondSettlementDateI2, "I");
-        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultSecondClaimsAssets, predictableSecondClaimsAssets);
+//
-        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultSecondClaimsMoney, predictableSecondClaimsMoney);
+//        LiabilitiesClaimsAssets predictableFirstClaimsAssets = lbltsClmsAssetsCreator.createFirstLegLCA(category, executionDeposit);
-        //PaymentInstruction
+//        predictableFirstClaimsAssets.setId(FIRST_ID);
-        PaymentInstruction resultPaymentInstruction = paymentInstructionCreator.searchExistPaymentInstructionsFirstI(predictableFirstClaimsAssets);
+//        liabilitiesClaimsAssetsImdg.insert(predictableFirstClaimsAssets);
-        PaymentInstruction predictablePaymentInstruction = paymentInstructionCreator.createPaymentInstruction(executionDeposit, predictableFirstClaimsAssets, Collections.singleton(category));
+//        LiabilitiesClaimsMoney predictableFirstClaimsMoney = lbltsClmsMoneyCreator.createFirstLegLcm(predictableFirstClaimsAssets, category);
-        predictablePaymentInstruction.setId(resultPaymentInstruction.getId());
+//        predictableFirstClaimsMoney.setId(FIRST_ID);
-        predictablePaymentInstruction.setDocumentNumber(resultPaymentInstruction.getDocumentNumber());
+//        liabilitiesClaimsMoneyImdg.insert(predictableFirstClaimsMoney);
-        PAYMENT_INSTRUCTION_MATCHER.assertMatch(resultPaymentInstruction, predictablePaymentInstruction);
+//        LiabilitiesClaimsAssets predictableSecondClaimsAssets = lbltsClmsAssetsCreator.createSecondLegLCA(category, executionDeposit);
-        //ExecutionDeposit
+//        predictableSecondClaimsAssets.setId(SECOND_ID);
-        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectByFieldValues(
+//        liabilitiesClaimsAssetsImdg.insert(predictableSecondClaimsAssets);
-                Map.of("accountId", accountIdI1, "securityId", securityIdI1));
+//        LiabilitiesClaimsMoney predictableSecondClaimsMoney = lbltsClmsMoneyCreator.createSecondLegLcm(predictableSecondClaimsAssets, category);
-        executionDeposit.setSessionId(resultExecutionDeposit.getSessionId());
+//        predictableSecondClaimsMoney.setId(SECOND_ID);
-        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
+//        liabilitiesClaimsMoneyImdg.insert(predictableSecondClaimsMoney);
-    }
+//        //ACT
-
+//        //stage executeClearing(startClearing)
-    /**
+//        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
-     * {@link ClearingService#executeClearing()} <br>
+//
-     * Тест проверяет обновление сущностей
+//        //waiting for kafka producer send message
-     * {@link LauncherCommandRequest}
+//        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(kafkaTemplate);
-     * {@link LiabilitiesClaimsMoney}
+//        verify(kafkaTemplate, timeout(30_000L).times(1))
-     * {@link PaymentInstruction}
+//                .send(producerRecord.capture());
-     * {@link ExecutionDeposit}
+//        assertEquals(Consts.BALANCE_ACCOUNT_UPDATE, producerRecord.getValue().topic());
-     * в Hazelcast при передаче из Apache Kafka.<br>
+//        BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
-     */
+//
-    @Test
+//        //stage continueClearing
-    void startClearingUpdate() {
+//        CommonIdRequest requestPayload = new CommonIdRequest();
-        //ARRANGE
+//        requestPayload.setId(baseRequestResult.getId());
-        int times = currentInteger.getAndIncrement();
+//        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
-        Long companyIdI1 = 21L;
+//
-        Long relationIdI1 = 211L;
+//        //waiting for kafka producer send message (finale event)
-        Long accountIdI1 = 2111L;
+//        verify(kafkaTemplate, timeout(30_000L).times(2))
-        Long securityIdI1 = 21111L;
+//                .send(producerRecord.capture());
-        LocalDate firstSettlementDateI1 = LocalDate.now();
+//
-        LocalDate secondSettlementDateI2 = LocalDate.ofYearDay(2022, 31);
+//        //ASSERT
-
+//        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
-        preparOptimisticCase(companyIdI1, relationIdI1, accountIdI1,
+//
-                securityIdI1, firstSettlementDateI1, secondSettlementDateI2, "I");
+//        //First LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
-
+//        LiabilitiesClaimsAssets resultFirstClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
-        LiabilitiesClaimsAssets predictableFirstClaimsAssets = lbltsClmsAssetsCreator.createFirstLegLCA(category, executionDeposit);
+//                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
-        predictableFirstClaimsAssets.setId(FIRST_ID);
+//        LiabilitiesClaimsMoney resultFirstClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
-        liabilitiesClaimsAssetsImdg.insert(predictableFirstClaimsAssets);
+//                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
-        LiabilitiesClaimsMoney predictableFirstClaimsMoney = lbltsClmsMoneyCreator.createFirstLegLcm(predictableFirstClaimsAssets, category);
+//        predictableFirstClaimsAssets.setPaymentId(resultFirstClaimsAssets.getPaymentId());
-        predictableFirstClaimsMoney.setId(FIRST_ID);
+//        predictableFirstClaimsAssets.setLiabilitiesClaimsMoneyId(resultFirstClaimsMoney.getId());
-        liabilitiesClaimsMoneyImdg.insert(predictableFirstClaimsMoney);
+//        lbltsClmsAssetsCreator.updateFirstLegLca(predictableFirstClaimsAssets, executionDeposit, category);
-        LiabilitiesClaimsAssets predictableSecondClaimsAssets = lbltsClmsAssetsCreator.createSecondLegLCA(category, executionDeposit);
+//        lbltsClmsMoneyCreator.updateFirstLegLcm(predictableFirstClaimsMoney, predictableFirstClaimsAssets, executionDeposit, category);
-        predictableSecondClaimsAssets.setId(SECOND_ID);
+//        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultFirstClaimsAssets, predictableFirstClaimsAssets);
-        liabilitiesClaimsAssetsImdg.insert(predictableSecondClaimsAssets);
+//        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultFirstClaimsMoney, predictableFirstClaimsMoney);
-        LiabilitiesClaimsMoney predictableSecondClaimsMoney = lbltsClmsMoneyCreator.createSecondLegLcm(predictableSecondClaimsAssets, category);
+//        //Second LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
-        predictableSecondClaimsMoney.setId(SECOND_ID);
+//        LiabilitiesClaimsAssets resultSecondClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
-        liabilitiesClaimsMoneyImdg.insert(predictableSecondClaimsMoney);
+//                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
-        //ACT
+//        LiabilitiesClaimsMoney resultSecondClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
-        //stage executeClearing(startClearing)
+//                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
-        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
+//
-
+//        predictableSecondClaimsAssets.setLiabilitiesClaimsMoneyId(resultSecondClaimsMoney.getId());
-        //waiting for kafka producer send message
+//        lbltsClmsAssetsCreator.updateSecondLegLca(predictableSecondClaimsAssets, executionDeposit, category);
-        verify(mockProducer, timeout(30_000L).times(1))
+//        lbltsClmsMoneyCreator.updateSecondLegLcm(predictableSecondClaimsMoney, predictableSecondClaimsAssets, executionDeposit, category);
-                .send(producerRecord.capture());
+//        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultSecondClaimsAssets, predictableSecondClaimsAssets);
-        assertEquals(Consts.BALANCE_ACCOUNT_UPDATE, producerRecord.getValue().topic());
+//        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultSecondClaimsMoney, predictableSecondClaimsMoney);
-        BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
+//        //PaymentInstruction
-
+//        PaymentInstruction resultPaymentInstruction = paymentInstructionCreator.searchExistPaymentInstructionsFirstI(predictableFirstClaimsAssets);
-        //stage continueClearing
+//        PaymentInstruction predictablePaymentInstruction = paymentInstructionCreator.createPaymentInstruction(executionDeposit, predictableFirstClaimsAssets, Collections.singleton(category));
-        CommonIdRequest requestPayload = new CommonIdRequest();
+//        predictablePaymentInstruction.setId(resultPaymentInstruction.getId());
-        requestPayload.setId(baseRequestResult.getId());
+//        predictablePaymentInstruction.setDocumentNumber(resultPaymentInstruction.getDocumentNumber());
-        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_CONTINUE_CLEARING, PARTITION, times, getJsonStringForNew(requestPayload, FIRST_ID));
+//        PAYMENT_INSTRUCTION_MATCHER.assertMatch(resultPaymentInstruction, predictablePaymentInstruction);
-
+//        //ExecutionDeposit
-        //waiting for kafka producer send message (finale event)
+//        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectByFieldValues(
-        verify(mockProducer, timeout(30_000L).times(2))
+//                Map.of("accountId", accountIdI1, "securityId", securityIdI1));
-                .send(producerRecord.capture());
+//        executionDeposit.setSessionId(resultExecutionDeposit.getSessionId());
-
+//        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
-        //ASSERT
+//    }
-        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
+//
-
+//    /**
-        //First LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
+//     * {@link ClearingService#executeClearing()} <br>
-        LiabilitiesClaimsAssets resultFirstClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
+//     * Тест проверяет обновление сущностей
-                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
+//     * {@link LauncherCommandRequest}
-        LiabilitiesClaimsMoney resultFirstClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
+//     * {@link LiabilitiesClaimsMoney}
-                Map.of("accountId", accountIdI1, "settlementDate", firstSettlementDateI1));
+//     * {@link PaymentInstruction}
-        predictableFirstClaimsAssets.setPaymentId(resultFirstClaimsAssets.getPaymentId());
+//     * {@link ExecutionDeposit}
-        predictableFirstClaimsAssets.setLiabilitiesClaimsMoneyId(resultFirstClaimsMoney.getId());
+//     * в Hazelcast при передаче из Apache Kafka.<br>
-        lbltsClmsAssetsCreator.updateFirstLegLca(predictableFirstClaimsAssets, executionDeposit, category);
+//     */
-        lbltsClmsMoneyCreator.updateFirstLegLcm(predictableFirstClaimsMoney, predictableFirstClaimsAssets, executionDeposit, category);
+////    @Test
-        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultFirstClaimsAssets, predictableFirstClaimsAssets);
+//    void startClearingValidatError() {
-        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultFirstClaimsMoney, predictableFirstClaimsMoney);
+//        //ARRANGE
-        //Second LiabilitiesClaimsAssets && LiabilitiesClaimsMoney
+//        Long companyId = 31L;
-        LiabilitiesClaimsAssets resultSecondClaimsAssets = liabilitiesClaimsAssetsImdg.getFirstObjectByFieldValues(
+//        Long relationId = 311L;
-                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
+//        Long accountId = 3111L;
-        LiabilitiesClaimsMoney resultSecondClaimsMoney = liabilitiesClaimsMoneyImdg.getFirstObjectByFieldValues(
+//        Long securityId = 31111L;
-                Map.of("accountId", accountIdI1, "settlementDate", secondSettlementDateI2));
+//        LocalDate firstSettlementDate = LocalDate.now();
-
+//        LocalDate secondSettlementDate = LocalDate.ofYearDay(2022, 31);
-        predictableSecondClaimsAssets.setLiabilitiesClaimsMoneyId(resultSecondClaimsMoney.getId());
+//
-        lbltsClmsAssetsCreator.updateSecondLegLca(predictableSecondClaimsAssets, executionDeposit, category);
+//        preparOptimisticCase(companyId, relationId, accountId,
-        lbltsClmsMoneyCreator.updateSecondLegLcm(predictableSecondClaimsMoney, predictableSecondClaimsAssets, executionDeposit, category);
+//                securityId, firstSettlementDate, secondSettlementDate, "V");
-        LIABILITIES_CLAIMS_ASSETS_MATCHER.assertMatch(resultSecondClaimsAssets, predictableSecondClaimsAssets);
+//
-        LIABILITIES_CLAIMS_MONEY_MATCHER.assertMatch(resultSecondClaimsMoney, predictableSecondClaimsMoney);
+//
-        //PaymentInstruction
+//        //ClearingIsAllowed
-        PaymentInstruction resultPaymentInstruction = paymentInstructionCreator.searchExistPaymentInstructionsFirstI(predictableFirstClaimsAssets);
+//        relation.setServiceStatus(ServiceStatus.Blocked.getKey());
-        PaymentInstruction predictablePaymentInstruction = paymentInstructionCreator.createPaymentInstruction(executionDeposit, predictableFirstClaimsAssets, Collections.singleton(category));
+//        relationImdg.insert(relation);
-        predictablePaymentInstruction.setId(resultPaymentInstruction.getId());
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-        predictablePaymentInstruction.setDocumentNumber(resultPaymentInstruction.getDocumentNumber());
+//
-        PAYMENT_INSTRUCTION_MATCHER.assertMatch(resultPaymentInstruction, predictablePaymentInstruction);
+//        //AccountIsNotBlocked
-        //ExecutionDeposit
+//        relation.setServiceStatus(ServiceStatus.Active.getKey());
-        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectByFieldValues(
+//        relationImdg.insert(relation);
-                Map.of("accountId", accountIdI1, "securityId", securityIdI1));
+//        executionDeposit = getExecutionDeposit(companyId, null, securityId, firstSettlementDate, secondSettlementDate);
-        executionDeposit.setSessionId(resultExecutionDeposit.getSessionId());
+//        executionDepositImdg.insert(executionDeposit);
-        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-    }
+//
-
+//        executionDeposit = getExecutionDeposit(companyId, accountId, securityId, firstSettlementDate, secondSettlementDate);
-    /**
+//        executionDepositImdg.insert(executionDeposit);
-     * {@link ClearingService#executeClearing()} <br>
+//        account.setStatus(AccountStatus.BLOCKED.getKey());
-     * Тест проверяет обновление сущностей
+//        accountImdg.insert(account);
-     * {@link LauncherCommandRequest}
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-     * {@link LiabilitiesClaimsMoney}
+//
-     * {@link PaymentInstruction}
+//        //CompanyIsNotBlocked
-     * {@link ExecutionDeposit}
+//        account.setStatus(AccountStatus.ACTIVE.getKey());
-     * в Hazelcast при передаче из Apache Kafka.<br>
+//        accountImdg.insert(account);
-     */
+//        company.setWorkflowStatus(WorkflowStatus.Blocked.getKey());
-    @Test
+//        companyImdg.insert(company);
-    void startClearingValidatError() {
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-        //ARRANGE
+//
-        Long companyId = 31L;
+//        company.setWorkflowStatus(null);
-        Long relationId = 311L;
+//        companyImdg.insert(company);
-        Long accountId = 3111L;
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-        Long securityId = 31111L;
+//
-        LocalDate firstSettlementDate = LocalDate.now();
+//        //FinancialObligationSecurity
-        LocalDate secondSettlementDate = LocalDate.ofYearDay(2022, 31);
+//        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
-
+//        companyImdg.insert(company);
-        preparOptimisticCase(companyId, relationId, accountId,
+//        accountBalance.setAccountId(0L);
-                securityId, firstSettlementDate, secondSettlementDate, "V");
+//        accountBalanceImdg.insert(accountBalance);
-
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-
+//
-        //ClearingIsAllowed
+//        accountBalance.setAccountId(accountId);
-        relation.setServiceStatus(ServiceStatus.Blocked.getKey());
+//        accountBalance.setFreeBalanceAmount(new BigDecimal(19));
-        relationImdg.insert(relation);
+//        accountBalanceImdg.insert(accountBalance);
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        executionDeposit.setFirstLegAmount(new BigDecimal(200));
-
+//        executionDepositImdg.insert(executionDeposit);
-        //AccountIsNotBlocked
+//        checkHaveSomeError(currentInteger.getAndIncrement());
-        relation.setServiceStatus(ServiceStatus.Active.getKey());
+//    }
-        relationImdg.insert(relation);
+//
-        executionDeposit = getExecutionDeposit(companyId, null, securityId, firstSettlementDate, secondSettlementDate);
+//    void preparOptimisticCase(Long companyId, Long relationId, Long accountId,
-        executionDepositImdg.insert(executionDeposit);
+//                              Long securityId, LocalDate dtF, LocalDate dtS, String memberCategory) {
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        category = IEnumKey.getEnumByKey(ClearingCategory.class, memberCategory);
-
+//
-        executionDeposit = getExecutionDeposit(companyId, accountId, securityId, firstSettlementDate, secondSettlementDate);
+//        executionDeposit = getExecutionDeposit(companyId, accountId, securityId, dtF, dtS);
-        executionDepositImdg.insert(executionDeposit);
+//        executionDepositImdg.insert(executionDeposit);
-        account.setStatus(AccountStatus.BLOCKED.getKey());
+//
-        accountImdg.insert(account);
+//        ClearingMemberCategory clearingMemberCategory = new ClearingMemberCategory();
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        clearingMemberCategory.setCompanyId(companyId);
-
+//        clearingMemberCategory.setClearingMemberCategory(memberCategory);
-        //CompanyIsNotBlocked
+//        clearingCategoryImdg.insert(clearingMemberCategory);
-        account.setStatus(AccountStatus.ACTIVE.getKey());
+//
-        accountImdg.insert(account);
+//        relation = new Relation();
-        company.setWorkflowStatus(WorkflowStatus.Blocked.getKey());
+//        relation.setId(relationId);
-        companyImdg.insert(company);
+//        relation.setConsumerId(companyId);
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        relation.setServiceStatus(ServiceStatus.Active.getKey());
-
+//        relationImdg.insert(relation);
-        company.setWorkflowStatus(null);
+//
-        companyImdg.insert(company);
+//        account = new Account();
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        account.setId(accountId);
-
+//        account.setRelationId(relationId);
-        //FinancialObligationSecurity
+//        account.setStatus(AccountStatus.ACTIVE.getKey());
-        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
+//        accountImdg.insert(account);
-        companyImdg.insert(company);
+//
-        accountBalance.setAccountId(0L);
+//        company = new Company();
-        accountBalanceImdg.insert(accountBalance);
+//        company.setId(companyId);
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
-
+//        companyImdg.insert(company);
-        accountBalance.setAccountId(accountId);
+//
-        accountBalance.setFreeBalanceAmount(new BigDecimal(19));
+//        accountBalance = new AccountBalance();
-        accountBalanceImdg.insert(accountBalance);
+//        accountBalance.setAccountId(accountId);
-        executionDeposit.setFirstLegAmount(new BigDecimal(200));
+//        accountBalance.setCompanyId(companyId);
-        executionDepositImdg.insert(executionDeposit);
+//        accountBalanceImdg.insert(accountBalance);
-        checkHaveSomeError(currentInteger.getAndIncrement());
+//    }
-    }
+//
-
+//    ExecutionDeposit getExecutionDeposit(Long companyId, Long accountId, Long securityId, LocalDate dtF, LocalDate dtS) {
-    void preparOptimisticCase(Long companyId, Long relationId, Long accountId,
+//        ExecutionDeposit executionDeposit = new ExecutionDeposit();
-                              Long securityId, LocalDate dtF, LocalDate dtS, String memberCategory) {
+//        executionDeposit.setExchangeExecutionId(5L);
-        category = IEnumKey.getEnumByKey(ClearingCategory.class, memberCategory);
+//        executionDeposit.setExchangeExecutionTime(Instant.now());
-
+//        executionDeposit.setTradingDate(LocalDate.now());
-        executionDeposit = getExecutionDeposit(companyId, accountId, securityId, dtF, dtS);
+//        executionDeposit.setTradingClearingRegistryId(accountId); //todo CLS-275       executionDeposit.setAccountId(accountId);
-        executionDepositImdg.insert(executionDeposit);
+//        executionDeposit.setMarket("market");
-
+//        executionDeposit.setPrice(new BigDecimal(9));
-        ClearingMemberCategory clearingMemberCategory = new ClearingMemberCategory();
+//        executionDeposit.setLots(new BigDecimal(0));
-        clearingMemberCategory.setCompanyId(companyId);
+//        executionDeposit.setQuantity(new BigDecimal(8));
-        clearingMemberCategory.setClearingMemberCategory(memberCategory);
+//        executionDeposit.setFirstLegAmount(new BigDecimal(7));
-        clearingCategoryImdg.insert(clearingMemberCategory);
+//        executionDeposit.setSecondLegAmount(new BigDecimal(6));
-
+//        executionDeposit.setInterestAmount(new BigDecimal(5));
-        relation = new Relation();
+//        executionDeposit.setSide("side");
-        relation.setId(relationId);
+//        executionDeposit.setSettlementCurrency("settlementCurrency");
-        relation.setConsumerId(companyId);
+//        executionDeposit.setCompanyId(companyId);
-        relation.setServiceStatus(ServiceStatus.Active.getKey());
+//        executionDeposit.setDuration(1L);
-        relationImdg.insert(relation);
+//        executionDeposit.setFirstLegSettlementDate(dtF);
-
+//        executionDeposit.setSecondLegSettlementDate(dtS);
-        account = new Account();
+//        executionDeposit.setFirstLegSettlementCode("leg1c");
-        account.setId(accountId);
+//        executionDeposit.setSecondLegSettlementCode("legcc");
-        account.setRelationId(relationId);
+//        executionDeposit.setContract("contract");
-        account.setStatus(AccountStatus.ACTIVE.getKey());
+//        executionDeposit.setSecurityFullName("full");
-        accountImdg.insert(account);
+//        executionDeposit.setSecuritySymbol("symbol");
-
+//        executionDeposit.setSecurityId(securityId);
-        company = new Company();
+//        executionDeposit.setCounterPartyId(0L);
-        company.setId(companyId);
+//        executionDeposit.setCoverageStatus(Allowed.ALLOWED.getKey());
-        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
+//        executionDeposit.setSessionId(null);
-        companyImdg.insert(company);
+//        executionDeposit.setClearingDate(LocalDate.now());
-
+//        executionDeposit.setId(FIRST_ID);
-        accountBalance = new AccountBalance();
+//        return executionDeposit;
-        accountBalance.setAccountId(accountId);
+//    }
-        accountBalance.setCompanyId(companyId);
+//
-        accountBalanceImdg.insert(accountBalance);
+//    void checkHaveSomeError(long times) {
-    }
+//        //ACT
-
+//        //stage executeClearing(startClearing)
-    ExecutionDeposit getExecutionDeposit(Long companyId, Long accountId, Long securityId, LocalDate dtF, LocalDate dtS) {
+//        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_START_CLEARING, PARTITION, times, getJsonStringForNew(new DealRegisterNewRequest(), FIRST_ID));
-        ExecutionDeposit executionDeposit = new ExecutionDeposit();
+//
-        executionDeposit.setExchangeExecutionId(5L);
+//        //waiting for kafka producer send message
-        executionDeposit.setExchangeExecutionTime(Instant.now());
+//        ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(kafkaTemplate);
-        executionDeposit.setTradingDate(LocalDate.now());
+//        verify(kafkaTemplate, timeout(30_000L).times(1))
-        executionDeposit.setTradingClearingRegistryId(accountId); //todo CLS-275       executionDeposit.setAccountId(accountId);
+//                .send(producerRecord.capture());
-        executionDeposit.setMarket("market");
+//
-        executionDeposit.setPrice(new BigDecimal(9));
+//        //ASSERT
-        executionDeposit.setLots(new BigDecimal(0));
+//        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
-        executionDeposit.setQuantity(new BigDecimal(8));
+//        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectBySQL("settlementCurrency = 'settlementCurrency'");
-        executionDeposit.setFirstLegAmount(new BigDecimal(7));
+//        executionDeposit.setUpdated(resultExecutionDeposit.getUpdated());
-        executionDeposit.setSecondLegAmount(new BigDecimal(6));
+//        executionDeposit.setCoverageStatus(Allowed.DENIED.getKey());
-        executionDeposit.setInterestAmount(new BigDecimal(5));
+//        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
-        executionDeposit.setSide("side");
+//    }
-        executionDeposit.setSettlementCurrency("settlementCurrency");
-        executionDeposit.setCompanyId(companyId);
-        executionDeposit.setDuration(1L);
-        executionDeposit.setFirstLegSettlementDate(dtF);
-        executionDeposit.setSecondLegSettlementDate(dtS);
-        executionDeposit.setFirstLegSettlementCode("leg1c");
-        executionDeposit.setSecondLegSettlementCode("legcc");
-        executionDeposit.setContract("contract");
-        executionDeposit.setSecurityFullName("full");
-        executionDeposit.setSecuritySymbol("symbol");
-        executionDeposit.setSecurityId(securityId);
-        executionDeposit.setCounterPartyId(0L);
-        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(30_000L).times((int) times))
-                .send(producerRecord.capture());
-
-        //ASSERT
-        assertEquals(Task.createOrder.topic(), producerRecord.getValue().topic());
-        ExecutionDeposit resultExecutionDeposit = executionDepositImdg.getFirstObjectBySQL("settlementCurrency = 'settlementCurrency'");
-        executionDeposit.setUpdated(resultExecutionDeposit.getUpdated());
-        executionDeposit.setCoverageStatus(Allowed.DENIED.getKey());
-        EXECUTION_DEPOSIT_MATCHER.assertMatch(resultExecutionDeposit, executionDeposit);
-    }
 }

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/PaymentUpdateBySdf04Test.java

@@ -18,7 +18,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 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.utils.TestUtils.*;
+import static ru.spcex.clearing.test.TestUtils.*;
 
 class PaymentUpdateBySdf04Test extends AbstractClearingTest {
     private static final int PARTITION = 0;
@@ -80,7 +80,7 @@ class PaymentUpdateBySdf04Test extends AbstractClearingTest {
 
         //ACT
         addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_SDF04_PROCESS,
-                PARTITION, times, getJsonStringForUPDATE(requestPayload, sdf04GroupId));
+                PARTITION, times, getJsonStringForUpdate(requestPayload, sdf04GroupId));
 
         //waiting for paymentImdgs update
         verify(paymentImdgsMock, timeout(30_000L).times(times))

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/VerificationResultComponentTest.java

@@ -24,15 +24,15 @@ import java.util.concurrent.atomic.AtomicInteger;
 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.utils.TestUtils.*;
+import static ru.spcex.clearing.test.TestUtils.*;
 
 class VerificationResultComponentTest extends AbstractClearingTest {
     private static final int PARTITION = 0;
     private static final AtomicInteger currentInteger = new AtomicInteger(1);
-    private static final String TOPIC_VERIFICATION = Task.getVerification.topic();
+    private static final String TOPIC_VERIFICATION = Task.createOrderConfirm.topic();
 
     @Autowired
-    EventsReceiver eventsReceiver;
+    LauncherCommandReceiver receiver;
     private Imdg<SDf01> sdf01Imdg;
     private Imdg<AccountBalance> accountBalanceImdg;
     private Imdg<Account> accountImdg;
@@ -112,8 +112,8 @@ class VerificationResultComponentTest extends AbstractClearingTest {
     private void checkVerificationResults(String resultStatuses) {
         int times = currentInteger.getAndIncrement();
         //ACT
-        addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC_VERIFICATION,
+        addRecordToKafka((MockConsumer) receiver.getConsumer(), TOPIC_VERIFICATION,
-                PARTITION, times, getJsonStringForUPDATE(new LauncherCommandRequest(), 1L));
+                PARTITION, times, getJsonStringForUpdate(new LauncherCommandRequest(), 1L));
 
         ArgumentCaptor<VerificationResult> settingResult = ArgumentCaptor.forClass(VerificationResult.class);
         verify(verificationResultImdgMock, timeout(30_000L).times(4 * times))

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/execution/ExecutionDepositComponentTest.java

@@ -21,8 +21,8 @@ import java.time.Instant;
 import java.time.LocalDate;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static ru.spcex.clearing.utils.TestUtils.addRecordToKafka;
+import static ru.spcex.clearing.test.TestUtils.addRecordToKafka;
-import static ru.spcex.clearing.utils.TestUtils.getJsonStringForUPDATE;
+import static ru.spcex.clearing.test.TestUtils.getJsonStringForUpdate;
 
 class ExecutionDepositComponentTest extends AbstractClearingTest {
     private static final int PARTITION = 0;
@@ -85,7 +85,7 @@ class ExecutionDepositComponentTest extends AbstractClearingTest {
         int times = currentInteger.getAndIncrement();
 
         addRecordToKafka((MockConsumer) eventsReceiver.getConsumer(), TOPIC,
-                PARTITION, times, getJsonStringForUPDATE(new LauncherCommandRequest(), 1L));
+                PARTITION, times, getJsonStringForUpdate(new LauncherCommandRequest(), 1L));
 
         //waiting for kafka producer send message (finale event)
 //        verify(mockProducer, timeout(30_000L).times(times))

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/utils/MatcherFactory.java

@@ -1,38 +0,0 @@
-package ru.spcex.clearing.utils;
-
-import java.util.Arrays;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Factory for creating test matchers.
- * <p>
- * Comparing actual and expected objects via AssertJ
- */
-public class MatcherFactory {
-
-    public static <T> Matcher<T> usingIgnoringFieldsComparator(String... fieldsToIgnore) {
-        return new Matcher<>(fieldsToIgnore);
-    }
-
-    public static class Matcher<T> {
-        private final String[] fieldsToIgnore;
-
-        private Matcher(String... fieldsToIgnore) {
-            this.fieldsToIgnore = fieldsToIgnore;
-        }
-
-        public void assertMatch(T actual, T expected) {
-            assertThat(actual).usingRecursiveComparison().ignoringFields(fieldsToIgnore).isEqualTo(expected);
-        }
-
-        @SafeVarargs
-        public final void assertMatch(Iterable<T> actual, T... expected) {
-            assertMatch(actual, Arrays.asList(expected));
-        }
-
-        public void assertMatch(Iterable<T> actual, Iterable<T> expected) {
-            assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields(fieldsToIgnore).isEqualTo(expected);
-        }
-    }
-}

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/utils/TestUtils.java

@@ -1,158 +0,0 @@
-package ru.spcex.clearing.utils;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.producer.MockProducer;
-import org.apache.kafka.clients.producer.ProducerRecord;
-import org.apache.kafka.clients.producer.RecordMetadata;
-import org.apache.kafka.common.TopicPartition;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
-import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
-import ru.clearing.classes.statics.data.payment.PaymentInstruction;
-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.service.RequestInfoUpdate;
-import ru.spcex.clearing.service.builder.PaymentInstructionCreator;
-import ru.spcex.platform.classes.base.SpcexObjectBase;
-import ru.spcex.platform.enumeration.ClearingCategory;
-import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.api.ImdgProvider;
-
-import java.lang.reflect.Field;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.*;
-import static ru.spcex.clearing.platform.messaging.service.Status.Success;
-import static ru.spcex.clearing.utils.MatcherFactory.usingIgnoringFieldsComparator;
-
-public class TestUtils {
-    public static final MatcherFactory.Matcher<BaseRequest<Object>> BASE_REQUEST_MATCHER = usingIgnoringFieldsComparator();
-    private static final ObjectMapper objectMapper = new ObjectMapper();
-
-    public static void waitingWhenAddedRecordAndCheckIt(Long id, MockProducer mockProducer, ArgumentCaptor<ProducerRecord> producerRecord) {
-        BaseRequest<Object> predictableBaseRequest = new BaseRequest<>();
-        predictableBaseRequest.setId(id);
-        predictableBaseRequest.setActionType(ActionType.SYSTEM);
-        RequestInfoUpdate requestInfoUpdate = new RequestInfoUpdate();
-        requestInfoUpdate.setId(id);
-        requestInfoUpdate.setStatus(Success);
-        predictableBaseRequest.setRequestPayload(requestInfoUpdate);
-
-        //waiting for kafka producer send message (finale event)
-        verify(mockProducer, timeout(30_000L).times(1))
-                .send(producerRecord.capture());
-
-        BaseRequest<Object> baseRequestResult = (BaseRequest<Object>) producerRecord.getValue().value();
-        assertEquals(Consts.REQUEST_INFO_UPDATE, producerRecord.getValue().topic());
-        BASE_REQUEST_MATCHER.assertMatch(baseRequestResult, predictableBaseRequest);
-    }
-
-    public static void addRecordToKafka(MockConsumer mockConsumer, String topic, int partition, long offset, String jsonValue) {
-        TopicPartition tp = new TopicPartition(topic, partition);
-        HashMap<TopicPartition, Long> startOffsets = new HashMap<>();
-        startOffsets.put(tp, 0L);
-        mockConsumer.updateBeginningOffsets(startOffsets);
-        mockConsumer.schedulePollTask(() -> {
-            mockConsumer.rebalance(Collections.singletonList(tp));
-            mockConsumer.addRecord(new ConsumerRecord<>(topic, partition, offset, "key", jsonValue));
-        });
-    }
-
-    public static <T> String getJsonStringForNew(T accountRequest, long id) {
-        return getJsonBaseRequest(accountRequest, id, ActionType.NEW);
-    }
-
-    public static <T> String getJsonStringForUPDATE(T accountRequest, long id) {
-        return getJsonBaseRequest(accountRequest, id, ActionType.UPDATE);
-    }
-
-    public static <T> String getJsonStringForDELETE(T accountRequest, long id) {
-        return getJsonBaseRequest(accountRequest, id, ActionType.DELETE);
-    }
-
-    private static <T> String getJsonBaseRequest(T accountRequest, long id, ActionType actionType) {
-        BaseRequest<T> baseRequest = new BaseRequest<>();
-        baseRequest.setRequestPayload(accountRequest);
-        baseRequest.setId(id);
-        baseRequest.setActionType(actionType);
-        String jsonBaseRequest;
-        try {
-            jsonBaseRequest = objectMapper.writeValueAsString(baseRequest);
-        } catch (JsonProcessingException e) {
-            throw new RuntimeException(e);
-        }
-        return jsonBaseRequest;
-    }
-
-    public static <T, V> T getMockForFildObj(T from, V obj, String fildName) {
-        T mock = Mockito.mock((Class<T>) from.getClass(), withSettings()
-                .serializable()
-                .spiedInstance(from)
-                .defaultAnswer(CALLS_REAL_METHODS));
-        try {
-            Field dbServiceField = obj.getClass().getDeclaredField(fildName);
-            dbServiceField.setAccessible(true);
-            dbServiceField.set(obj, mock);
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            throw new RuntimeException(e);
-        }
-        return mock;
-    }
-
-    public static <T extends SpcexObjectBase> void clearAllInImdg(Imdg<T> imdg) {
-        Collection<T> values = imdg.getAllValues();
-        values.forEach(imdg::delete);
-    }
-
-    public static class FutureRecordMetadata implements Future<RecordMetadata> {
-        @Override
-        public boolean cancel(boolean mayInterruptIfRunning) {
-            return false;
-        }
-
-        @Override
-        public boolean isCancelled() {
-            return false;
-        }
-
-        @Override
-        public boolean isDone() {
-            return false;
-        }
-
-        @Override
-        public RecordMetadata get() throws InterruptedException, ExecutionException {
-            return null;
-        }
-
-        @Override
-        public RecordMetadata get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-            return null;
-        }
-    }
-
-    public static class PaymentInstructionCreatorTest extends PaymentInstructionCreator {
-        public PaymentInstructionCreatorTest(ImdgProvider imdgProvider) {
-            super(imdgProvider);
-        }
-
-        public PaymentInstruction createPaymentInstruction(ExecutionDeposit executionDeposit, LiabilitiesClaimsAssets liabilitiesClaimsAssets,
-                                                           Collection<ClearingCategory> clearingCategory) {
-            List<PaymentInstruction> list = super.createPaymentInstructions(executionDeposit, liabilitiesClaimsAssets, clearingCategory);
-            return list.stream().findFirst().orElseGet(PaymentInstruction::new);
-        }
-    }
-}

clearing-parent/company-service/src/test/java/ru/spcex/clearing/company/service/CompanyServiceTest.java

@@ -7,6 +7,7 @@ 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.kafka.core.KafkaTemplate;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.company.ClearingMemberCategory;
@@ -40,6 +41,7 @@ import java.util.Map;
 import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
 import static ru.spcex.clearing.test.TestUtils.*;
 import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -75,9 +77,15 @@ class CompanyServiceTest {
     @Qualifier("mockProducer")
     protected Producer<String, Object> mockProducer;
 
+    @Autowired
+    @Qualifier("kafkaTestTemplate")
+    protected KafkaTemplate<String, Object> kafkaTemplate;
+
     @PostConstruct
     private void init() {
         waitAvailableImdgProviderAndAddAdminWithDefaultId();
+        setMockFuture(mockProducer);
+        setMockFuture(kafkaTemplate);
         companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         companySymbolsImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
 

clearing-parent/company-service/src/test/java/ru/spcex/clearing/company/service/RelationServiceTest.java

@@ -157,7 +157,7 @@ class RelationServiceTest {
         existsRelation.setComment("Test ONE");
         existsRelation.setServiceStatus("ACTV");
         existsRelation.setServiceProduct("PROD");
-        existsRelation.setService("MKR");
+//        existsRelation.setService("MKR");
         relationMap.insert(existsRelation);
 
         Relation predictableRelation = new Relation();
@@ -167,7 +167,7 @@ class RelationServiceTest {
         predictableRelation.setComment("Another Me - ONE");
         predictableRelation.setServiceStatus("ACTV");
         predictableRelation.setServiceProduct("PROD");
-        predictableRelation.setService("MKR");
+//        predictableRelation.setService("MKR");
 
         RelationUpdateRequest relationUpdateRequest = new RelationUpdateRequest();
         relationUpdateRequest.setId(RELATION_ID);

clearing-parent/dbf-exporter/pom.xml

@@ -96,6 +96,23 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>1.2.0-M1</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>5.2.0-M1</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
     </build>
 

clearing-parent/dbf-exporter/src/main/java/ru/spcex/clearing/dbf/exporter/logic/data/enums/FilenameTemplate.java

@@ -6,10 +6,8 @@ import org.springframework.integration.sftp.session.SftpFileInfo;
 import ru.spcex.clearing.dbf.exporter.logic.data.ResultContainer;
 
 import java.io.File;
-import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 
@@ -124,7 +122,7 @@ public enum FilenameTemplate {
         return res;
     }
 
-    private static final DateTimeFormatter tsFormatter = DateTimeFormatter.ofPattern("yyMMddHHmm");
+    public static final DateTimeFormatter tsFormatter = DateTimeFormatter.ofPattern("yyMMddHHmm");
     private static final DateTimeFormatter utilFormatter = DateTimeFormatter.ofPattern("yyMMdd");
 
     public String getFileName(ResultContainer resultContainer, List<SftpFileInfo> files) {

clearing-parent/dbf-exporter/src/test/java/ru/spcex/clearing/dbf/exporter/logic/data/enums/FilenameTemplateTest.java

@@ -13,13 +13,15 @@ import java.util.List;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.*;
 import static ru.spcex.clearing.dbf.exporter.logic.data.enums.FilenameTemplate.df_section_sameName;
+import static ru.spcex.clearing.dbf.exporter.logic.data.enums.FilenameTemplate.tsFormatter;
 
 class FilenameTemplateTest {
 
     @Test
     void countSameFilesInDir() {
         LsEntry lsEntry = mock(LsEntry.class);
-        doReturn("DF-02_S_PRC2305191321_1.DBF").when(lsEntry).getFilename();
+        String name = "DF-02_S_PRC%s_1.DBF".formatted(tsFormatter.format(LocalDateTime.now()));
+        doReturn(name).when(lsEntry).getFilename();
         SftpFileInfo sftpFileInfo = spy(new SftpFileInfo(lsEntry));
         doReturn(false).when(sftpFileInfo).isDirectory();
         List<SftpFileInfo> files = List.of(sftpFileInfo);

clearing-parent/dbf-importer/pom.xml

@@ -122,6 +122,23 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>1.2.0-M1</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>5.2.0-M1</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
 
     </build>

clearing-parent/reports-service/pom.xml

@@ -133,6 +133,23 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>1.2.0-M1</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>5.2.0-M1</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
     </build>
 

clearing-parent/swt-exporter/src/test/java/ru/spcex/clearing/swt/exporter/AbstractServiceTest.java

@@ -24,6 +24,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 
 import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
 import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
+import static ru.spcex.clearing.test.config.KafkaTestConfig.setMockFuture;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
@@ -62,6 +63,7 @@ public abstract class AbstractServiceTest {
 
     protected void init() {
         waitAvailableImdgProviderAndAddAdminWithDefaultId();
+        setMockFuture(kafkaTemplate);
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
     }

clearing-parent/swt-exporter/src/test/java/ru/spcex/clearing/swt/exporter/services/exportimpl/DF09ExporterTest.java

@@ -12,11 +12,11 @@ import ru.spcex.platform.utils.time.TimeUtil;
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
 import java.time.LocalDate;
-import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.Collection;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class DF09ExporterTest {
 
@@ -70,9 +70,9 @@ class DF09ExporterTest {
                 "From:SPCE\r\n" +
                 "Type:009\r\n" +
                 "Date/Time:XXXX\r\n" +
-                ":18A:2\r\n" +
                 ":20:XXXX\r\n" +
                 ":21:test2\r\n" +
+                ":18A:2\r\n" +
                 "test3:4567:test5:test6:test7\r\n" +
                 "DEPO:450:SECCODE:SPB:OK\r\n" +
                 "5017", out);

clearing-parent/swt-importer/pom.xml

@@ -114,6 +114,23 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>1.2.0-M1</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>5.2.0-M1</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
 
     </build>

clearing-parent/test-clearing/src/main/java/ru/spcex/clearing/test/config/KafkaTestConfig.java

@@ -1,5 +1,6 @@
 package ru.spcex.clearing.test.config;
 
+import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.MockConsumer;
 import org.apache.kafka.clients.consumer.OffsetResetStrategy;
@@ -158,6 +159,11 @@ public class KafkaTestConfig {
                 .build();
     }
 
+    @Bean("kafkaConsumerGateway")
+    public Supplier<Consumer<String, Object>> getwaySessionConsumer() {
+        return () -> new MockConsumer<>(OffsetResetStrategy.EARLIEST);
+    }
+
     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
     @Bean
     public MockConsumer<String, Object> createTestConsumer() {