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

Поправил существующий серис, валидаторы, тесты для plannerTemplate .

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerTemplateValidationConfig.java

@@ -74,6 +74,7 @@ public class PlannerTemplateValidationConfig {
             Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
             addImdg.accept(IMDGDistributedNames.Map_TaskDictionary);
             addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_PlannerTemplate);
             addImdg.accept(IMDGDistributedNames.Map_Company);
             addImdg.accept(IMDGDistributedNames.Map_Security);
             return new ValidatorImpl<>(context,
@@ -83,27 +84,27 @@ public class PlannerTemplateValidationConfig {
                             PlannerTemplate.class,
                             ValidationError.RecordNotFound),
                     DictionaryPresentRule.instance("task",
-                            PlannerTemplateNewRequest::getTask,
+                            PlannerTemplateUpdateRequest::getTask,
                             IMDGDistributedNames.Map_TaskDictionary,
                             TaskDictionary.class,
                             false),
                     TimeNotBeforeRule.instance("taskTime",
-                            PlannerTemplateNewRequest::getTaskTime,
+                            PlannerTemplateUpdateRequest::getTaskTime,
                             false),
                     DictionaryPresentRule.instance("taskStatus",
-                            PlannerTemplateNewRequest::getTaskStatus,
+                            PlannerTemplateUpdateRequest::getTaskStatus,
                             IMDGDistributedNames.Map_TaskStatusDictionary,
                             TaskStatusDictionary.class,
                             false),
                     IdPresentRule.instance("companyId",
-                            PlannerTemplateNewRequest::getCompanyId,
+                            PlannerTemplateUpdateRequest::getCompanyId,
                             IMDGDistributedNames.Map_Company,
                             Company.class,
                             ValidationError.CompanyNotFound,
                             false,
                             company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
                     IdPresentRule.instance("securityId",
-                            PlannerTemplateNewRequest::getSecurityId,
+                            PlannerTemplateUpdateRequest::getSecurityId,
                             IMDGDistributedNames.Map_Security,
                             Security.class,
                             ValidationError.SecurityNotFound,
@@ -115,10 +116,12 @@ public class PlannerTemplateValidationConfig {
 
 
     @Bean("plannerTemplateDeleteRequestValidator")
-    public Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidator() {
+    public Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
         return plannerTemplateDeleteRequest -> {
             ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
             context.setValidatedObject(plannerTemplateDeleteRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_PlannerTemplate);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("id",
                             CommonDeleteRequest::getId,

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/service/PlannerService.java

@@ -9,6 +9,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.scheduler.Planner;
+import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
@@ -17,19 +18,28 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewReques
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.scheduler.PlannerAllTodayBuilder;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.platform.enumeration.Status;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.Map;
 import java.util.function.Function;
 
 @Service
 public class PlannerService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<Planner> plannerMap;
+    private final Imdg<PlannerAllToday> plannerAllTodayMap;
+
     private final IMessageResolver messageResolver;
+    private final UserRoleVerification userRoleVerification;
     private final Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidation;
     private final Function<PlannerNewRequest, IValidator> plannerNewRequestValidation;
     private final Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidation;
@@ -39,12 +49,15 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
                           Producer<String, Object> kafkaProducer,
                           ImdgProvider imdgProvider,
                           IMessageResolver messageResolver,
+                          @Qualifier("userRoleVerificationBean") UserRoleVerification userRoleVerification,
                           @Qualifier("plannerDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> plannerDeleteRequestValidator,
                           @Qualifier("plannerNewRequestValidator") Function<PlannerNewRequest, IValidator> plannerNewRequestValidator,
                           @Qualifier("plannerUpdateRequestValidator") Function<PlannerUpdateRequest, IValidator> plannerUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.plannerMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
+        this.plannerAllTodayMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class);
         this.messageResolver = messageResolver;
+        this.userRoleVerification = userRoleVerification;
         this.plannerDeleteRequestValidation = plannerDeleteRequestValidator;
         this.plannerNewRequestValidation = plannerNewRequestValidator;
         this.plannerUpdateRequestValidation = plannerUpdateRequestValidator;
@@ -53,24 +66,30 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
     @Override
     public void afterPropertiesSet() {
         callback(PlannerNewRequest.class)
-                .setFunction(this::newScheduler)
+                .setFunction(this::newPlanner)
                 .forDestination(Consts.DESTINATION_PLANNER_NEW, callbacks::put);
         callback(PlannerUpdateRequest.class)
-                .setFunction(this::updateScheduler)
+                .setFunction(this::updatePlanner)
                 .forDestination(Consts.DESTINATION_PLANNER_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setFunction(this::deleteScheduler)
+                .setFunction(this::deletePlanner)
                 .forDestination(Consts.DESTINATION_PLANNER_DELETE, callbacks::put);
         init();
     }
 
-    private RequestInfoUpdate newScheduler(BaseRequest<PlannerNewRequest> userRequest) {
+    private RequestInfoUpdate newPlanner(BaseRequest<PlannerNewRequest> userRequest) {
         PlannerNewRequest req = userRequest.getRequestPayload();
         log.debug("PlannerNewRequest received");
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerNewRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, plannerNewRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
+        Instant created = Instant.now();
         Planner planner = new Planner();
-        planner.setCreated(Instant.now());
+        planner.setCreated(created);
+        planner.setUpdated(created);
         planner.setTask(req.getTask());
         planner.setTaskTime(req.getTaskTime());
         planner.setClearingDate(req.getClearingDate());
@@ -79,15 +98,23 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
         planner.setCompanyId(req.getCompanyId());
         planner.setSecurityId(req.getSecurityId());
         plannerMap.insert(planner);
+        LocalDate currentDate = LocalDate.now();
+        if (req.getClearingDate() != null && currentDate.equals(req.getClearingDate()) && planner.getTaskStatus() != null) {
+            cudPlannerAllToday(planner);
+        }
         log.debug("successfully processed, new id {}", planner.getId());
         return null;
     }
 
-    private RequestInfoUpdate updateScheduler(BaseRequest<PlannerUpdateRequest> userRequest) {
+    private RequestInfoUpdate updatePlanner(BaseRequest<PlannerUpdateRequest> userRequest) {
         PlannerUpdateRequest req = userRequest.getRequestPayload();
         log.debug("PlannerUpdateRequest received id = {}", req.getId());
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerUpdateRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, plannerUpdateRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
         Planner planner = plannerMap.getSingleObjectByID(req.getId());
         planner.setUpdated(Instant.now());
         planner.setTask(req.getTask());
@@ -98,17 +125,44 @@ public class PlannerService extends QueueConsumer implements InitializingBean {
         planner.setCompanyId(req.getCompanyId());
         planner.setSecurityId(req.getSecurityId());
         plannerMap.update(planner);
+        LocalDate currentDate = LocalDate.now();
+        if (req.getClearingDate() != null && currentDate.equals(req.getClearingDate()) && planner.getTaskStatus() != null) {
+            cudPlannerAllToday(planner);
+        }
         return null;
     }
 
-    private RequestInfoUpdate deleteScheduler(BaseRequest<CommonDeleteRequest> userRequest) {
+    private RequestInfoUpdate deletePlanner(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, plannerDeleteRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, plannerDeleteRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
         Planner planner = plannerMap.getSingleObjectByID(req.getId());
         plannerMap.delete(planner);
+        Collection<PlannerAllToday> values = plannerAllTodayMap.getCollectionObjectsBySQL(String.format("parentId = %s", planner.getId()));
+        values.forEach(plannerAllTodayMap::delete);
         return null;
     }
 
+    public void cudPlannerAllToday(Planner planner) {
+        if (planner.getTaskStatus().equalsIgnoreCase(Status.Active.getKey())) {
+            PlannerAllToday plannerAllToday = PlannerAllTodayBuilder.builder().append(planner).build();
+            PlannerAllToday allToday = plannerAllTodayMap.getSingleObjectBySQL(String.format("parentId = %s", planner.getId()));
+            if (allToday != null) plannerAllToday.setId(allToday.getId());
+            plannerAllTodayMap.insert(plannerAllToday);
+        }
+
+        if (planner.getTaskStatus().equalsIgnoreCase(Status.Cancel.getKey()) || planner.getTaskStatus().equalsIgnoreCase(Status.Blocked.getKey())) {
+            Collection<PlannerAllToday> values = plannerAllTodayMap.getCollectionObjectsByFieldValues(Map.of(
+                    "task", planner.getTask(),
+                    "taskTime", planner.getTaskTime(),
+                    "securityId", planner.getSecurityId(),
+                    "companyId", planner.getCompanyId()));
+            values.forEach(plannerAllTodayMap::delete);
+        }
+    }
 }

clearing-parent/scheduler-service/src/test/java/ru/specx/clearing/scheduler/service/PlannerTemplateServiceTest.java

@@ -1,206 +1,134 @@
 package ru.specx.clearing.scheduler.service;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.hazelcast.core.IMap;
-import com.hazelcast.map.listener.EntryRemovedListener;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.MockConsumer;
-import org.apache.kafka.clients.consumer.OffsetResetStrategy;
-import org.apache.kafka.clients.producer.MockProducer;
-import org.apache.kafka.common.TopicPartition;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
 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 ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.junit.jupiter.SpringExtension;
-import ru.clearing.classes.statics.data.company.Company;
-import ru.clearing.classes.statics.data.profile.Contact;
 import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
-import ru.clearing.classes.statics.data.security.Security;
-import ru.clearing.platform.dictionary.TaskDictionary;
-import ru.clearing.platform.dictionary.TaskStatusDictionary;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerTemplateUpdateRequest;
-import ru.spcex.clearing.scheduler.config.validation.PlannerTemplateValidationConfig;
+import ru.spcex.clearing.scheduler.PlannerAllTodayBuilder;
-import ru.spcex.clearing.scheduler.config.validation.ValidationConfig;
 import ru.spcex.clearing.scheduler.service.PlannerTemplateService;
-import ru.spcex.platform.enumeration.Status;
+import ru.spcex.clearing.test.MatcherFactory;
-import ru.spcex.platform.enumeration.Task;
+import ru.specx.clearing.scheduler.AbstractServiceTest;
-import ru.spcex.platform.enumeration.WorkflowStatus;
-import ru.spcex.platform.imdg.api.Imdg;
-import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
-import ru.spcex.platform.utils.enumeration.IMessageResolver;
-import ru.spcex.platform.utils.validation.IValidator;
-import ru.specx.clearing.scheduler.config.HazelcastServiceTestConfiguration;
 
-import java.time.Instant;
+import javax.annotation.PostConstruct;
-import java.time.LocalTime;
-import java.time.temporal.ChronoUnit;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.function.Function;
 
-@ExtendWith(SpringExtension.class)
+import static org.junit.jupiter.api.Assertions.assertNull;
-@ContextConfiguration(classes = {
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
-        HazelcastServiceTestConfiguration.class,
+import static ru.spcex.clearing.test.TestUtils.*;
-        ValidationConfig.class,
+import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
-        PlannerTemplateValidationConfig.class
-})
-class PlannerTemplateServiceTest {
 
+class PlannerTemplateServiceTest extends AbstractServiceTest {
+    protected static final MatcherFactory.Matcher<PlannerTemplate> PLANNER_TEMPLATE_MATCHER = usingIgnoringFieldsComparator("created", "updated");
     private static final int PARTITION = 0;
     private static final String TOPIC_PLANNER_TEMPLATE_NEW = Consts.DESTINATION_PLANNER_TEMPLATE_NEW;
-    private static final Long ID = 0L;
+    private static final String TOPIC_PLANNER_TEMPLATE_UPDATE = Consts.DESTINATION_PLANNER_TEMPLATE_UPDATE;
+    private static final String TOPIC_PLANNER_TEMPLATE_DELETE = Consts.DESTINATION_PLANNER_TEMPLATE_DELETE;
+    private static final Long ID = currentID.getAndIncrement();
 
     @Autowired
-    @Qualifier("hazelcastServiceTest")
+    private PlannerTemplateService plannerTemplateService;
-    private HazelcastService hazelcastServiceTest;
-    private MockConsumer<String, Object> mockConsumer;
-    private MockProducer<String, Object> mockProducer;
 
-    @Autowired
+    @PostConstruct
-    private IMessageResolver messageResolver;
+    public void init() {
-
+        super.init();
-    @Autowired
-    private Function<CommonDeleteRequest, IValidator> plannerTemplateDeleteRequestValidation;
-
-    @Autowired
-    private Function<PlannerTemplateNewRequest, IValidator> plannerTemplateNewRequestValidation;
-
-    @Autowired
-    private Function<PlannerTemplateUpdateRequest, IValidator> plannerTemplateUpdateRequestValidation;
-
-    @BeforeEach
-    void setUp() {
-        mockConsumer = new MockConsumer<>(OffsetResetStrategy.EARLIEST);
-        mockProducer = new MockProducer<>();
     }
 
     /**
-     * {@link PlannerTemplateService#newTimetable(BaseRequest)}(BaseRequest)}<br>
+     * {@link PlannerTemplateService#newPlannerTemplate(BaseRequest)}(BaseRequest)}<br>
      * Тест проверяет создание сущности {@link ru.clearing.classes.statics.data.scheduler.PlannerTemplate} в Hazelcast при передаче из Apache Kafka.<br>
      * Входной запрос {@link PlannerTemplateNewRequest}:<br>
      */
     @Test
     public void newPlannerTemplateInQueue() throws InterruptedException {
-        Task testTask = Task.accountBlock;
-        TaskDictionary taskDictionary = new TaskDictionary();
-        taskDictionary.setId(0L);
-        taskDictionary.setCode(testTask.getKey());
-        Imdg<TaskDictionary> taskDictionaryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class);
-        taskDictionaryImdg.insert(taskDictionary);
-
-        Status testTaskStatus = Status.Active;
-        TaskStatusDictionary taskStatusDictionary = new TaskStatusDictionary();
-        taskStatusDictionary.setId(0L);
-        taskStatusDictionary.setCode(testTaskStatus.getKey());
-        Imdg<TaskStatusDictionary> taskStatusDictionaryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class);
-        taskStatusDictionaryImdg.insert(taskStatusDictionary);
-
-        long testCompanyId = 0L;
-        Company company = new Company();
-        company.setId(testCompanyId);
-        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
-        Imdg<Company> companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-        companyImdg.insert(company);
-
-        long testSecurityId = 0L;
-        Security security = new Security();
-        security.setId(testSecurityId);
-        security.setWorkflowStatus(WorkflowStatus.Active.getKey());
-        Imdg<Security> securityImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Security, Security.class);
-        securityImdg.insert(security);
-
         //ARRANGE
-        Instant created = Instant.now();
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
-        PlannerTemplate plannerTemplate = new PlannerTemplate();
-        plannerTemplate.setTask(testTask.getKey());
-        plannerTemplate.setTaskTime(LocalTime.now().plusHours(1));
-        plannerTemplate.setTaskStatus(testTaskStatus.getKey());
-        plannerTemplate.setCompanyId(testCompanyId);
-        plannerTemplate.setSecurityId(testSecurityId);
 
-        PlannerTemplateNewRequest plannerTemplateNewRequest = new PlannerTemplateNewRequest();
+        PlannerTemplateNewRequest templateNewRequest = new PlannerTemplateNewRequest();
-        plannerTemplateNewRequest.setTask(plannerTemplate.getTask());
+        templateNewRequest.setTask(plannerTemplate.getTask());
-        plannerTemplateNewRequest.setTaskTime(plannerTemplate.getTaskTime());
+        templateNewRequest.setTaskTime(plannerTemplate.getTaskTime());
-        plannerTemplateNewRequest.setTaskStatus(plannerTemplate.getTaskStatus());
+        templateNewRequest.setTaskStatus(plannerTemplate.getTaskStatus());
-        plannerTemplateNewRequest.setCompanyId(plannerTemplate.getCompanyId());
+        templateNewRequest.setCompanyId(plannerTemplate.getCompanyId());
-        plannerTemplateNewRequest.setSecurityId(plannerTemplate.getSecurityId());
+        templateNewRequest.setSecurityId(plannerTemplate.getSecurityId());
-
-        BaseRequest<PlannerTemplateNewRequest> plannerTemplateRequest = new BaseRequest<>();
-        plannerTemplateRequest.setRequestPayload(plannerTemplateNewRequest);
-        plannerTemplateRequest.setId(ID);
-        plannerTemplateRequest.setActionType(ActionType.NEW);
-        String jsonBaseForDeleteRequest;
-        ObjectMapper objectMapper = new ObjectMapper();
-        try {
-            jsonBaseForDeleteRequest = objectMapper.writeValueAsString(plannerTemplateRequest);
-        } catch (JsonProcessingException e) {
-            throw new RuntimeException(e);
-        }
 
         //ACT
-        //service set up
+        String jsonString = getJsonStringForNew(templateNewRequest, ID);
-        PlannerTemplateService plannerTemplateService = new PlannerTemplateService(mockConsumer,
+        addRecordToKafka((MockConsumer) plannerTemplateService.getConsumer(), TOPIC_PLANNER_TEMPLATE_NEW, PARTITION, 0, jsonString);
-                mockProducer,
-                hazelcastServiceTest,
-                messageResolver,
-                plannerTemplateDeleteRequestValidation,
-                plannerTemplateNewRequestValidation,
-                plannerTemplateUpdateRequestValidation);
 
-        //callbacks set up
-        plannerTemplateService.afterPropertiesSet();
-        IMap<Long, PlannerTemplate> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_PlannerTemplate);
-        //KAFKA
-        HashMap<TopicPartition, Long> startOffsetsUpdating = new HashMap<>();
-        TopicPartition topic = new TopicPartition(TOPIC_PLANNER_TEMPLATE_NEW, PARTITION);
-        startOffsetsUpdating.put(topic, 0L);
-        mockConsumer.updateBeginningOffsets(startOffsetsUpdating);
-
-        mockConsumer.schedulePollTask(() -> {
-            mockConsumer.rebalance(Collections.singletonList(new TopicPartition(TOPIC_PLANNER_TEMPLATE_NEW, PARTITION)));
-            mockConsumer.addRecord(new ConsumerRecord<>(TOPIC_PLANNER_TEMPLATE_NEW, PARTITION, 0, "key", jsonBaseForDeleteRequest));
-        });
-
-        //waiting for hazelcast map item removes
-        Object waiter = new Object();
-        String listenerID = iMap.addEntryListener((EntryRemovedListener<Long, Contact>) entryEvent -> {
-            System.out.println("Checking If pushed..");
-
-            try {
-                waiter.wait(100);
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-            synchronized (waiter) {
-                waiter.notify();
-            }
-        }, false);
-
-        synchronized (waiter) {
-            waiter.wait(100);
-        }
-        PlannerTemplate plannerTemplateRes = iMap.get(iMap.keySet().stream().findFirst().get());
         //ASSERT
-        Assertions.assertEquals(1, iMap.size());
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
 
-        Assertions.assertNotNull(plannerTemplateRes.getCreated());
+        PlannerTemplate plannerTemplateRes = plannerTemplateImdg.getSingleObjectBySQL(String.format("companyId = %s", plannerTemplate.getCompanyId()));
-        Assertions.assertEquals(plannerTemplate.getTask(), plannerTemplateRes.getTask());
+        plannerTemplate.setId(plannerTemplateRes.getId());
-        Assertions.assertEquals(plannerTemplate.getTaskTime().truncatedTo(ChronoUnit.SECONDS), plannerTemplateRes.getTaskTime().truncatedTo(ChronoUnit.SECONDS));
+        PLANNER_TEMPLATE_MATCHER.assertMatch(plannerTemplateRes, plannerTemplate);
-        Assertions.assertEquals(plannerTemplate.getTaskStatus(), plannerTemplateRes.getTaskStatus());
+        checkPlannerAllTodayByPlannerTemplate(plannerTemplate);
-        Assertions.assertEquals(plannerTemplate.getCompanyId(), plannerTemplateRes.getCompanyId());
+    }
-        Assertions.assertEquals(plannerTemplate.getSecurityId(), plannerTemplateRes.getSecurityId());
+
-        //preparing hazelcastImdgProvider for next test
+    /**
-        iMap.removeEntryListener(listenerID);
+     * {@link PlannerTemplateService#updatePlannerTemplate(BaseRequest)}(BaseRequest)}<br>
+     * Тест проверяет обновление сущности {@link ru.clearing.classes.statics.data.scheduler.PlannerTemplate} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link PlannerTemplateUpdateRequest}:<br>
+     */
+    @Test
+    public void updatePlannerTemplate() throws InterruptedException {
+        //ARRANGE
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
+        plannerTemplateImdg.insert(plannerTemplate);
+        plannerTemplate.setCompanyId(updateCompanyId);
+
+        PlannerTemplateUpdateRequest plannerTemplateUpdateRequest = new PlannerTemplateUpdateRequest();
+        plannerTemplateUpdateRequest.setId(plannerTemplate.getId());
+        plannerTemplateUpdateRequest.setTask(plannerTemplate.getTask());
+        plannerTemplateUpdateRequest.setTaskTime(plannerTemplate.getTaskTime());
+        plannerTemplateUpdateRequest.setTaskStatus(plannerTemplate.getTaskStatus());
+        plannerTemplateUpdateRequest.setCompanyId(plannerTemplate.getCompanyId());
+        plannerTemplateUpdateRequest.setSecurityId(plannerTemplate.getSecurityId());
+
+        //ACT
+        String jsonString = getJsonStringForUpdate(plannerTemplateUpdateRequest, ID);
+        addRecordToKafka((MockConsumer) plannerTemplateService.getConsumer(), TOPIC_PLANNER_TEMPLATE_UPDATE, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
+
+        PlannerTemplate plannerTemplateRes = plannerTemplateImdg.getSingleObjectBySQL(String.format("companyId = %s", plannerTemplate.getCompanyId()));
+        plannerTemplate.setId(plannerTemplateRes.getId());
+        PLANNER_TEMPLATE_MATCHER.assertMatch(plannerTemplateRes, plannerTemplate);
+        checkPlannerAllTodayByPlannerTemplate(plannerTemplate);
+    }
+
+    /**
+     * {@link PlannerTemplateService#deletePlannerTemplate(BaseRequest)}(BaseRequest)}<br>
+     * Тест проверяет удаление сущности {@link ru.clearing.classes.statics.data.scheduler.PlannerTemplate} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link CommonDeleteRequest}:<br>
+     */
+    @Test
+    public void deletePlannerTemplate() throws InterruptedException {
+        //ARRANGE
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
+        long id = plannerTemplate.getId();
+
+        plannerTemplate.setCompanyId(deleteCompanyId);
+        plannerTemplateImdg.insert(plannerTemplate);
+        plannerAllTodayImdg.insert(PlannerAllTodayBuilder.builder().append(plannerTemplate).build());
+
+        CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
+        commonDeleteRequest.setId(id);
+
+        //ACT
+        String jsonString = getJsonStringForDelete(commonDeleteRequest, id);
+        addRecordToKafka((MockConsumer) plannerTemplateService.getConsumer(), TOPIC_PLANNER_TEMPLATE_DELETE, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(id, mockProducer, producerRecord);
+
+        PlannerTemplate plannerTemplateRes = plannerTemplateImdg.getSingleObjectBySQL(String.format("companyId = %s", plannerTemplate.getCompanyId()));
+        assertNull(plannerTemplateRes);
+        PlannerAllToday plannerAllTodayRes = plannerAllTodayImdg.getSingleObjectBySQL(String.format("companyId = %s", plannerTemplate.getCompanyId()));
+        assertNull(plannerAllTodayRes);
     }
 }