treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix tests.

Browse source
This commit is contained in:
psemenkov 2023-10-30 15:48:49 +03:00
parent 520233356b
commit 1e09424541
46 changed files with 735 additions and 1182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -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;
}
}

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

@ -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);
}

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

@ -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());
}
}

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

@ -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 {
}

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

@ -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
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 *******
TestConfig.class,
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;
@MockBean
protected MockProducer<String, Object> producer;
@Autowired
@Qualifier("mockProducer")
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();

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

@ -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, "044525776", "", "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", "", "RUB", "destination", "3664011397", "01", "11111222223333344444"));
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", ""));
assertThrowsFor(getBankAccountNewAction(0, null, "Beta Money Bank", "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", "30101111111111111776", "correspondent", null, "destination", "3664011397", "01", "11111222223333344444"));
assertThrowsFor(getBankAccountNewAction(0, "044525776", "Beta Money Bank", "30101111111111111776", "correspondent", "RUB", "destination", "3664011397", "01", null));
}
/**

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

@ -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));
}

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

@ -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);
iMap.put(profileDocument.getId(), profileDocument);
Imdg<Notification> iMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Notification, Notification.class);
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);

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

@ -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);
iMap.put(session.getId(), session);
Imdg<Session> sessionImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Session, Session.class);
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);

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

@ -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);
iMap.put(paymentInstruction.getId(), paymentInstruction);
Imdg<PaymentInstruction> paymentInstructionImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class);
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);

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

@ -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);
iMap.put(taskRunner.getId(), taskRunner);
Imdg<Launcher> iMap = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Launcher, Launcher.class);
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);

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

@ -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);
iMap.put(schedulerAllToday.getId(), schedulerAllToday);
Imdg<PlannerAllToday> plannerAllTodayImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class);
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);

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

@ -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);
iMap.put(scheduler.getId(), scheduler);
Imdg<Planner> plannerImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Planner, Planner.class);
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);

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

@ -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);

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

@ -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.setUserId(currentId.get()); // отдаются по userId CLS-64, todo в тесте null
userSettings.setId(id);
userSettings.setUserId(id); // отдаются по userId CLS-64, todo в тесте null
userSettings.setJson("json");
userSettings.setVersion("version");

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

@ -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(

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

@ -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

5
clearing-parent/balance-service/pom.xml
View file

@ -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>

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

@ -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;
}
}

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

@ -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);
}
}

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

@ -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;

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

@ -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());

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

@ -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);
doReturn(future).when(producer).send(producerRecord.capture());
ArgumentCaptor<ProducerRecord> producerRecord = getCaptor(producer);
Result result = sdf16Executor.execute(Collections.singletonList(sdf16), statementRequest);
BaseRequest<Object> baseRequest = (BaseRequest<Object>) producerRecord.getValue().value();

5
clearing-parent/clearing-service/pom.xml
View file

@ -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>

91
clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/config/ConfigTest.java Normal file
View file

@ -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();
}
}

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

@ -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;
}
}

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

@ -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);
}
}

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

@ -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);
}
}

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

@ -1,54 +1,38 @@
package ru.spcex.clearing.service;
import org.apache.kafka.clients.producer.MockProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.Producer;
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.service.builder.LiabilitiesClaimsMoneyCreator;
import ru.spcex.clearing.service.execution.ExecutionDepositComponent;
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;
import ru.spcex.clearing.test.config.ImdgTestConfig;
import ru.spcex.clearing.test.config.KafkaTestConfig;
import ru.spcex.platform.imdg.api.ImdgProvider;
@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,
HazelcastServiceTestConfiguration.class})
KafkaTestConfig.class,
ImdgTestConfig.class})
public abstract class AbstractClearingTest {
@Autowired
@Qualifier("hazelcastServiceTest")
protected HazelcastService hazelcastServiceTest;
@Captor
protected ArgumentCaptor<ProducerRecord> producerRecord;
@SpyBean
protected MockProducer<String, Object> mockProducer;
protected ImdgProvider hazelcastServiceTest;
@Autowired
@Qualifier("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());
}
}

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

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

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

@ -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))

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

@ -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,
PARTITION, times, getJsonStringForUPDATE(new LauncherCommandRequest(), 1L));
addRecordToKafka((MockConsumer) receiver.getConsumer(), TOPIC_VERIFICATION,
PARTITION, times, getJsonStringForUpdate(new LauncherCommandRequest(), 1L));
ArgumentCaptor<VerificationResult> settingResult = ArgumentCaptor.forClass(VerificationResult.class);
verify(verificationResultImdgMock, timeout(30_000L).times(4 * times))

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

@ -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.utils.TestUtils.getJsonStringForUPDATE;
import static ru.spcex.clearing.test.TestUtils.addRecordToKafka;
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))

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

@ -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);
}
}
}

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

@ -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);
}
}
}

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

@ -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);

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

@ -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);

17
clearing-parent/dbf-exporter/pom.xml
View file

@ -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>

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

@ -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) {

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

@ -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);

17
clearing-parent/dbf-importer/pom.xml
View file

@ -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>

17
clearing-parent/reports-service/pom.xml
View file

@ -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>

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

@ -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);
}

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

@ -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);

17
clearing-parent/swt-importer/pom.xml
View file

@ -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>

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

@ -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() {