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

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

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

@@ -58,6 +58,7 @@ public class ClearingCalendarValidationConfig {
             ImdgValidationContext<ClearingCalendarUpdateRequest> context = new ImdgValidationContext<>();
             context.setValidatedObject(clearingCalendarUpdateRequest);
             Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_ClearingCalendar);
             addImdg.accept(IMDGDistributedNames.Map_Company);
             addImdg.accept(IMDGDistributedNames.Map_DayStatusDictionary);
             return new ValidatorImpl<>(context,
@@ -83,10 +84,12 @@ public class ClearingCalendarValidationConfig {
     }
 
     @Bean("clearingCalendarDeleteRequestValidator")
-    public Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidator() {
+    public Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidator(Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation) {
         return clearingCalendarDeleteRequest -> {
             ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
             context.setValidatedObject(clearingCalendarDeleteRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_ClearingCalendar);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("id",
                             CommonDeleteRequest::getId,

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

@@ -9,6 +9,9 @@ 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.ClearingCalendar;
+import ru.clearing.classes.statics.data.scheduler.Planner;
+import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
+import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
@@ -17,19 +20,36 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendar
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarUpdateRequest;
 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.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.DayStatus;
+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.DayOfWeek;
 import java.time.Instant;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 import java.util.function.Function;
 
+import static ru.spcex.clearing.scheduler.ISchedulerChecker.isValidWorkday;
+
 @Service
 public class ClearingCalendarService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<ClearingCalendar> clearingCalendarMap;
+    private final Imdg<PlannerTemplate> plannerTemplateMap;
+    private final Imdg<PlannerAllToday> plannerAllTodayMap;
+    private final Imdg<Planner> plannerMap;
     private final IMessageResolver messageResolver;
+    private final UserRoleVerification userRoleVerification;
     private final Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidation;
     private final Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidation;
     private final Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidation;
@@ -38,11 +58,16 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
     public ClearingCalendarService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer,
                                    ImdgProvider imdgProvider,
                                    IMessageResolver messageResolver,
+                                   @Qualifier("userRoleVerificationBean") UserRoleVerification userRoleVerification,
                                    @Qualifier("clearingCalendarDeleteRequestValidator") Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidator,
                                    @Qualifier("clearingCalendarNewRequestValidator") Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidator,
                                    @Qualifier("clearingCalendarUpdateRequestValidator") Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.clearingCalendarMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingCalendar, ClearingCalendar.class);
+        this.plannerTemplateMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerTemplate, PlannerTemplate.class);
+        this.plannerMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
+        this.plannerAllTodayMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class);
+        this.userRoleVerification = userRoleVerification;
         this.clearingCalendarDeleteRequestValidation = clearingCalendarDeleteRequestValidator;
         this.clearingCalendarNewRequestValidation = clearingCalendarNewRequestValidator;
         this.clearingCalendarUpdateRequestValidation = clearingCalendarUpdateRequestValidator;
@@ -66,24 +91,35 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
     private RequestInfoUpdate newClearingCalendar(BaseRequest<ClearingCalendarNewRequest> userRequest) {
         ClearingCalendarNewRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarNewRequest received");
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarNewRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, clearingCalendarNewRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
         ClearingCalendar clearingCalendar = new ClearingCalendar();
         Instant created = Instant.now();
         clearingCalendar.setCreated(created);
+        clearingCalendar.setUpdated(created);
         clearingCalendar.setClearingDate(req.getClearingDate());
         clearingCalendar.setCompanyId(req.getCompanyId());
         clearingCalendar.setDayStatus(req.getDayStatus());
         clearingCalendarMap.insert(clearingCalendar);
         log.debug("successfully processed, new id {}", clearingCalendar.getId());
+        //если clearingCalendar.getClearingDate() сегодняшний день необходимо проверить/добавить plannerTemplate
+        updateFromPlannerAllTodayMap(clearingCalendar);
         return null;
     }
 
     private RequestInfoUpdate updateClearingCalendar(BaseRequest<ClearingCalendarUpdateRequest> userRequest) {
         ClearingCalendarUpdateRequest req = userRequest.getRequestPayload();
         log.debug("ClearingCalendarUpdateRequest received");
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarUpdateRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, clearingCalendarUpdateRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
         Instant updated = Instant.now();
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
         clearingCalendar.setClearingDate(req.getClearingDate());
@@ -92,16 +128,63 @@ public class ClearingCalendarService extends QueueConsumer implements Initializi
         clearingCalendar.setUpdated(updated);
         clearingCalendarMap.update(clearingCalendar);
         log.debug("successfully processed, new id {}", clearingCalendar.getId());
+        //если clearingCalendar.getClearingDate() сегодняшний день необходимо проверить/добавить plannerTemplate
+        updateFromPlannerAllTodayMap(clearingCalendar);
         return null;
     }
 
     private RequestInfoUpdate deleteClearingCalendar(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
-        RequestInfoUpdate requestInfoUpdate = validate(userRequest, clearingCalendarDeleteRequestValidation, messageResolver);
+
+        RequestInfoUpdate requestInfoUpdate = userRoleVerification.validateRoleAndGetResult(userRequest);
         if (requestInfoUpdate != null) return requestInfoUpdate;
+        requestInfoUpdate = validate(userRequest, clearingCalendarDeleteRequestValidation, messageResolver);
+        if (requestInfoUpdate != null) return requestInfoUpdate;
+
         log.debug("CommonDeleteRequest received id = {}", req.getId());
         ClearingCalendar clearingCalendar = clearingCalendarMap.getSingleObjectByID(req.getId());
+
         clearingCalendarMap.delete(clearingCalendar);
+        deleteFromPlannerAllTodayMap();
         return null;
     }
+
+    private void updateFromPlannerAllTodayMap(ClearingCalendar clearingCalendar) {
+        LocalDate currentDate = LocalDate.now();
+        if (clearingCalendar.getClearingDate() == null || !clearingCalendar.getClearingDate().equals(currentDate))
+            return;
+        boolean isWeekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
+        if (isValidWorkday(clearingCalendar, isWeekend)) {
+            for (PlannerTemplate plannerTemplate : plannerTemplateMap.getAllValues()) {
+                PlannerAllToday plannerAllToday = plannerAllTodayMap.getSingleObjectBySQL(String.format("parentId = %s", plannerTemplate.getId()));
+                if (plannerAllToday == null)
+                    plannerAllTodayMap.insert(PlannerAllTodayBuilder.builder().append(plannerTemplate).build());
+            }
+        }
+    }
+
+    public void deleteFromPlannerAllTodayMap() {
+        LocalDate currentDate = LocalDate.now();
+        boolean isWeekend = Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(currentDate.getDayOfWeek());
+        //проверим есть ли другие записи clearingCalendar с таким же clearingDate, если они актуальные ничего не удаляем
+        Collection<ClearingCalendar> clearingCalendars = clearingCalendarMap.getCollectionObjectsByFieldValues(Map.of("dayStatus", DayStatus.Workday.getKey(),
+                "clearingDate", currentDate));
+        if (clearingCalendars != null && !clearingCalendars.isEmpty()) {
+            for (ClearingCalendar calendar : clearingCalendars) {
+                //если будет хоть один валидные ClearingCalendar на сегодня на основании которого(и plannerTemplate -ов) могли быть созданы PlannerAllToday
+                //ничего проверять\удалять дальше не будем
+                if (isValidWorkday(calendar, isWeekend)) return;
+            }
+        }
+        //удалим все PlannerAllToday созданные на основании plannerTemplate кроме созданных на основании planner
+        List<Long> plannerIds = plannerMap.getCollectionObjectsByFieldValues(Map.of("taskStatus", Status.Active.getKey(),
+                        "clearingDate", currentDate)).stream()
+                .mapToLong(SpcexObjectBase::getId)
+                .boxed().toList();
+
+        Collection<PlannerAllToday> values = plannerAllTodayMap.getAllValues().stream()
+                .filter(plannerAllToday -> !plannerIds.contains(plannerAllToday.getParentId())).toList();
+
+        values.forEach(plannerAllTodayMap::delete);
+    }
 }

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

@@ -1,192 +1,198 @@
 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 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.ClearingCalendar;
-import ru.clearing.platform.dictionary.DayStatusDictionary;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.clearing.classes.statics.data.scheduler.Planner;
+import ru.clearing.classes.statics.data.scheduler.PlannerAllToday;
+import ru.clearing.classes.statics.data.scheduler.PlannerTemplate;
 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.ClearingCalendarNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.ClearingCalendarUpdateRequest;
-import ru.spcex.clearing.scheduler.config.validation.ClearingCalendarValidationConfig;
-import ru.spcex.clearing.scheduler.config.validation.ValidationConfig;
+import ru.spcex.clearing.scheduler.PlannerAllTodayBuilder;
 import ru.spcex.clearing.scheduler.service.ClearingCalendarService;
+import ru.spcex.clearing.test.MatcherFactory;
 import ru.spcex.platform.enumeration.DayStatus;
-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 ru.spcex.platform.enumeration.Status;
+import ru.specx.clearing.scheduler.AbstractServiceTest;
 
-import java.time.Instant;
+import javax.annotation.PostConstruct;
 import java.time.LocalDate;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.function.Function;
 
-@ExtendWith(SpringExtension.class)
-@ContextConfiguration(classes = {
-        HazelcastServiceTestConfiguration.class,
-        ValidationConfig.class,
-        ClearingCalendarValidationConfig.class
-})
-class ClearingCalendarServiceTest {
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static ru.spcex.clearing.test.MatcherFactory.usingIgnoringFieldsComparator;
+import static ru.spcex.clearing.test.TestUtils.*;
+import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
 
+class ClearingCalendarServiceTest extends AbstractServiceTest {
+    protected static final MatcherFactory.Matcher<ClearingCalendar> CLEARING_CALENDAR_MATCHER = usingIgnoringFieldsComparator("created", "updated");
     private static final int PARTITION = 0;
     private static final String TOPIC_CLEARING_CALENDAR_NEW = Consts.DESTINATION_CLEARING_CALENDAR_NEW;
-    private static final Long ID = 0L;
+    private static final String TOPIC_CLEARING_CALENDAR_UPDATE = Consts.DESTINATION_CLEARING_CALENDAR_UPDATE;
+    private static final String TOPIC_CLEARING_CALENDAR_DELETE = Consts.DESTINATION_CLEARING_CALENDAR_DELETE;
+    private static final Long ID = currentID.getAndIncrement();
 
     @Autowired
-    @Qualifier("hazelcastServiceTest")
-    private HazelcastService hazelcastServiceTest;
-    private MockConsumer<String, Object> mockConsumer;
-    private MockProducer<String, Object> mockProducer;
+    ClearingCalendarService clearingCalendarService;
 
-    @Autowired
-    private IMessageResolver messageResolver;
-
-    @Autowired
-    private Function<CommonDeleteRequest, IValidator> clearingCalendarDeleteRequestValidation;
-
-    @Autowired
-    private Function<ClearingCalendarNewRequest, IValidator> clearingCalendarNewRequestValidation;
-
-    @Autowired
-    private Function<ClearingCalendarUpdateRequest, IValidator> clearingCalendarUpdateRequestValidation;
+    @PostConstruct
+    public void init() {
+        super.init();
+    }
 
     @BeforeEach
-    void setUp() {
-        mockConsumer = new MockConsumer<>(OffsetResetStrategy.EARLIEST);
-        mockProducer = new MockProducer<>();
+    public void prepare() {
+        clearAllInImdg(plannerTemplateImdg);
+        clearAllInImdg(plannerAllTodayImdg);
     }
 
     /**
-     * {@link ClearingCalendarService#newTradingCalendar(BaseRequest)}(BaseRequest)}<br>
+     * {@link ClearingCalendarService#newClearingCalendar(BaseRequest)}(BaseRequest)}<br>
      * Тест проверяет создание сущности {@link ClearingCalendar} в Hazelcast при передаче из Apache Kafka.<br>
      * Входной запрос {@link ClearingCalendarNewRequest}:<br>
      */
     @Test
-    public void newClearingCalendarInQueue() throws InterruptedException {
-        // Prepare test objects
-        hazelcastServiceTest.waitAvailable();
-        Company company = new Company();
-        company.setId(0L);
-        company.setWorkflowStatus(WorkflowStatus.Active.getKey());
-        Imdg<Company> companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-        companyImdg.insert(company);
-
-        DayStatus dayStatus = DayStatus.Workday;
-        DayStatusDictionary dayStatusDictionary = new DayStatusDictionary();
-        dayStatusDictionary.setId(0L);
-        dayStatusDictionary.setCode(dayStatus.getKey());
-        Imdg<DayStatusDictionary> dayStatusDictionaryImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class);
-        dayStatusDictionaryImdg.insert(dayStatusDictionary);
-
+    public void newClearingCalendar() {
         //ARRANGE
         ClearingCalendar clearingCalendar = new ClearingCalendar();
-        Instant created = Instant.now();
-        clearingCalendar.setCreated(created);
-        clearingCalendar.setClearingDate(LocalDate.now().plusDays(1));
-        clearingCalendar.setCompanyId(0L);
+        clearingCalendar.setClearingDate(LocalDate.now());
+        clearingCalendar.setCompanyId(newCompanyId);
         clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
+        plannerTemplateImdg.insert(plannerTemplate);
 
         ClearingCalendarNewRequest clearingCalendarNewRequest = new ClearingCalendarNewRequest();
         clearingCalendarNewRequest.setClearingDate(clearingCalendar.getClearingDate());
         clearingCalendarNewRequest.setCompanyId(clearingCalendar.getCompanyId());
         clearingCalendarNewRequest.setDayStatus(clearingCalendar.getDayStatus());
 
-        BaseRequest<ClearingCalendarNewRequest> baseNewRequest = new BaseRequest<>();
-        baseNewRequest.setRequestPayload(clearingCalendarNewRequest);
-        baseNewRequest.setId(ID);
-        baseNewRequest.setActionType(ActionType.NEW);
-        String jsonBaseForRequest;
-        ObjectMapper objectMapper = new ObjectMapper();
-        try {
-            jsonBaseForRequest = objectMapper.writeValueAsString(baseNewRequest);
-        } catch (JsonProcessingException e) {
-            throw new RuntimeException(e);
-        }
+        //ACT
+        String jsonString = getJsonStringForNew(clearingCalendarNewRequest, ID);
+        addRecordToKafka((MockConsumer) clearingCalendarService.getConsumer(), TOPIC_CLEARING_CALENDAR_NEW, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
+
+        ClearingCalendar clearingCalendarRes = clearingCalendarImdg.getSingleObjectBySQL(String.format("companyId = %s", clearingCalendar.getCompanyId()));
+        clearingCalendar.setId(clearingCalendarRes.getId());
+        CLEARING_CALENDAR_MATCHER.assertMatch(clearingCalendarRes, clearingCalendar);
+        checkPlannerAllTodayByPlannerTemplate(plannerTemplate);
+    }
+
+    /**
+     * {@link ClearingCalendarService#updateClearingCalendar(BaseRequest)}(BaseRequest)}<br>
+     * Тест проверяет создание сущности {@link ClearingCalendar} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link ClearingCalendarUpdateRequest}:<br>
+     */
+    @Test
+    public void updateClearingCalendar() {
+        //ARRANGE
+        ClearingCalendar clearingCalendar = new ClearingCalendar();
+        clearingCalendar.setId(currentID.getAndIncrement());
+        clearingCalendar.setClearingDate(LocalDate.now());
+        clearingCalendar.setCompanyId(newCompanyId);
+        clearingCalendar.setDayStatus(DayStatus.Workday.getKey());
+        clearingCalendarImdg.insert(clearingCalendar);
+        clearingCalendar.setCompanyId(updateCompanyId);
+
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
+        plannerTemplateImdg.insert(plannerTemplate);
+
+        ClearingCalendarUpdateRequest clearingCalendarNewRequest = new ClearingCalendarUpdateRequest();
+        clearingCalendarNewRequest.setId(clearingCalendar.getId());
+        clearingCalendarNewRequest.setClearingDate(clearingCalendar.getClearingDate());
+        clearingCalendarNewRequest.setCompanyId(clearingCalendar.getCompanyId());
+        clearingCalendarNewRequest.setDayStatus(clearingCalendar.getDayStatus());
 
         //ACT
-        //service set up
-        ClearingCalendarService clearingCalendarService = new ClearingCalendarService(mockConsumer,
-                mockProducer,
-                hazelcastServiceTest,
-                messageResolver,
-                clearingCalendarDeleteRequestValidation,
-                clearingCalendarNewRequestValidation,
-                clearingCalendarUpdateRequestValidation);
+        String jsonString = getJsonStringForUpdate(clearingCalendarNewRequest, ID);
+        addRecordToKafka((MockConsumer) clearingCalendarService.getConsumer(), TOPIC_CLEARING_CALENDAR_UPDATE, PARTITION, 0, jsonString);
 
-        //callbacks set up
-        clearingCalendarService.afterPropertiesSet();
-
-        BaseRequest<ClearingCalendarNewRequest> baseRequest = new BaseRequest<>();
-        baseRequest.setId(1L);
-        baseRequest.setActionType(ActionType.NEW);
-        ClearingCalendarNewRequest newRequest = new ClearingCalendarNewRequest();
-        baseRequest.setRequestPayload(newRequest);
-
-        IMap<Long, ClearingCalendar> iMap = hazelcastServiceTest.getHazelcast().getMap(IMDGDistributedNames.Map_ClearingCalendar);
-        //KAFKA
-        HashMap<TopicPartition, Long> startOffsetsUpdating = new HashMap<>();
-        TopicPartition topic = new TopicPartition(TOPIC_CLEARING_CALENDAR_NEW, PARTITION);
-        startOffsetsUpdating.put(topic, 0L);
-        mockConsumer.updateBeginningOffsets(startOffsetsUpdating);
-
-        mockConsumer.schedulePollTask(() -> {
-            mockConsumer.rebalance(Collections.singletonList(new TopicPartition(TOPIC_CLEARING_CALENDAR_NEW, PARTITION)));
-            mockConsumer.addRecord(new ConsumerRecord<>(TOPIC_CLEARING_CALENDAR_NEW, PARTITION, 0, "key", jsonBaseForRequest));
-        });
-
-        //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);
-        }
-        ClearingCalendar clearingCalendarRes = iMap.get(iMap.keySet().stream().findFirst().get());
         //ASSERT
-        Assertions.assertEquals(1, iMap.size());
+        waitingWhenAddedRecordAndCheckIt(ID, mockProducer, producerRecord);
 
-        Assertions.assertNotNull(clearingCalendarRes.getCreated());
-        Assertions.assertEquals(clearingCalendar.getClearingDate(), clearingCalendarRes.getClearingDate());
-        Assertions.assertEquals(clearingCalendar.getCompanyId(), clearingCalendarRes.getCompanyId());
-        Assertions.assertEquals(clearingCalendar.getDayStatus(), clearingCalendarRes.getDayStatus());
+        ClearingCalendar clearingCalendarRes = clearingCalendarImdg.getSingleObjectBySQL(String.format("companyId = %s", clearingCalendar.getCompanyId()));
+        clearingCalendar.setId(clearingCalendarRes.getId());
+        CLEARING_CALENDAR_MATCHER.assertMatch(clearingCalendarRes, clearingCalendar);
+        checkPlannerAllTodayByPlannerTemplate(plannerTemplate);
+    }
 
-        //preparing hazelcastImdgProvider for next test
-        iMap.removeEntryListener(listenerID);
+
+    /**
+     * {@link ClearingCalendarService#deleteClearingCalendar(BaseRequest)}(BaseRequest)}<br>
+     * Тест проверяет удаление сущности {@link ru.clearing.classes.statics.data.scheduler.ClearingCalendar} в Hazelcast при передаче из Apache Kafka.<br>
+     * Входной запрос {@link CommonDeleteRequest}:<br>
+     */
+    @Test
+    public void deleteClearingCalendar() {
+        //ARRANGE
+        clearAllInImdg(clearingCalendarImdg);
+        ClearingCalendar clearingCalendar = getClearingCalendar();
+        clearingCalendarImdg.insert(clearingCalendar);
+
+        PlannerTemplate plannerTemplate = getPlannerTemplate(newCompanyId);
+        long id = clearingCalendar.getId();
+
+        plannerTemplate.setCompanyId(deleteCompanyId);
+        plannerAllTodayImdg.insert(PlannerAllTodayBuilder.builder().append(plannerTemplate).build());
+
+        CommonDeleteRequest commonDeleteRequest = new CommonDeleteRequest();
+        commonDeleteRequest.setId(id);
+
+        //ACT
+        String jsonString = getJsonStringForDelete(commonDeleteRequest, id);
+        addRecordToKafka((MockConsumer) clearingCalendarService.getConsumer(), TOPIC_CLEARING_CALENDAR_DELETE, PARTITION, 0, jsonString);
+
+        //ASSERT
+        waitingWhenAddedRecordAndCheckIt(id, mockProducer, producerRecord);
+
+        ClearingCalendar plannerTemplateRes = clearingCalendarImdg.getSingleObjectBySQL(String.format("companyId = %s", clearingCalendar.getCompanyId()));
+        assertNull(plannerTemplateRes);
+        PlannerAllToday plannerAllTodayRes = plannerAllTodayImdg.getSingleObjectBySQL(String.format("companyId = %s", plannerTemplate.getCompanyId()));
+        assertNull(plannerAllTodayRes);
+
+        //добавим в clearingCalendarImdg валидный clearingCalendar на случай если тесты plannerTemplate еще не отработали
+        clearingCalendarImdg.insert(clearingCalendar);
+    }
+
+    /**
+     * {@link ClearingCalendarService#deleteFromPlannerAllTodayMap()}}<br>
+     * Тест проверяет удаление сущности {@link ru.clearing.classes.statics.data.scheduler.PlannerAllToday} в Hazelcast.<br>
+     */
+    @Test
+    public void deleteFromPlannerAllTodayMap() {
+        //проверка удаления PlannerAllToday
+        Planner planner = getPlanner(newCompanyId);
+        planner.setId(12L);
+        planner.setTaskStatus(Status.Active.getKey());
+        planner.setCompanyId(newCompanyId);
+        planner.setClearingDate(LocalDate.now());
+        plannerImdg.insert(planner);
+        plannerAllTodayImdg.insert(PlannerAllTodayBuilder.builder().append(planner).build());
+        PlannerTemplate plannerTemplate = new PlannerTemplate();
+        plannerTemplate.setId(13L);
+        plannerTemplate.setCompanyId(updateCompanyId);
+        plannerAllTodayImdg.insert(PlannerAllTodayBuilder.builder().append(plannerTemplate).build());
+
+        //ни чего не должно быть удалено ест валидный clearingCalendar
+        clearingCalendarService.deleteFromPlannerAllTodayMap();
+        assertEquals(2, plannerAllTodayImdg.getAllValues().size());
+        checkPlannerAllTodayByPlanner(planner);
+        checkPlannerAllTodayByPlannerTemplate(plannerTemplate);
+
+        //сейчас удалятся только созданные на основании plannerTemplate
+        clearAllInImdg(clearingCalendarImdg);
+        clearingCalendarService.deleteFromPlannerAllTodayMap();
+
+        checkPlannerAllTodayByPlanner(planner);
+        assertEquals(1, plannerAllTodayImdg.getAllValues().size());
+
+        //добавим в clearingCalendarImdg валидный clearingCalendar на случай если тесты plannerTemplate еще не отработали
+        clearingCalendarImdg.insert(getClearingCalendar());
     }
 }