diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterServiceTest.java new file mode 100644 index 000000000..679d151c7 --- /dev/null +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterServiceTest.java @@ -0,0 +1,129 @@ +package ru.spcex.clearing.registry.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.register.AdmittedLiabilitiesRegister; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + AdmittedLiabilitiesRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class AdmittedLiabilitiesRegisterServiceTest { + //consts + + private static int requestCount = 0; + private static final String securitySymbol = "SYMBOL"; + private static final Long companyId = 1L; + private static final String clearingCode = "CODE"; + private static final String account = "ACCOUNT"; + private static final BigDecimal balance = new BigDecimal(1); + private static final LocalDate clearingDate = LocalDate.now(); + private static final String COMPANY_FULL_NAME = "ROGA"; + private Long REGISTRY_SPY_ID; + private final Long sessionId = 0L; + private Imdg registryMap; + private Imdg companyMap; + private Imdg admittedLiabilitiesRegisterMap; + @Autowired + private AdmittedLiabilitiesRegisterService admittedLiabilitiesRegisterService; + + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + //initializing of imdg + companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + admittedLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class); + // initialing objects for imdg repos + + Long securityId = 1L; + Registry registry = new Registry(); + registry.setRegistryDesignation(RegistryDesignation.O.getKey()); + registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey()); + registry.setRegistryUnit(RegistryUnit.T.getKey()); + registry.setRegistryStatus(RegistryStatus.OK.getKey()); + registry.setSecurityId(securityId); + registry.setSessionId(sessionId); + registry.setSecuritySymbol(securitySymbol); + registry.setCompanyId(companyId); + registry.setClearingCode(clearingCode); + registry.setAccount(account); + registry.setBalance(balance); + registry.setClearingDate(clearingDate); + REGISTRY_SPY_ID = registryMap.insert(registry); + + Company company = new Company(); + company.setId(1L); + company.setFullName(COMPANY_FULL_NAME); + companyMap.insert(company); + } + + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) admittedLiabilitiesRegisterService.getConsumer(), + Task.createRegistry_ADLR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = admittedLiabilitiesRegisterMap.getAllValues(); + AdmittedLiabilitiesRegister admittedLiabilitiesRegister = allValues.iterator().next(); + assertEquals(companyId, admittedLiabilitiesRegister.getCompanyId()); + assertEquals(clearingCode, admittedLiabilitiesRegister.getClearingCode()); + assertEquals(account, admittedLiabilitiesRegister.getAccount()); + assertEquals(balance, admittedLiabilitiesRegister.getAmount()); + assertEquals(clearingDate, admittedLiabilitiesRegister.getClearingDate()); + assertEquals(COMPANY_FULL_NAME, admittedLiabilitiesRegister.getCompanyFullName()); + } + +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterServiceTest.java new file mode 100644 index 000000000..d6484bfeb --- /dev/null +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterServiceTest.java @@ -0,0 +1,127 @@ +package ru.spcex.clearing.registry.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.register.CoveredLiabilitiesRegister; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + CoveredLiabilitiesRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class CoveredLiabilitiesRegisterServiceTest { + private static int requestCount = 0; + private static final String securitySymbol = "SYMBOL"; + private static final Long companyId = 1L; + private static final String clearingCode = "CODE"; + private static final String account = "ACCOUNT"; + private static final BigDecimal balance = new BigDecimal(1); + private static final LocalDate clearingDate = LocalDate.now(); + private static final String COMPANY_FULL_NAME = "ROGA"; + private Imdg coveredLiabilitiesRegisterMap; + private Imdg registryMap; + private Imdg companyMap; + private Long REGISTRY_SPY_ID; + private final Long sessionId = 0L; + + @Autowired + private CoveredLiabilitiesRegisterService coveredLiabilitiesRegisterService; + + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + //initializing of imdg + companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + coveredLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class); + // initialing objects for imdg repos + + Long securityId = 1L; + Registry registry = new Registry(); + registry.setRegistryDesignation(RegistryDesignation.O.getKey()); + registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey()); + registry.setRegistryUnit(RegistryUnit.T.getKey()); + registry.setRegistryStatus(RegistryStatus.OK.getKey()); + registry.setSecurityId(securityId); + registry.setSessionId(sessionId); + registry.setSecuritySymbol(securitySymbol); + registry.setCompanyId(companyId); + registry.setClearingCode(clearingCode); + registry.setAccount(account); + registry.setBalance(balance); + registry.setClearingDate(clearingDate); + REGISTRY_SPY_ID = registryMap.insert(registry); + + Company company = new Company(); + company.setId(1L); + company.setFullName(COMPANY_FULL_NAME); + companyMap.insert(company); + } + + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) coveredLiabilitiesRegisterService.getConsumer(), + Task.createRegistry_CDLR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = coveredLiabilitiesRegisterMap.getAllValues(); + CoveredLiabilitiesRegister coveredLiabilitiesRegister = allValues.iterator().next(); + assertEquals(companyId, coveredLiabilitiesRegister.getCompanyId()); + assertEquals(clearingCode, coveredLiabilitiesRegister.getClearingCode()); + assertEquals(account, coveredLiabilitiesRegister.getAccount()); + assertEquals(balance, coveredLiabilitiesRegister.getAmount()); + assertEquals(clearingDate, coveredLiabilitiesRegister.getClearingDate()); + assertEquals(COMPANY_FULL_NAME, coveredLiabilitiesRegister.getCompanyFullName()); + } +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterServiceTest.java new file mode 100644 index 000000000..ae73c8c99 --- /dev/null +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterServiceTest.java @@ -0,0 +1,113 @@ +package ru.spcex.clearing.registry.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.register.DepoBalanceRegister; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + DepoBalanceRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class DepoBalanceRegisterServiceTest { + private static int requestCount = 0; + + private static final Long companyId = 1L; + private static final Long sessionId = 1L; + private static final String account = "ACCOUNT"; + private static final BigDecimal balance = new BigDecimal(1); + private static final String SECURITY_SYMBOL= "SECURITY_SYMBOL"; + + private Imdg depoBalanceRegisterMap; + private Imdg registryMap; + + @Autowired + private DepoBalanceRegisterService depoBalanceRegisterService; + + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + //initializing of imdg + registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class); + // initialing objects for imdg repos + + Long securityId = 1L; + Registry registry = new Registry(); + registry.setRegistryDesignation(RegistryDesignation.A.getKey()); + registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey()); + registry.setRegistryUnit(RegistryUnit.T.getKey()); + registry.setRegistryStatus(RegistryStatus.OK.getKey()); + registry.setSessionId(sessionId); + registry.setCompanyId(companyId); + registry.setAccountType(AccountType.Depo.getKey()); + registry.setAccount(account); + registry.setBalance(balance); + registry.setSecuritySymbol(SECURITY_SYMBOL); + registryMap.insert(registry); + } + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) depoBalanceRegisterService.getConsumer(), + Task.createRegistry_GRRT.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = depoBalanceRegisterMap.getAllValues(); + DepoBalanceRegister depoBalanceRegister = allValues.iterator().next(); + assertEquals(sessionId, depoBalanceRegister.getSessionId()); + assertEquals(companyId, depoBalanceRegister.getCompanyId()); + assertEquals(account, depoBalanceRegister.getDepoCode()); + assertEquals(balance, depoBalanceRegister.getQuantity()); + assertEquals(SECURITY_SYMBOL, depoBalanceRegister.getSecuritySymbol()); + } +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterServiceTest.java new file mode 100644 index 000000000..04af05318 --- /dev/null +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoPaymentInstructionRegisterServiceTest.java @@ -0,0 +1,133 @@ +package ru.spcex.clearing.registry.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.misc.Session; +import ru.clearing.classes.statics.data.payment.PaymentInstruction; +import ru.clearing.classes.statics.data.register.DepoPaymentInstructionRegister; +import ru.clearing.classes.statics.data.registry.TradingClearingRegistry; +import ru.clearing.platform.dictionary.InOutDirectionDictionary; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.Task; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + DepoPaymentInstructionRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +class DepoPaymentInstructionRegisterServiceTest { + private Imdg depoPaymentInstructionRegisterMap; + private Imdg paymentInstructionMap; + private Imdg sessionMap; + private Imdg tradingClearingRegistryMap; + private Imdg inOutDirectionDictionaryMap; + private static int requestCount = 0; + private static final Long SESSION_ID = 1L; + private static final String SESSION_SECTION = "FOND"; + private static final Long TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID = 100L; + private static final Long TRADING_CLEARING_REGISTRY_COMPANY_ID = 101L; + private static final String TRADING_CLEARING_REGISTRY_TYPE = "TYPE"; + private static final String TRADING_CLEARING_REGISTRY_CODE = "CODE"; + private static final String SET_CREDIT_LEG_DIRECTION = "PAYMENT_INSTRUCTION_CREDIT_LEG"; + private static final BigDecimal SET_CREDIT_LEG_AMOUNT = new BigDecimal(1); + private static final Long IN_OUT_DIRECTION_DICTIONARY_ID = 123L; + @Autowired + private DepoPaymentInstructionRegisterService depoPaymentInstructionRegisterService; + + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + //initializing of imdg + depoPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class); + paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class); + sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + tradingClearingRegistryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class); + inOutDirectionDictionaryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class); + + // initialing objects for imdg repos + + } + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + Session session = new Session(); + session.setSection(SESSION_SECTION); + session.setId(SESSION_ID); + sessionMap.update(session); + + PaymentInstruction paymentInstruction = new PaymentInstruction(); + paymentInstruction.setSessionId(SESSION_ID); + paymentInstruction.setCreditLeg_accountId(TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID); + paymentInstruction.setSenderId(TRADING_CLEARING_REGISTRY_COMPANY_ID); + paymentInstruction.setCreditLeg_direction(SET_CREDIT_LEG_DIRECTION); + paymentInstruction.setCreditLeg_amount(SET_CREDIT_LEG_AMOUNT); + paymentInstructionMap.insert(paymentInstruction); + + + TradingClearingRegistry tradingClearingRegistry = new TradingClearingRegistry(); + tradingClearingRegistry.setCompanyId(TRADING_CLEARING_REGISTRY_COMPANY_ID); + tradingClearingRegistry.setDepoAccountId(TRADING_CLEARING_REGISTRY_DEPO_ACCOUNT_ID); + tradingClearingRegistry.setTradingClearingRegistryType(TRADING_CLEARING_REGISTRY_TYPE); + tradingClearingRegistry.setCode(TRADING_CLEARING_REGISTRY_CODE); + tradingClearingRegistryMap.insert(tradingClearingRegistry); + + InOutDirectionDictionary inOutDirectionDictionary = new InOutDirectionDictionary(); + inOutDirectionDictionary.setCode(SET_CREDIT_LEG_DIRECTION); + inOutDirectionDictionary.setId(IN_OUT_DIRECTION_DICTIONARY_ID); + inOutDirectionDictionaryMap.update(inOutDirectionDictionary); + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) depoPaymentInstructionRegisterService.getConsumer(), + Task.createRegistry_GORD.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = depoPaymentInstructionRegisterMap.getAllValues(); + DepoPaymentInstructionRegister depoPaymentInstructionRegister = allValues.iterator().next(); + assertEquals(SESSION_ID, depoPaymentInstructionRegister.getSessionId()); + assertEquals(TRADING_CLEARING_REGISTRY_COMPANY_ID, depoPaymentInstructionRegister.getCompanyId()); + assertEquals(TRADING_CLEARING_REGISTRY_TYPE, depoPaymentInstructionRegister.getTradingClearingRegistryType()); + assertEquals(TRADING_CLEARING_REGISTRY_CODE, depoPaymentInstructionRegister.getTradingClearingRegistry()); + assertEquals(IN_OUT_DIRECTION_DICTIONARY_ID, depoPaymentInstructionRegister.getDirection()); + assertEquals(SET_CREDIT_LEG_AMOUNT, depoPaymentInstructionRegister.getQuantity()); + } +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java index ec8bdeae5..735ac3811 100644 --- a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java @@ -1,34 +1,143 @@ package ru.spcex.clearing.registry.service; +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; -import org.mockito.Mockito; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.company.CompanySymbols; +import ru.clearing.classes.statics.data.misc.Session; import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister; -import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; import ru.clearing.classes.statics.data.registry.Registry; import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; -import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast; +import ru.spcex.platform.utils.time.TimeUtil; -import static org.junit.jupiter.api.Assertions.*; +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDate; +import java.util.Collection; +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + ExcludeLiabilitiesRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) class ExcludeLiabilitiesRegisterServiceTest { + private static int requestCount = 0; - @Test - void getSqlForRegistries() { - ExcludeLiabilitiesRegisterService svc = instance(); - assertEquals("registryDesignation = 'O' and registryInstrumentType in ('S','M') and registryUnit = 'T' and registryStatus in ('FAIL', 'UNCV')", - svc.getSqlForRegistries()); + @Autowired + private ExcludeLiabilitiesRegisterService excludeLiabilitiesRegisterService; + private Imdg excludeLiabilitiesRegisterMap; + private Imdg registryMap; + private Imdg sessionMap; + private Imdg companySymbolMap; + + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + excludeLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class); + registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + companySymbolMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, ru.clearing.classes.statics.data.company.CompanySymbols.class); } + private static final Long SESSION_ID = 10L; + private static final Long SECURITY_ID = 101L; + private static final Long REGISTRY_COMPANY_ID = 10L; + private static final String REGISTRY_COMPANY_FULL_NAME = "full_nome"; + private static final String REGISTRY_CODE = "full_nome"; + private static final String REGISTRY_ACCOUNT = "full_nome"; + private static final String REGISTRY_STATUS = RegistryStatus.FAIL.getKey(); + private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(1); + private static final LocalDate SESSION_CLEARING_DATE = LocalDate.now(); + private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now(); + private static final Instant SESSION_UPDATED = Instant.now(); + private static final String COMPANY_SYMBOL_VALUE = "COMPANY_SYMBOL_VALUE"; + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + Registry registry = new Registry(); + registry.setRegistryDesignation(RegistryDesignation.O.getKey()); + registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey()); + registry.setRegistryUnit(RegistryUnit.T.getKey()); + registry.setRegistryStatus(REGISTRY_STATUS); + registry.setSessionId(SESSION_ID); + registry.setCompanyId(REGISTRY_COMPANY_ID); + registry.setFullName(REGISTRY_COMPANY_FULL_NAME); + registry.setRegistryCode(REGISTRY_CODE); + registry.setAccount(REGISTRY_ACCOUNT); + registry.setBalance(REGISTRY_BALANCE); + registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE); + registry.setSecurityId(SECURITY_ID); + registryMap.insert(registry); - ExcludeLiabilitiesRegisterService instance() { - ImdgProvider imdg = Mockito.mock(ImdgProvider.class); - Imdg map1 = Mockito.mock(Imdg.class); - Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast()); - Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class)).thenReturn(map1); + Session session = new Session(); + session.setId(SESSION_ID); + session.setClearingDate(SESSION_CLEARING_DATE); + session.setUpdated(SESSION_UPDATED); + sessionMap.update(session); + CompanySymbols companySymbols = new CompanySymbols(); + companySymbols.setCompanyId(REGISTRY_COMPANY_ID); + companySymbols.setCompanySymbol(CompanySymbol.INN.getKey()); + companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE); + companySymbolMap.insert(companySymbols); + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) excludeLiabilitiesRegisterService.getConsumer(), + Task.createRegistry_EXLR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = excludeLiabilitiesRegisterMap.getAllValues(); + ExcludeLiabilitiesRegister excludeLiabilitiesRegister = allValues.iterator().next(); + assertEquals(SESSION_ID, excludeLiabilitiesRegister.getSessionId()); + assertEquals(REGISTRY_COMPANY_ID, excludeLiabilitiesRegister.getCompanyId()); + assertEquals(REGISTRY_COMPANY_FULL_NAME, excludeLiabilitiesRegister.getCompanyFullName()); + assertEquals(REGISTRY_CODE, excludeLiabilitiesRegister.getRegistryCode()); + assertEquals(REGISTRY_ACCOUNT, excludeLiabilitiesRegister.getAccount()); + assertEquals(REGISTRY_STATUS, excludeLiabilitiesRegister.getRegistryStatus()); + assertEquals(REGISTRY_BALANCE, excludeLiabilitiesRegister.getSumLiabilities()); + assertEquals(SESSION_CLEARING_DATE, excludeLiabilitiesRegister.getValidFromDate()); + assertEquals(REGISTRY_SETTLEMENT_DATE, excludeLiabilitiesRegister.getSettlementDate()); + assertEquals(TimeUtil.toLocalDate(SESSION_UPDATED), excludeLiabilitiesRegister.getValidToDate()); + assertEquals(COMPANY_SYMBOL_VALUE, excludeLiabilitiesRegister.getInn()); - return new ExcludeLiabilitiesRegisterService(null, null, imdg, null); } } \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExecutionRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExecutionRegisterServiceTest.java index 23eddccff..422ebbbf0 100644 --- a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExecutionRegisterServiceTest.java +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExecutionRegisterServiceTest.java @@ -24,12 +24,10 @@ import ru.spcex.clearing.test.TestUtils; import ru.spcex.clearing.test.config.ImdgTestConfig; import ru.spcex.clearing.test.config.KafkaTestConfig; import ru.spcex.platform.enumeration.CompanySymbol; -import ru.spcex.platform.enumeration.MoneyFlowSide; import ru.spcex.platform.enumeration.Side; import ru.spcex.platform.enumeration.Task; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; -import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast; import javax.annotation.PostConstruct; import java.math.BigDecimal; @@ -164,11 +162,10 @@ class ExecutionRegisterServiceTest { executionFond.setTradingClearingRegistryId(TKR_FOR_TKR_ID); executionFond.setCompanyId(COMPANY_ID); executionFond.setCounterPartyId(COUNTER_PARTY_ID); - executionFond.setSide(Side.SELL.getKey()); + executionFond.setSide(Side.BUY.getKey()); executionFond.setCounterPartyTradingClearingRegistry(COUNTER_PARTY_TKR); executionFond.setPartyTradingClearingRegistry(PARTY_TKR); executionFondImdg.insert(executionFond); - ((ImdgHazelcast)executionDepositImdg).clear(); // чтобы не влиял второй тест LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); @@ -188,16 +185,16 @@ class ExecutionRegisterServiceTest { assertEquals(executionRegister.getExchangeExecutionId(), EXCHANGE_EXECUTION_ID); assertEquals(executionRegister.getExchangeExecutionTime(), EXCHANGE_EXECUTION_TIME); assertEquals(executionRegister.getSecurityId(), SECURITY_ID); - assertEquals(executionRegister.getSellerId(), COMPANY_ID); - assertEquals(executionRegister.getSellerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COMPANY_ID); - assertEquals(executionRegister.getSellerTradingClearingRegister(), PARTY_TKR); - assertEquals(executionRegister.getSellerMoneyAccount(), MONEY_ACCOUNT_FOR_TKR); - assertEquals(executionRegister.getSellerDepoAccount(), DEPO_ACCOUNT_FOR_TKR); - assertEquals(executionRegister.getBuyerId(), COUNTER_PARTY_ID); - assertEquals(executionRegister.getBuyerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COUNTER_PARTY_ID); - assertEquals(executionRegister.getBuyerTradingClearingRegister(), COUNTER_PARTY_TKR); - assertEquals(executionRegister.getBuyerMoneyAccount(), MONEY_ACCOUNT_FOR_COUNTER_PARTY_TKR); - assertEquals(executionRegister.getBuyerDepoAccount(), DEPO_ACCOUNT_FOR_COUNTER_PARTY_TKR); + assertEquals(executionRegister.getSellerId(), COUNTER_PARTY_ID); + assertEquals(executionRegister.getSellerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COUNTER_PARTY_ID); + assertEquals(executionRegister.getSellerTradingClearingRegister(), COUNTER_PARTY_TKR); + assertEquals(executionRegister.getSellerMoneyAccount(), MONEY_ACCOUNT_FOR_COUNTER_PARTY_TKR); + assertEquals(executionRegister.getSellerDepoAccount(), DEPO_ACCOUNT_FOR_COUNTER_PARTY_TKR); + assertEquals(executionRegister.getBuyerId(), COMPANY_ID); + assertEquals(executionRegister.getBuyerClearingCode(), COMPANY_SYMBOL_VALUE_FOR_COMPANY_ID); + assertEquals(executionRegister.getBuyerTradingClearingRegister(), PARTY_TKR); + assertEquals(executionRegister.getBuyerMoneyAccount(), MONEY_ACCOUNT_FOR_TKR); + assertEquals(executionRegister.getBuyerDepoAccount(), DEPO_ACCOUNT_FOR_TKR); assertEquals(executionRegister.getAmount(), SETTLEMENT_AMOUNT); assertEquals(executionRegister.getQuantity(), QUANTITY); assertEquals(executionRegister.getClearingDate(), LocalDate.now()); @@ -220,11 +217,10 @@ class ExecutionRegisterServiceTest { executionDeposit.setTradingClearingRegistryId(TKR_FOR_TKR_ID); executionDeposit.setCompanyId(COMPANY_ID); executionDeposit.setCounterPartyId(COUNTER_PARTY_ID); - executionDeposit.setSide(MoneyFlowSide.SELL.getKey()); + executionDeposit.setSide(Side.SELL.getKey()); executionDeposit.setCounterPartyTradingClearingRegistry(COUNTER_PARTY_TKR); executionDeposit.setPartyTradingClearingRegistry(PARTY_TKR); executionDepositImdg.insert(executionDeposit); - ((ImdgHazelcast)executionFondImdg).clear(); // чтобы не влиял первый тест LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java index b35882342..d842b4ee9 100644 --- a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java @@ -1,31 +1,143 @@ package ru.spcex.clearing.registry.service; +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; -import org.mockito.Mockito; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.company.CompanySymbols; +import ru.clearing.classes.statics.data.misc.Session; import ru.clearing.classes.statics.data.register.LiabilitiesRegister; +import ru.clearing.classes.statics.data.registry.Registry; import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; -import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast; +import ru.spcex.platform.utils.time.TimeUtil; -import static org.junit.jupiter.api.Assertions.*; +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.time.Instant; +import java.time.LocalDate; +import java.util.Collection; +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + LiabilitiesRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) class LiabilitiesRegisterServiceTest { + private static int requestCount = 0; + private static final String REGISTRY_DESIGNATION = RegistryDesignation.L.getKey(); + private static final String REGISTRY_INSTRUMENT_TYPE = RegistryInstrumentType.S.getKey(); + private static final String REGISTRY_UNIT = RegistryUnit.T.getKey(); + private static final String REGISTRY_FULL_NAME = "MY FULLNAME"; + private static final String REGISTRY_CODE = "ANY CODE"; + private static final String REGISTRY_ACCOUNT = "ANY ACCOUNT"; + private static final String REGISTRY_STATUS = "ANY STATUS"; + private static final Long REGISTRY_SESSION_ID = 1234L; + private static final Long REGISTRY_COMPANY_ID = 10101L; + private static final Long REGISTRY_SECURITY_ID = 123411L; + private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(123411L); + private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now(); + private static final LocalDate SESSION_CLEARING_DATE = LocalDate.now(); + private static final Instant SESSION_UPDATE = Instant.now(); + private static final String COMPANY_SYMBOL_INN = CompanySymbol.INN.getKey(); + private static final String COMPANY_SYMBOL_VALUE = "ANY VALUE"; + + @Autowired + private LiabilitiesRegisterService liabilitiesRegisterService; + private Imdg liabilitiesRegisterMap; + private Imdg registryMap; + private Imdg sessionMap; + private Imdg companySymbolsMap; + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + + this.liabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class); + this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + } @Test - void getSqlForRegistries() { - LiabilitiesRegisterService svc = instance(); - assertEquals("registryDesignation = 'L' and registryInstrumentType in ('S','M') and registryUnit = 'T'", - svc.getSqlForRegistries()); - } + @Order(1) + void executionRegisterNewForClearingDate() { + Registry registry = new Registry(); + registry.setRegistryUnit(REGISTRY_UNIT); + registry.setRegistryInstrumentType(REGISTRY_INSTRUMENT_TYPE); + registry.setRegistryDesignation(REGISTRY_DESIGNATION); + registry.setSessionId(REGISTRY_SESSION_ID); + registry.setCompanyId(REGISTRY_COMPANY_ID); + registry.setFullName(REGISTRY_FULL_NAME); + registry.setRegistryCode(REGISTRY_CODE); + registry.setAccount(REGISTRY_ACCOUNT); + registry.setRegistryStatus(REGISTRY_STATUS); + registry.setBalance(REGISTRY_BALANCE); + registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE); + registry.setSecurityId(REGISTRY_SECURITY_ID); + registryMap.insert(registry); + Session session = new Session(); + session.setId(REGISTRY_SESSION_ID); + session.setClearingDate(SESSION_CLEARING_DATE); + session.setUpdated(SESSION_UPDATE); + sessionMap.update(session); - LiabilitiesRegisterService instance() { - ImdgProvider imdg = Mockito.mock(ImdgProvider.class); - Imdg map1 = Mockito.mock(Imdg.class); - Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast()); - Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class)).thenReturn(map1); + CompanySymbols companySymbols = new CompanySymbols(); + companySymbols.setCompanyId(REGISTRY_COMPANY_ID); + companySymbols.setCompanySymbol(COMPANY_SYMBOL_INN); + companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE); + companySymbolsMap.insert(companySymbols); + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); - return new LiabilitiesRegisterService(null, null, imdg, null); + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) liabilitiesRegisterService.getConsumer(), + Task.createRegistry_LBSR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = liabilitiesRegisterMap.getAllValues(); + LiabilitiesRegister liabilitiesRegister = allValues.iterator().next(); + assertEquals(REGISTRY_COMPANY_ID, liabilitiesRegister.getCompanyId()); + assertEquals(REGISTRY_FULL_NAME, liabilitiesRegister.getCompanyFullName()); + assertEquals(REGISTRY_CODE, liabilitiesRegister.getRegistryCode()); + assertEquals(REGISTRY_ACCOUNT, liabilitiesRegister.getAccount()); + assertEquals(REGISTRY_STATUS, liabilitiesRegister.getRegistryStatus()); + assertEquals(REGISTRY_BALANCE, liabilitiesRegister.getSumLiabilities()); + assertEquals(REGISTRY_SETTLEMENT_DATE, liabilitiesRegister.getSettlementDate()); + assertEquals(SESSION_CLEARING_DATE, liabilitiesRegister.getValidFromDate()); + assertEquals(TimeUtil.toLocalDate(SESSION_UPDATE), liabilitiesRegister.getValidToDate()); + assertEquals(COMPANY_SYMBOL_VALUE, liabilitiesRegister.getInn()); } } \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java index d6de6c4f0..085ef2e32 100644 --- a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java @@ -1,123 +1,154 @@ package ru.spcex.clearing.registry.service; +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; -import org.mockito.Mockito; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.account.Account; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.company.CompanySymbols; import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; import ru.clearing.classes.statics.data.registry.Registry; import ru.spcex.clearing.imdg.IMDGDistributedNames; -import ru.spcex.platform.classes.base.SpcexObjectBase; -import ru.spcex.platform.enumeration.RegistryUnit; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.*; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; -import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast; -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Collectors; +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.util.Collection; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + MoneyBalanceRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) class MoneyBalanceRegisterServiceTest { + private static final String REGISTRY_DESIGNATION = RegistryDesignation.A.getKey(); + private static final String REGISTRY_INSTRUMENT_TYPE = RegistryInstrumentType.M.getKey(); + private static final String REGISTRY_FULL_NAME = "MY FULLNAME"; + private static final String REGISTRY_CODE = "ANY CODE"; + private static final String REGISTRY_ACCOUNT = "CLRN VALUE"; + private static final String ACCOUNT_ACCOUNT = "ACCOUNT"; + private static final String REGISTRY_ACCOUNT_TYPE = "CLRN"; + private static final String REGISTRY_STATUS = "ANY STATUS"; + private static final Long REGISTRY_SESSION_ID = 1234L; + private static final Long REGISTRY_COMPANY_ID = 10101L; + private static final Long REGISTRY_SECURITY_ID = 123411L; + private static final BigDecimal REGISTRY_BALANCE = new BigDecimal(123411L); + private static final LocalDate REGISTRY_SETTLEMENT_DATE = LocalDate.now(); + private static final String COMPANY_SYMBOL_INN = CompanySymbol.INN.getKey(); + private static final String COMPANY_SYMBOL_VALUE = "ANY VALUE"; + private static final String COMPANY_SHORTNAME = "ANY VALUE"; + private static int requestCount = 0; + @Autowired + private MoneyBalanceRegisterService moneyBalanceRegisterService; + private Imdg moneyBalanceRegisterMap; + private Imdg registryMap; + private Imdg companySymbolsMap; + private Imdg companyMap; + private Imdg accountMap; + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; - @Test - void groupingRegistry() { - MoneyBalanceRegisterService svc = testInstance(); - ArrayList regs1 = new ArrayList<>(); - assertEquals(0, svc.groupingRegistry(regs1).size()); - { - Registry r = new Registry(); - r.setId(1001L); - r.setCompanyId(10L); - r.setAccount("A100"); - r.setAccountId(100L); - r.setRegistryUnit(RegistryUnit.T.getKey()); - regs1.add(r); - } - { - Registry r = new Registry(); - r.setId(1002L); - r.setCompanyId(10L); - r.setAccount("A100"); - r.setAccountId(100L); - r.setRegistryUnit(RegistryUnit.B.getKey()); - regs1.add(r); - } - { - Registry r = new Registry(); - r.setId(1003L); - r.setCompanyId(10L); - r.setAccount("A100"); - r.setAccountId(100L); - r.setRegistryUnit(RegistryUnit.F.getKey()); - regs1.add(r); - } - { - Registry r = new Registry(); - r.setId(1004L); - r.setCompanyId(110L); - r.setAccount("A103"); - r.setAccountId(103L); - r.setRegistryUnit(RegistryUnit.F.getKey()); - regs1.add(r); - } - { - Registry r = new Registry(); - r.setId(1005L); - r.setCompanyId(10L); - r.setAccount("A101"); - r.setAccountId(101L); - r.setRegistryUnit(RegistryUnit.F.getKey()); - regs1.add(r); - } + @Autowired + @Qualifier("mockProducer") + private Producer producer; - List> out = svc.groupingRegistry(regs1); + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); - assertEquals("[[Registry{id=1004}], [Registry{id=1001}, Registry{id=1002}, Registry{id=1003}], [Registry{id=1005}]]", - "[" + out.stream().map(lst -> "[" + lst.stream().map(v -> v.toString()).collect(Collectors.joining(", ")) + "]") - .collect(Collectors.joining(", ")) + "]"); + moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class); + registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class); + companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class); + companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class); } @Test - void getSqlForRegistries() { - MoneyBalanceRegisterService svc = testInstance(); - assertEquals("(companyId=1000 AND (registryDesignation=A AND registryInstrumentType=M))", - svc.getSqlForRegistries(1000L).toString()); + @Order(1) + void executionRegisterNewForClearingDate() { + Registry registry = new Registry(); + registry.setRegistryUnit(RegistryUnit.T.getKey()); + registry.setRegistryInstrumentType(REGISTRY_INSTRUMENT_TYPE); + registry.setRegistryDesignation(REGISTRY_DESIGNATION); + registry.setSessionId(REGISTRY_SESSION_ID); + registry.setCompanyId(REGISTRY_COMPANY_ID); + registry.setFullName(REGISTRY_FULL_NAME); + registry.setRegistryCode(REGISTRY_CODE); + registry.setAccount(REGISTRY_ACCOUNT); + registry.setAccountType(REGISTRY_ACCOUNT_TYPE); + registry.setRegistryStatus(REGISTRY_STATUS); + registry.setBalance(REGISTRY_BALANCE); + registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE); + registry.setSecurityId(REGISTRY_SECURITY_ID); + registryMap.insert(registry); + registry.setId(null); + registry.setRegistryUnit(RegistryUnit.B.getKey()); + registryMap.insert(registry); + registry.setId(null); + registry.setRegistryUnit(RegistryUnit.F.getKey()); + registryMap.insert(registry); + Company company = new Company(); + company.setId(2L); + company.setShortName(COMPANY_SHORTNAME); + companyMap.insert(company); + + CompanySymbols companySymbols = new CompanySymbols(); + companySymbols.setCompanyId(REGISTRY_COMPANY_ID); + companySymbols.setCompanySymbol(COMPANY_SYMBOL_INN); + companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE); + companySymbolsMap.insert(companySymbols); + + Account account = new Account(); + account.setCompanyId(REGISTRY_COMPANY_ID); + account.setAccountType(AccountType.Info.getKey()); + account.setAccount(ACCOUNT_ACCOUNT); + accountMap.insert(account); + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + launcherCommandRequest.setCompanyId(REGISTRY_COMPANY_ID); + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) moneyBalanceRegisterService.getConsumer(), + Task.createRegistry_GBRR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = moneyBalanceRegisterMap.getAllValues(); + MoneyBalanceRegister moneyBalanceRegister = allValues.iterator().next(); + assertEquals(REGISTRY_COMPANY_ID, moneyBalanceRegister.getCompanyId()); + assertEquals(REGISTRY_FULL_NAME, moneyBalanceRegister.getCompanyFullName()); + assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getRemainderSum()); + assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getBlockedSum()); + assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getUnblockedSum()); + assertEquals(REGISTRY_ACCOUNT, moneyBalanceRegister.getAccount()); + assertEquals(ACCOUNT_ACCOUNT, moneyBalanceRegister.getInfoAccount()); + assertEquals(COMPANY_SHORTNAME, moneyBalanceRegister.getSetHouseName()); + assertEquals(COMPANY_SYMBOL_VALUE, moneyBalanceRegister.getInn()); } - - @Test - void getSqlForRemainderSum() { - MoneyBalanceRegisterService svc = testInstance(); - assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=T))", - svc.getSqlForRemainderSum(1000L, "ACC-2").toString()); - } - - @Test - void getSqlForBlockedSum() { - MoneyBalanceRegisterService svc = testInstance(); - assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=B))", - svc.getSqlForBlockedSum(1000L, "ACC-2").toString()); - } - - @Test - void getSqlForUnblockedSum() { - MoneyBalanceRegisterService svc = testInstance(); - assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=F))", - svc.getSqlForUnblockedSum(1000L, "ACC-2").toString()); - } - - static MoneyBalanceRegisterService testInstance() { - ImdgProvider imdg = Mockito.mock(ImdgProvider.class); - Imdg map1 = Mockito.mock(Imdg.class); - Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast()); - Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class)).thenReturn(map1); - Imdg map2 = Mockito.mock(Imdg.class); - Mockito.when(map2.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast()); - Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_Registry, Registry.class)).thenReturn(map2); - - MoneyBalanceRegisterService instance = new MoneyBalanceRegisterService(null, null, imdg, null); - return instance; - - //todo тесты с выборкой с реальным тестовым Imdg, чтобы провалидировать типы данных в SQL - } - } \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterServiceTest.java new file mode 100644 index 000000000..35d4186ff --- /dev/null +++ b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterServiceTest.java @@ -0,0 +1,123 @@ +package ru.spcex.clearing.registry.service; + +import org.apache.kafka.clients.consumer.MockConsumer; +import org.apache.kafka.clients.producer.Producer; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import ru.clearing.classes.statics.data.company.Company; +import ru.clearing.classes.statics.data.misc.Session; +import ru.clearing.classes.statics.data.payment.PaymentInstruction; +import ru.clearing.classes.statics.data.register.MoneyPaymentInstructionRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest; +import ru.spcex.clearing.registry.config.ValidationConfig; +import ru.spcex.clearing.test.TestUtils; +import ru.spcex.clearing.test.config.ImdgTestConfig; +import ru.spcex.clearing.test.config.KafkaTestConfig; +import ru.spcex.platform.enumeration.Task; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; + +import javax.annotation.PostConstruct; +import java.math.BigDecimal; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@ExtendWith(SpringExtension.class) +@ContextConfiguration(classes = { + ValidationConfig.class, + MoneyPaymentInstructionRegisterService.class, + ImdgTestConfig.class, + KafkaTestConfig.class, +}) +class MoneyPaymentInstructionRegisterServiceTest { + private static int requestCount = 0; + private Imdg moneyPaymentInstructionRegisterMap; + private Imdg paymentInstructionMap; + private Imdg sessionMap; + private Imdg companyMap; + private final String CREDITLEG_ACCOUNT_CONST = "CREDITLEG_ACCOUNT_CONST"; + private final BigDecimal CREDITLEG_AMOUNT_CONST = new BigDecimal(1); + private final String CREDITLEG_CURRENCYCODE_CONST = "CREDITLEG_CURRENCYCODE_CONST"; + private final String DEBITLEG_ACCOUNT_CONST = "DEBITLEG_ACCOUNT_CONST"; + private final String COMPANY_SHORT_NAME_SENDER_CONST = "COMPANY_SHORT_NAME_SENDER_CONST"; + private final String COMPANY_SHORT_NAME_ADDRESSEE_CONST = "COMPANY_SHORT_NAME_ADDRESSEE_CONST"; + @Autowired + @Qualifier("hazelcastServiceTest") + private ImdgProvider imdgProvider; + + @Autowired + @Qualifier("mockProducer") + private Producer producer; + + @Autowired + private MoneyPaymentInstructionRegisterService moneyPaymentInstructionRegisterService; + + @PostConstruct + private void init() { + ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId(); + companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class); + moneyPaymentInstructionRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class); + paymentInstructionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class); + sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class); + + + } + + @Test + @Order(1) + void executionRegisterNewForClearingDate() { + Long sessionId = 1L; + Long companySenderId = 1L; + Long companyAddresseeId = 2L; + Session sessionMkr = new Session(); + sessionMkr.setSection("MKR"); + sessionMkr.setId(sessionId); + sessionMap.update(sessionMkr); + PaymentInstruction paymentInstruction = new PaymentInstruction(); + paymentInstruction.setSessionId(sessionId); + paymentInstruction.setCreditLeg_account(CREDITLEG_ACCOUNT_CONST); + paymentInstruction.setCreditLeg_amount(CREDITLEG_AMOUNT_CONST); + paymentInstruction.setCreditLeg_currencyCode(CREDITLEG_CURRENCYCODE_CONST); + paymentInstruction.setDebitLeg_account(DEBITLEG_ACCOUNT_CONST); + paymentInstruction.setSenderId(companySenderId); + paymentInstruction.setAddresseeId(companyAddresseeId); + paymentInstructionMap.insert(paymentInstruction); + Company companySender = new Company(); + companySender.setId(companySenderId); + companySender.setShortName(COMPANY_SHORT_NAME_SENDER_CONST); + companyMap.update(companySender); + Company companyAddressee = new Company(); + companyAddressee.setId(companyAddresseeId); + companyAddressee.setShortName(COMPANY_SHORT_NAME_ADDRESSEE_CONST); + companyMap.update(companyAddressee); + //making launcherCommand + LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest(); + + String jsonString = TestUtils.getJsonStringForSystem(launcherCommandRequest, 0L); + + TestUtils.addRecordToKafka((MockConsumer) moneyPaymentInstructionRegisterService.getConsumer(), + Task.createRegistry_GORR.topic(), + requestCount++, + 0, + jsonString); + + TestUtils.waitingSendAndCheckRecord(0L, producer); + + //take all values is procceed imdg + Collection allValues = moneyPaymentInstructionRegisterMap.getAllValues(); + MoneyPaymentInstructionRegister moneyPaymentInstructionRegister = allValues.iterator().next(); + assertEquals(CREDITLEG_ACCOUNT_CONST, moneyPaymentInstructionRegister.getCreditLegAccount()); + assertEquals(CREDITLEG_AMOUNT_CONST, moneyPaymentInstructionRegister.getCreditLegAmount()); + assertEquals(CREDITLEG_CURRENCYCODE_CONST, moneyPaymentInstructionRegister.getCreditLegCurrencyCode()); + assertEquals(DEBITLEG_ACCOUNT_CONST, moneyPaymentInstructionRegister.getDebitLegAccount()); + assertEquals(COMPANY_SHORT_NAME_SENDER_CONST, moneyPaymentInstructionRegister.getSender()); + assertEquals(COMPANY_SHORT_NAME_ADDRESSEE_CONST, moneyPaymentInstructionRegister.getAddressee()); + } +} \ No newline at end of file