From 8dc27ce066c5261ffe042af10796423710ab6afd Mon Sep 17 00:00:00 2001 From: abel Date: Sat, 8 Apr 2023 23:06:13 +0200 Subject: [PATCH 1/6] POS-1 : Ajoute de dependences dans pom.pom.xml --- Poseiden-skeleton/pom.xml | 197 +++++++++++++++++++++++++++++++++++++- 1 file changed, 193 insertions(+), 4 deletions(-) diff --git a/Poseiden-skeleton/pom.xml b/Poseiden-skeleton/pom.xml index a7dcbc04dc..1812ceaee5 100644 --- a/Poseiden-skeleton/pom.xml +++ b/Poseiden-skeleton/pom.xml @@ -15,7 +15,7 @@ org.springframework.boot spring-boot-starter-parent - 2.0.4.RELEASE + 2.7.8 @@ -23,6 +23,17 @@ UTF-8 UTF-8 1.8 + 2.7.8 + 8.0.0.Final + 5.9.2 + 1.9.2 + 3.24.2 + 0.8.8 + 3.0.0 + 1.18.26 + 3.4.2 + 3.7.1 + 2.0.1.Final @@ -53,13 +64,81 @@ true - mysql - mysql-connector-java + com.mysql + mysql-connector-j + runtime com.h2database h2 + + + org.projectlombok + lombok + ${lombok.version} + true + + + + org.junit.jupiter + junit-jupiter-api + ${junit-jupiter.version} + test + + + org.junit.vintage + junit-vintage-engine + test + + + org.hamcrest + hamcrest-core + + + + + + org.junit.platform + junit-platform-runner + ${junit-platform.version} + test + + + + org.assertj + assertj-core + ${assertj.version} + test + + + javax.validation + validation-api + ${validation-api.version} + + + org.hibernate.validator + hibernate-validator + ${hibernate-validator.version} + + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + maven-plugin + + + org.apache.maven.plugins + maven-failsafe-plugin + ${failsafe.version} + test + + + + org.apache.maven.plugins + maven-project-info-reports-plugin + ${maven-project-info-reports-plugin.version} + @@ -68,7 +147,117 @@ org.springframework.boot spring-boot-maven-plugin + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + + + pre-unit-test + + prepare-agent + + + ${project.build.directory}/coverage-reports/jacoco-ut.exec + surefireArgLine + + + + post-unit-test + test + + report + + + ${project.build.directory}/coverage-reports/jacoco-ut.exec + ${project.reporting.outputDirectory}/jacoco-ut + + + + pre-integration-test + pre-integration-test + + prepare-agent + + + ${project.build.directory}/coverage-reports/jacoco-it.exec + failsafeArgLine + + + + post-integration-test + post-integration-test + + report + + + ${project.build.directory}/coverage-reports/jacoco-it.exec + ${project.reporting.outputDirectory}/jacoco-it + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.project-lombok + lombok + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 9 + 9 + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + ${surefireArgLine} + + **/IT*.java + + + + + + org.apache.maven.plugins + maven-failsafe-plugin + + + integration-tests + + integration-test + verify + + + + ${failsafeArgLine} + + + + + + org.apache.maven.plugins + maven-site-plugin + ${maven-site-plugin.version} + + + + org.apache.maven.plugins + maven-project-info-reports-plugin + ${maven-project-info-reports-plugin.version} + - From c6ddba793eefb8263b344cacf9485c1170e2d145 Mon Sep 17 00:00:00 2001 From: abel Date: Sat, 8 Apr 2023 23:13:08 +0200 Subject: [PATCH 2/6] Ajoute du fichier gitignore --- Poseiden-skeleton/.gitignore | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 Poseiden-skeleton/.gitignore diff --git a/Poseiden-skeleton/.gitignore b/Poseiden-skeleton/.gitignore new file mode 100644 index 0000000000..583caa2c59 --- /dev/null +++ b/Poseiden-skeleton/.gitignore @@ -0,0 +1,3 @@ +## Ignored files and forlder +.idea/ +target/ \ No newline at end of file From fa5ef8e45cf4fecd4053f889a279e18b6a1936be Mon Sep 17 00:00:00 2001 From: abel Date: Sat, 8 Apr 2023 23:20:54 +0200 Subject: [PATCH 3/6] POS-3 : Ajout de @Repository sur tous les fichiers du package repositories --- .../com/nnk/springboot/repositories/BidListRepository.java | 3 ++- .../com/nnk/springboot/repositories/CurvePointRepository.java | 3 ++- .../java/com/nnk/springboot/repositories/RatingRepository.java | 2 ++ .../com/nnk/springboot/repositories/RuleNameRepository.java | 3 ++- .../java/com/nnk/springboot/repositories/TradeRepository.java | 3 ++- .../java/com/nnk/springboot/repositories/UserRepository.java | 3 ++- 6 files changed, 12 insertions(+), 5 deletions(-) diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/BidListRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/BidListRepository.java index f74b94e51d..f5247087fa 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/BidListRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/BidListRepository.java @@ -2,8 +2,9 @@ import com.nnk.springboot.domain.BidList; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; - +@Repository public interface BidListRepository extends JpaRepository { } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/CurvePointRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/CurvePointRepository.java index b01751b53e..c4904c483e 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/CurvePointRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/CurvePointRepository.java @@ -2,8 +2,9 @@ import com.nnk.springboot.domain.CurvePoint; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; - +@Repository public interface CurvePointRepository extends JpaRepository { } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RatingRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RatingRepository.java index 7ded405e6d..ded1e8a0ed 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RatingRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RatingRepository.java @@ -2,7 +2,9 @@ import com.nnk.springboot.domain.Rating; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; +@Repository public interface RatingRepository extends JpaRepository { } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RuleNameRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RuleNameRepository.java index 8053d1612e..a805586b44 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RuleNameRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/RuleNameRepository.java @@ -2,7 +2,8 @@ import com.nnk.springboot.domain.RuleName; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; - +@Repository public interface RuleNameRepository extends JpaRepository { } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/TradeRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/TradeRepository.java index e8da38af02..50e9b39a15 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/TradeRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/TradeRepository.java @@ -2,7 +2,8 @@ import com.nnk.springboot.domain.Trade; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; - +@Repository public interface TradeRepository extends JpaRepository { } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/UserRepository.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/UserRepository.java index b6a3363949..1d338d5101 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/UserRepository.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/repositories/UserRepository.java @@ -5,8 +5,9 @@ import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; - +@Repository public interface UserRepository extends JpaRepository, JpaSpecificationExecutor { } From ad4e652291f027d6290dac3324fbb06a5d312fcb Mon Sep 17 00:00:00 2001 From: abel Date: Sat, 8 Apr 2023 23:26:30 +0200 Subject: [PATCH 4/6] POS 4 : Ajout des TU Repository --- .../repositories/BidListRepositoryTest.java | 190 ++++++++++++++++++ .../CurvePointRepositoryTest.java | 133 ++++++++++++ .../repositories/RatingRepositoryTest.java | 115 +++++++++++ .../repositories/RuleNameRepositoryTest.java | 122 +++++++++++ .../repositories/TradeRepositoryTest.java | 187 +++++++++++++++++ .../repositories/UserRepositoryTest.java | 113 +++++++++++ 6 files changed, 860 insertions(+) create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/BidListRepositoryTest.java create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/CurvePointRepositoryTest.java create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RatingRepositoryTest.java create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RuleNameRepositoryTest.java create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/TradeRepositoryTest.java create mode 100644 Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/UserRepositoryTest.java diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/BidListRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/BidListRepositoryTest.java new file mode 100644 index 0000000000..c2935685c1 --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/BidListRepositoryTest.java @@ -0,0 +1,190 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.BidList; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class BidListRepositoryTest { + @Mock + private BidListRepository bidListRepository; + + @BeforeEach + private void setup() { + bidListRepository = Mockito.mock(BidListRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les BidLists") + @Order(1) + @Test + void test_findAll_should_FindAll_BidList() { + List bidListList = new ArrayList<>(); + + BidList bidList = new BidList(); + BidList bidList2 = new BidList(); + BidList bidList3 = new BidList(); + bidListList.add(bidList); + bidListList.add(bidList2); + bidListList.add(bidList3); + + when(bidListRepository.findAll()).thenReturn(bidListList); + + List result = bidListRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(bidListList.size()); + } + + @DisplayName(value = "2°) Recherche de BidList par ID") + @Order(2) + @Test + void test_findById_shoud_findBidList_By_Id() { + BidList bidList = new BidList(); + bidList.setBidListId(1); + + when(bidListRepository.findById(1)).thenReturn(Optional.of(bidList)); + + Optional bidListResult = bidListRepository.findById(bidList.getBidListId()); + + assertThat(bidListResult).isNotNull(); + assertThat(bidListResult).isPresent(); + assertThat(bidListResult.get().getBidListId()).isEqualTo(bidList.getBidListId()); + } + + @DisplayName(value = "3°) Mise à jour d'un BidList Existant") + @Order(3) + @Test + void test_update_should_update_BidList() throws ParseException { + DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy"); + Date date = dateFormat.parse("02/09/2024"); + + + BidList bidList = new BidList(); + bidList.setBidListId(1); + bidList.setAccount("testAccount"); + bidList.setType("testType"); + bidList.setBidQuantity(10.00); + bidList.setBid(1.0); + bidList.setAsk(10.00); + bidList.setBenchmark("testBencjmark"); + bidList.setAskQuantity(10.11); + bidList.setBidListDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setCommentary("testCommentary"); + bidList.setSecurity("testSecurity"); + bidList.setStatus("testStatus"); + bidList.setTrader("testTrade"); + bidList.setBook("testBook"); + bidList.setCreationName("testCreationName"); + bidList.setCreationDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setRevisionName("testRevisionName"); + bidList.setRevisionDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setDealName("testDealName"); + bidList.setDealType("testDealType"); + bidList.setSourceListId("testSourceListId"); + bidList.setSide("testSide"); + + BidList bidListUpdated = new BidList(); + bidListUpdated.setBidListId(1); + bidListUpdated.setAccount("testSuccessAccountUpdated"); + bidListUpdated.setType("testSuccessTypeUpdated"); + bidListUpdated.setBidQuantity(20.00); + bidListUpdated.setBid(20.0); + bidListUpdated.setAsk(200.00); + bidListUpdated.setBenchmark("testSuccessBencjmarkUpdated"); + bidListUpdated.setAskQuantity(22.22); + bidListUpdated.setBidListDate(new Timestamp(date.getTime())); + bidListUpdated.setCommentary("testSuccessCommentaryUpdated"); + bidListUpdated.setSecurity("testSuccessSecurityUpdated"); + bidListUpdated.setStatus("testSuccessStatusUpdated"); + bidListUpdated.setTrader("testSuccessTradeUpdated"); + bidListUpdated.setBook("testSuccessBookUpdated"); + bidListUpdated.setCreationName("testSuccessCreationNameUpdated"); + bidListUpdated.setCreationDate(new Timestamp(date.getTime())); + bidListUpdated.setRevisionName("testSuccessRrevisionNameUpdated"); + bidListUpdated.setRevisionDate(new Timestamp(date.getTime())); + bidListUpdated.setDealName("testSuccessDealNameUpdated"); + bidListUpdated.setDealType("testSuccessDealTypeUpdated"); + bidListUpdated.setSourceListId("testSuccessSourceListIdUpdated"); + bidListUpdated.setSide("testSuccessSideUpdated"); + + when(bidListRepository.save(any(BidList.class))).thenReturn(bidListUpdated); + + BidList bidListResult = bidListRepository.save(bidList); + + assertThat(bidListResult).isNotNull(); + assertThat(bidListResult.getBidListId()).isEqualTo(bidListUpdated.getBidListId()); + assertThat(bidListResult.getAccount()).isEqualTo(bidListUpdated.getAccount()); + assertThat(bidListResult.getType()).isEqualTo(bidListUpdated.getType()); + assertThat(bidListResult.getBidQuantity()).isEqualTo(bidListUpdated.getBidQuantity()); + assertThat(bidListResult.getBid()).isEqualTo(bidListUpdated.getBid()); + assertThat(bidListResult.getAsk()).isEqualTo(bidListUpdated.getAsk()); + assertThat(bidListResult.getBenchmark()).isEqualTo(bidListUpdated.getBenchmark()); + assertThat(bidListResult.getAskQuantity()).isEqualTo(bidListUpdated.getAskQuantity()); + assertThat(bidListResult.getBidListDate()).isEqualTo(bidListUpdated.getBidListDate()); + assertThat(bidListResult.getCommentary()).isEqualTo(bidListUpdated.getCommentary()); + assertThat(bidListResult.getSecurity()).isEqualTo(bidListUpdated.getSecurity()); + assertThat(bidListResult.getStatus()).isEqualTo(bidListUpdated.getStatus()); + assertThat(bidListResult.getTrader()).isEqualTo(bidListUpdated.getTrader()); + assertThat(bidListResult.getBook()).isEqualTo(bidListUpdated.getBook()); + assertThat(bidListResult.getCreationName()).isEqualTo(bidListUpdated.getCreationName()); + assertThat(bidListResult.getCreationDate()).isEqualTo(bidListUpdated.getCreationDate()); + assertThat(bidListResult.getRevisionName()).isEqualTo(bidListUpdated.getRevisionName()); + assertThat(bidListResult.getRevisionDate()).isEqualTo(bidListUpdated.getRevisionDate()); + assertThat(bidListResult.getDealName()).isEqualTo(bidListUpdated.getDealName()); + assertThat(bidListResult.getDealType()).isEqualTo(bidListUpdated.getDealType()); + assertThat(bidListResult.getSourceListId()).isEqualTo(bidListUpdated.getSourceListId()); + assertThat(bidListResult.getSide()).isEqualTo(bidListUpdated.getSide()); + } + + @DisplayName(value = "4°) Suppression de BidList par ID") + @Order(4) + @Test + void test_delete_shoud_deleteBidList_By_Id() { + BidList bidList = new BidList(); + bidList.setBidListId(1); + bidList.setAccount("testAccount"); + bidList.setType("testType"); + bidList.setBidQuantity(10.00); + bidList.setBid(1.0); + bidList.setAsk(10.00); + bidList.setBenchmark("testBencjmark"); + bidList.setAskQuantity(10.11); + bidList.setBidListDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setCommentary("testCommentary"); + bidList.setSecurity("testSecurity"); + bidList.setStatus("testStatus"); + bidList.setTrader("testTrade"); + bidList.setBook("testBook"); + bidList.setCreationName("testCreationName"); + bidList.setCreationDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setRevisionName("testRevisionName"); + bidList.setRevisionDate(Timestamp.valueOf(LocalDateTime.now())); + bidList.setDealName("testDealName"); + bidList.setDealType("testDealType"); + bidList.setSourceListId("testSourceListId"); + bidList.setSide("testSide"); + //TODO:QUESTION : Est-ce que le test est valide comme ça + bidListRepository.deleteById(bidList.getBidListId()); + } +} diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/CurvePointRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/CurvePointRepositoryTest.java new file mode 100644 index 0000000000..5377c59fef --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/CurvePointRepositoryTest.java @@ -0,0 +1,133 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.CurvePoint; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class CurvePointRepositoryTest { + @Mock + private CurvePointRepository curvePointRepository; + + @BeforeEach + private void setup() { + curvePointRepository = Mockito.mock(CurvePointRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les CurvePoints") + @Order(1) + @Test + void test_findAll_should_FindAll_CurvePoint() { + List curvePointList = new ArrayList<>(); + + CurvePoint curvePoint = new CurvePoint(); + CurvePoint curvePoint2 = new CurvePoint(); + CurvePoint curvePoint3 = new CurvePoint(); + CurvePoint curvePoint4 = new CurvePoint(); + CurvePoint curvePoint5 = new CurvePoint(); + + curvePointList.add(curvePoint); + curvePointList.add(curvePoint2); + curvePointList.add(curvePoint3); + curvePointList.add(curvePoint4); + curvePointList.add(curvePoint5); + + when(curvePointRepository.findAll()).thenReturn(curvePointList); + + List result = curvePointRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(curvePointList.size()); + } + + @DisplayName(value = "2°) Recherche de CurvePoint par ID") + @Order(2) + @Test + void test_findById_shoud_findCurvePoint_By_Id() throws ParseException { + DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy"); + Date date = dateFormat.parse("02/09/2023"); + + CurvePoint curvePoint = new CurvePoint(1, 1, new Timestamp(date.getTime()), + 1.0, 5.2, new Timestamp(new Date().getTime())); + + when(curvePointRepository.findById(anyInt())).thenReturn(Optional.of(curvePoint)); + + Optional curvePointResult = curvePointRepository.findById(curvePoint.getId()); + + assertThat(curvePointResult).isNotNull(); + assertThat(curvePointResult).isPresent(); + assertThat(curvePointResult.get().getId()).isEqualTo(curvePoint.getId()); + } + + @DisplayName(value = "3°) Mise à jour d'un CurvePoint Existant") + @Order(3) + @Test + void test_update_should_update_CurvePoint() throws ParseException { + DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy"); + Date date = dateFormat.parse("02/05/2023"); + + CurvePoint curvePoint = new CurvePoint(); + curvePoint.setId(1); + curvePoint.setCurveId(1); + curvePoint.setAsOfDate(new Timestamp(date.getTime())); + curvePoint.setTerm(10.0); + curvePoint.setValue(15.50); + curvePoint.setCreationDate(new Timestamp(new Date().getTime())); + + CurvePoint curvePointUdate = new CurvePoint(); + curvePointUdate.setId(1); + curvePointUdate.setCurveId(3); + curvePointUdate.setAsOfDate(new Timestamp(date.getTime())); + curvePointUdate.setTerm(50.0); + curvePointUdate.setValue(40.50); + curvePointUdate.setCreationDate(new Timestamp(new Date().getTime())); + + when(curvePointRepository.save(any(CurvePoint.class))).thenReturn(curvePoint); + + CurvePoint curvePointResult = curvePointRepository.save(curvePoint); + + assertThat(curvePointResult).isNotNull(); + assertThat(curvePointResult.getId()).isEqualTo(curvePointUdate.getId()); + assertThat(curvePointResult.getCurveId()).isEqualTo(curvePointUdate.getCurveId()); + assertThat(curvePointResult.getAsOfDate()).isEqualTo(curvePointUdate.getAsOfDate()); + assertThat(curvePointResult.getTerm()).isEqualTo(curvePointUdate.getTerm()); + assertThat(curvePointResult.getValue()).isEqualTo(curvePointUdate.getValue()); + assertThat(curvePointResult.getCreationDate()).isEqualTo(curvePointUdate.getCreationDate()); + } + + @DisplayName(value = "4°) Suppression de CurvePoint par ID") + @Order(4) + @Test + void test_delete_shoud_deleteCurvePoint_By_Id() { + CurvePoint curvePoint = new CurvePoint(); + curvePoint.setId(1); + curvePoint.setCurveId(1); + curvePoint.setAsOfDate(new Timestamp(new Date().getTime())); + curvePoint.setTerm(10.0); + curvePoint.setValue(15.50); + curvePoint.setCreationDate(new Timestamp(new Date().getTime())); + + curvePointRepository.deleteById(curvePoint.getId()); + } +} diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RatingRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RatingRepositoryTest.java new file mode 100644 index 0000000000..982528e226 --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RatingRepositoryTest.java @@ -0,0 +1,115 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.Rating; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class RatingRepositoryTest { + @Mock + private RatingRepository ratingRepository; + + @BeforeEach + private void setup() { + ratingRepository = Mockito.mock(RatingRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les Ratings") + @Order(1) + @Test + void test_findAll_should_FindAll_Rating() { + List ratingList = new ArrayList<>(); + + Rating rating1 = new Rating(); + Rating rating2 = new Rating(); + Rating rating3 = new Rating(); + Rating rating4 = new Rating(); + + ratingList.add(rating1); + ratingList.add(rating2); + ratingList.add(rating3); + ratingList.add(rating4); + + when(ratingRepository.findAll()).thenReturn(ratingList); + + List result = ratingRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(ratingList.size()); + } + + @DisplayName(value = "2°) Recherche de Rating par ID") + @Order(2) + @Test + void test_findById_shoud_findRating_By_Id() { + Rating rating = new Rating(1, "moddysTest", "sandPTest", "fitchTest", 1); + + when(ratingRepository.findById(anyInt())).thenReturn(Optional.of(rating)); + + Optional ratingResult = ratingRepository.findById(rating.getId()); + + assertThat(ratingResult).isNotNull(); + assertThat(ratingResult).isPresent(); + assertThat(ratingResult.get().getId()).isEqualTo(rating.getId()); + } + + @DisplayName(value = "3°) Mise à jour d'un Rating Existant") + @Order(3) + @Test + void test_update_should_update_Rating() { + Rating rating = new Rating(); + rating.setId(1); + rating.setMoodysRating("moddysTest"); + rating.setSandPRating("sandPTest"); + rating.setFitchRating("fitchTest"); + rating.setOrderNumber(2); + + Rating ratingUpdated = new Rating(); + ratingUpdated.setId(1); + ratingUpdated.setMoodysRating("moddysTestUpdated"); + ratingUpdated.setSandPRating("sandPTestUpdated"); + ratingUpdated.setFitchRating("fitchTestUpdated"); + ratingUpdated.setOrderNumber(3); + + when(ratingRepository.save(any(Rating.class))).thenReturn(ratingUpdated); + + Rating ratingResult = ratingRepository.save(rating); + + assertThat(ratingResult).isNotNull(); + assertThat(ratingResult.getId()).isEqualTo(ratingUpdated.getId()); + assertThat(ratingResult.getMoodysRating()).isEqualTo(ratingUpdated.getMoodysRating()); + assertThat(ratingResult.getSandPRating()).isEqualTo(ratingUpdated.getSandPRating()); + assertThat(ratingResult.getFitchRating()).isEqualTo(ratingUpdated.getFitchRating()); + assertThat(ratingResult.getOrderNumber()).isEqualTo(ratingUpdated.getOrderNumber()); + } + + @DisplayName(value = "4°) Suppression de Rating par ID") + @Order(4) + @Test + void test_delete_shoud_deleteRating_By_Id() { + Rating rating = new Rating(); + rating.setId(1); + rating.setMoodysRating("moddysTest"); + rating.setSandPRating("sandPTest"); + rating.setFitchRating("fitchTest"); + rating.setOrderNumber(1); + + ratingRepository.deleteById(rating.getId()); + } +} diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RuleNameRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RuleNameRepositoryTest.java new file mode 100644 index 0000000000..044cb1d785 --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/RuleNameRepositoryTest.java @@ -0,0 +1,122 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.RuleName; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class RuleNameRepositoryTest { + @Mock + private RuleNameRepository ruleNameRepository; + + @BeforeEach + private void setup() { + ruleNameRepository = Mockito.mock(RuleNameRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les RuleName") + @Order(1) + @Test + void test_findAll_should_FindAll_RuleName() { + List ruleNameList = new ArrayList<>(); + + RuleName ruleName1 = new RuleName(); + RuleName ruleName2 = new RuleName(); + RuleName ruleName3 = new RuleName(); + + ruleNameList.add(ruleName1); + ruleNameList.add(ruleName2); + ruleNameList.add(ruleName3); + + when(ruleNameRepository.findAll()).thenReturn(ruleNameList); + + List result = ruleNameRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(ruleNameList.size()); + } + + @DisplayName(value = "2°) Recherche de RuleName par ID") + @Order(2) + @Test + void test_findById_shoud_findRuleName_By_Id() { + RuleName ruleName = new RuleName(1, "nameTest", "descriptionTest", "{ \"message\" : \"message breaks json\" }", + "templateTest", "sqlStrTest", "sqlPartTest"); + + when(ruleNameRepository.findById(anyInt())).thenReturn(Optional.of(ruleName)); + + Optional ruleNameResult = ruleNameRepository.findById(ruleName.getId()); + + assertThat(ruleNameResult).isNotNull(); + assertThat(ruleNameResult).isPresent(); + assertThat(ruleNameResult.get().getId()).isEqualTo(ruleName.getId()); + } + + @DisplayName(value = "3°) Mise à jour d'un RuleName Existant") + @Order(3) + @Test + void test_update_should_update_RuleName() { + RuleName ruleName = new RuleName(); + ruleName.setId(1); + ruleName.setName("nameTest"); + ruleName.setDescription("descriptionTest"); + ruleName.setJson("{ \"message\" : \"message breaks json\" }"); + ruleName.setTemplate("templateTest"); + ruleName.setSqlStr("sqlStrTest"); + ruleName.setSqlPart("sqlPartTest"); + + RuleName ruleNameUpdated = new RuleName(); + ruleNameUpdated.setId(1); + ruleNameUpdated.setName("nameTestUpdated"); + ruleNameUpdated.setDescription("descriptionTestUpdated"); + ruleNameUpdated.setJson("{ \"message\" : \"message breaks json Updated\" }"); + ruleNameUpdated.setTemplate("templateTestUpdated"); + ruleNameUpdated.setSqlStr("sqlStrTestUpdated"); + ruleNameUpdated.setSqlPart("sqlPartTestUpdated"); + + when(ruleNameRepository.save(any(RuleName.class))).thenReturn(ruleNameUpdated); + + RuleName ruleNameResult = ruleNameRepository.save(ruleName); + + assertThat(ruleNameResult).isNotNull(); + assertThat(ruleNameResult.getId()).isEqualTo(ruleNameUpdated.getId()); + assertThat(ruleNameResult.getName()).isEqualTo(ruleNameUpdated.getName()); + assertThat(ruleNameResult.getDescription()).isEqualTo(ruleNameUpdated.getDescription()); + assertThat(ruleNameResult.getJson()).isEqualTo(ruleNameUpdated.getJson()); + assertThat(ruleNameResult.getTemplate()).isEqualTo(ruleNameUpdated.getTemplate()); + assertThat(ruleNameResult.getSqlStr()).isEqualTo(ruleNameUpdated.getSqlStr()); + assertThat(ruleNameResult.getSqlPart()).isEqualTo(ruleNameUpdated.getSqlPart()); + } + + @DisplayName(value = "4°) Suppression de RuleName par ID") + @Order(4) + @Test + void test_delete_shoud_deleteRuleName_By_Id() { + RuleName ruleName = new RuleName(); + ruleName.setId(1); + ruleName.setName("nameTest"); + ruleName.setDescription("descriptionTest"); + ruleName.setJson("{ \"message\" : \"message breaks json\" }"); + ruleName.setTemplate("templateTest"); + ruleName.setSqlStr("sqlStrTest"); + ruleName.setSqlPart("sqlPartTest"); + + ruleNameRepository.deleteById(ruleName.getId()); + } +} diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/TradeRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/TradeRepositoryTest.java new file mode 100644 index 0000000000..e593684168 --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/TradeRepositoryTest.java @@ -0,0 +1,187 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.Trade; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class TradeRepositoryTest { + @Mock + private TradeRepository tradeRepository; + + @BeforeEach + private void setup() { + tradeRepository = Mockito.mock(TradeRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les Trade") + @Order(1) + @Test + void test_findAll_should_FindAll_Trade() { + List tradeList = new ArrayList<>(); + + Trade trade1 = new Trade(); + Trade trade2 = new Trade(); + Trade trade3 = new Trade(); + Trade trade4 = new Trade(); + Trade trade5 = new Trade(); + + tradeList.add(trade1); + tradeList.add(trade2); + tradeList.add(trade3); + tradeList.add(trade4); + tradeList.add(trade5); + + when(tradeRepository.findAll()).thenReturn(tradeList); + + List result = tradeRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(tradeList.size()); + } + + @DisplayName(value = "2°) Recherche de Trade par ID") + @Order(2) + @Test + void test_findById_shoud_findTrade_By_Id() { + Trade trade = new Trade(1, "accountTest", "typeTest", 5.00, 10.00, 30.00, + 60.00, "benchmarkTest", new Timestamp(new Date().getTime()), "securityTest", "statusTest", + "traderTest", "bookTest", "creationNameTest", new Timestamp(new Date().getTime()), + "revisionNameTest", new Timestamp(new Date().getTime()), "dealNameTest", "dealTypeTest", + "sourceListIdTest", "sideTest"); + + when(tradeRepository.findById(anyInt())).thenReturn(Optional.of(trade)); + + Optional tradeResult = tradeRepository.findById(trade.getTradeId()); + + assertThat(tradeResult).isNotNull(); + assertThat(tradeResult).isPresent(); + assertThat(tradeResult.get().getTradeId()).isEqualTo(trade.getTradeId()); + } + + @DisplayName(value = "3°) Mise à jour d'un Trade Existant") + @Order(3) + @Test + void test_update_should_update_Trade() { + Trade trade = new Trade(); + trade.setTradeId(1); + trade.setAccount("accountTest"); + trade.setType("typeTest"); + trade.setBuyQuantity(5.00); + trade.setSellQuantity(10.00); + trade.setBuyPrice(30.00); + trade.setSellPrice(60.00); + trade.setBenchmark("benchmarkTest"); + trade.setTradeDate(new Timestamp(new Date().getTime())); + trade.setSecurity("securityTest"); + trade.setStatus("statusTest"); + trade.setTrader("traderTest"); + trade.setBook("bookTest"); + trade.setCreationName("creationNameTest"); + trade.setCreationDate(new Timestamp(new Date().getTime())); + trade.setRevisionName("revisionNameTest"); + trade.setRevisionDate(new Timestamp(new Date().getTime())); + trade.setDealName("dealNameTest"); + trade.setDealType("dealTypeTest"); + trade.setSourceListId("sourceListIdTest"); + trade.setSide("sideTest"); + + Trade tradeUpdated = new Trade(); + tradeUpdated.setTradeId(1); + tradeUpdated.setAccount("accountTestUpdated"); + tradeUpdated.setType("typeTestUpdated"); + tradeUpdated.setBuyQuantity(15.00); + tradeUpdated.setSellQuantity(20.00); + tradeUpdated.setBuyPrice(40.00); + tradeUpdated.setSellPrice(80.00); + tradeUpdated.setBenchmark("benchmarkTestUpdated"); + tradeUpdated.setTradeDate(new Timestamp(new Date().getTime())); + tradeUpdated.setSecurity("securityTestUpdated"); + tradeUpdated.setStatus("statusTestUpdated"); + tradeUpdated.setTrader("traderTestUpdated"); + tradeUpdated.setBook("bookTestUpdated"); + tradeUpdated.setCreationName("creationNameTestUpdated"); + tradeUpdated.setCreationDate(new Timestamp(new Date().getTime())); + tradeUpdated.setRevisionName("revisionNameTestUpdated"); + tradeUpdated.setRevisionDate(new Timestamp(new Date().getTime())); + tradeUpdated.setDealName("dealNameTestUpdated"); + tradeUpdated.setDealType("dealTypeTestUpdated"); + tradeUpdated.setSourceListId("sourceListIdTestUpdated"); + tradeUpdated.setSide("sideTestUpdated"); + + when(tradeRepository.save(any(Trade.class))).thenReturn(tradeUpdated); + + Trade tradeResult = tradeRepository.save(trade); + + assertThat(tradeResult).isNotNull(); + assertThat(tradeResult.getTradeId()).isEqualTo(tradeUpdated.getTradeId()); + assertThat(tradeResult.getAccount()).isEqualTo(tradeUpdated.getAccount()); + assertThat(tradeResult.getType()).isEqualTo(tradeUpdated.getType()); + assertThat(tradeResult.getBuyQuantity()).isEqualTo(tradeUpdated.getBuyQuantity()); + assertThat(tradeResult.getSellQuantity()).isEqualTo(tradeUpdated.getSellQuantity()); + assertThat(tradeResult.getBuyPrice()).isEqualTo(tradeUpdated.getBuyPrice()); + assertThat(tradeResult.getSellPrice()).isEqualTo(tradeUpdated.getSellPrice()); + assertThat(tradeResult.getBenchmark()).isEqualTo(tradeUpdated.getBenchmark()); + assertThat(tradeResult.getTradeDate()).isEqualTo(tradeUpdated.getTradeDate()); + assertThat(tradeResult.getSecurity()).isEqualTo(tradeUpdated.getSecurity()); + assertThat(tradeResult.getStatus()).isEqualTo(tradeUpdated.getStatus()); + assertThat(tradeResult.getTrader()).isEqualTo(tradeUpdated.getTrader()); + assertThat(tradeResult.getBook()).isEqualTo(tradeUpdated.getBook()); + assertThat(tradeResult.getCreationName()).isEqualTo(tradeUpdated.getCreationName()); + assertThat(tradeResult.getCreationDate()).isEqualTo(tradeUpdated.getCreationDate()); + assertThat(tradeResult.getRevisionName()).isEqualTo(tradeUpdated.getRevisionName()); + assertThat(tradeResult.getRevisionDate()).isEqualTo(tradeUpdated.getRevisionDate()); + assertThat(tradeResult.getDealName()).isEqualTo(tradeUpdated.getDealName()); + assertThat(tradeResult.getDealType()).isEqualTo(tradeUpdated.getDealType()); + assertThat(tradeResult.getSourceListId()).isEqualTo(tradeUpdated.getSourceListId()); + assertThat(tradeResult.getSide()).isEqualTo(tradeUpdated.getSide()); + } + + @DisplayName(value = "4°) Suppression de Trade par ID") + @Order(4) + @Test + void test_delete_shoud_deleteTrade_By_Id() { + Trade trade = new Trade(); + trade.setTradeId(1); + trade.setAccount("accountTest"); + trade.setType("typeTest"); + trade.setBuyQuantity(5.00); + trade.setSellQuantity(10.00); + trade.setBuyPrice(30.00); + trade.setSellPrice(60.00); + trade.setBenchmark("benchmarkTest"); + trade.setTradeDate(new Timestamp(new Date().getTime())); + trade.setSecurity("securityTest"); + trade.setStatus("statusTest"); + trade.setTrader("traderTest"); + trade.setBook("bookTest"); + trade.setCreationName("creationNameTest"); + trade.setCreationDate(new Timestamp(new Date().getTime())); + trade.setRevisionName("revisionNameTest"); + trade.setRevisionDate(new Timestamp(new Date().getTime())); + trade.setDealName("dealNameTest"); + trade.setDealType("dealTypeTest"); + trade.setSourceListId("sourceListIdTest"); + trade.setSide("sideTest"); + + tradeRepository.deleteById(trade.getTradeId()); + } +} diff --git a/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/UserRepositoryTest.java b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/UserRepositoryTest.java new file mode 100644 index 0000000000..0de3314d37 --- /dev/null +++ b/Poseiden-skeleton/src/test/java/com/nnk/springboot/repositories/UserRepositoryTest.java @@ -0,0 +1,113 @@ +package com.nnk.springboot.repositories; + +import com.nnk.springboot.domain.User; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class UserRepositoryTest { + @Mock + private UserRepository userRepository; + + private void setup() { + userRepository = Mockito.mock(UserRepository.class); + } + + @DisplayName(value = "1°) Recherche de tous les User") + @Order(1) + @Test + void test_findAll_should_FindAll_User() { + List userList = new ArrayList<>(); + + User user1 = new User(); + User user2 = new User(); + User user3 = new User(); + User user4 = new User(); + + userList.add(user1); + userList.add(user2); + userList.add(user3); + userList.add(user4); + + when(userRepository.findAll()).thenReturn(userList); + + List result = userRepository.findAll(); + + assertThat(result).isNotNull(); + assertThat(result).isNotEmpty(); + assertThat(result.size()).isEqualTo(userList.size()); + } + + @DisplayName(value = "2°) Recherche d'un User par ID") + @Order(2) + @Test + void test_findById_shoud_findUser_By_Id() { + User user = new User(1, "usernameTest", "passwordTest", "fullnameTest", "roleTest"); + + when(userRepository.findById(anyInt())).thenReturn(Optional.of(user)); + + Optional userResult = userRepository.findById(user.getId()); + + assertThat(userResult).isNotNull(); + assertThat(userResult).isPresent(); + assertThat(userResult.get().getId()).isEqualTo(user.getId()); + } + + @DisplayName(value = "3°) Mise à jour d'un User Existant") + @Order(3) + @Test + void test_update_should_update_User() { + User user = new User(); + user.setId(1); + user.setUsername("usernameTest"); + user.setPassword("passwordTest"); + user.setFullname("fullnameTest"); + user.setRole("role"); + + User userUpdated = new User(); + user.setId(1); + user.setUsername("usernameTestUpdated"); + user.setPassword("passwordTestUpdated"); + user.setFullname("fullnameTestUpdated"); + user.setRole("roleTestUpdated"); + + when(userRepository.save(any(User.class))).thenReturn(userUpdated); + + User userResult = userRepository.save(user); + + assertThat(userResult).isNotNull(); + assertThat(userResult.getId()).isEqualTo(userUpdated.getId()); + assertThat(userResult.getUsername()).isEqualTo(userUpdated.getUsername()); + assertThat(userResult.getPassword()).isEqualTo(userUpdated.getPassword()); + assertThat(userResult.getFullname()).isEqualTo(userUpdated.getFullname()); + assertThat(userResult.getRole()).isEqualTo(userUpdated.getRole()); + } + + @DisplayName(value = "4°) Suppression d'un User par ID") + @Order(4) + @Test + void test_delete_shoud_deleteUser_By_Id() { + User user = new User(); + user.setId(1); + user.setUsername("usernameTest"); + user.setPassword("passwordTest"); + user.setFullname("fullnameTest"); + user.setRole("role"); + + userRepository.deleteById(user.getId()); + } +} From 3e3e55673111933a1c57e31e3b031224f6ec53c0 Mon Sep 17 00:00:00 2001 From: abel Date: Sat, 8 Apr 2023 23:33:49 +0200 Subject: [PATCH 5/6] POS-5 : Modification des fichiers du package domain MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit -Ajout de @Data(lombok) sur les modèles -Ajout de @Id sur les identifiants manquant --- .../com/nnk/springboot/domain/BidList.java | 29 +++++++++++- .../com/nnk/springboot/domain/CurvePoint.java | 16 ++++++- .../com/nnk/springboot/domain/Rating.java | 15 +++++- .../com/nnk/springboot/domain/RuleName.java | 17 ++++++- .../java/com/nnk/springboot/domain/Trade.java | 31 +++++++++++- .../java/com/nnk/springboot/domain/User.java | 47 +++---------------- 6 files changed, 110 insertions(+), 45 deletions(-) diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/BidList.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/BidList.java index 3a0e27efc8..1bb7fa137c 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/BidList.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/BidList.java @@ -1,5 +1,8 @@ package com.nnk.springboot.domain; +import lombok.Data; +import lombok.Getter; +import lombok.Setter; import org.springframework.beans.factory.annotation.Required; import javax.persistence.*; @@ -10,6 +13,30 @@ @Entity @Table(name = "bidlist") +@Data public class BidList { - // TODO: Map columns in data table BIDLIST with corresponding java fields + @Id + @GeneratedValue(strategy= GenerationType.AUTO) + private Integer BidListId; + private String account; + private String type; + private Double bidQuantity; + private Double askQuantity; + private Double bid; + private Double ask; + private String benchmark; + private Timestamp bidListDate; + private String commentary; + private String security; + private String status; + private String trader; + private String book; + private String creationName; + private Timestamp creationDate; + private String revisionName; + private Timestamp revisionDate; + private String dealName; + private String dealType; + private String sourceListId; + private String side; } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/CurvePoint.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/CurvePoint.java index 151f80d02f..501c7a3dae 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/CurvePoint.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/CurvePoint.java @@ -1,5 +1,8 @@ package com.nnk.springboot.domain; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; import org.hibernate.validator.constraints.Length; import javax.persistence.*; @@ -10,6 +13,17 @@ @Entity @Table(name = "curvepoint") +@Data +@AllArgsConstructor +@NoArgsConstructor public class CurvePoint { - // TODO: Map columns in data table CURVEPOINT with corresponding java fields + @Id + @GeneratedValue(strategy= GenerationType.AUTO) + private Integer id; + private Integer curveId; + private Timestamp asOfDate; + private Double term; + private Double value; + private Timestamp creationDate; + } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Rating.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Rating.java index 12d1be58c0..30469c9d0d 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Rating.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Rating.java @@ -1,5 +1,9 @@ package com.nnk.springboot.domain; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + import javax.persistence.*; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; @@ -7,6 +11,15 @@ @Entity @Table(name = "rating") +@Data +@NoArgsConstructor +@AllArgsConstructor public class Rating { - // TODO: Map columns in data table RATING with corresponding java fields + @Id + @GeneratedValue(strategy= GenerationType.AUTO) + private Integer id; + private String moodysRating; + private String sandPRating; + private String fitchRating; + private Integer orderNumber; } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/RuleName.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/RuleName.java index b8ac970edf..2d6b5805a0 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/RuleName.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/RuleName.java @@ -1,11 +1,26 @@ package com.nnk.springboot.domain; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + import javax.persistence.*; import javax.validation.constraints.NotBlank; import java.sql.Timestamp; @Entity @Table(name = "rulename") +@Data +@NoArgsConstructor +@AllArgsConstructor public class RuleName { - // TODO: Map columns in data table RULENAME with corresponding java fields + @Id + @GeneratedValue(strategy= GenerationType.AUTO) + private Integer id; + private String name; + private String description; + private String json; + private String template; + private String sqlStr; + private String sqlPart; } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Trade.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Trade.java index b6db7c13b7..a45016f36a 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Trade.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/Trade.java @@ -1,5 +1,9 @@ package com.nnk.springboot.domain; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + import javax.persistence.*; import javax.validation.constraints.NotBlank; import java.sql.Timestamp; @@ -7,6 +11,31 @@ @Entity @Table(name = "trade") +@Data +@NoArgsConstructor +@AllArgsConstructor public class Trade { - // TODO: Map columns in data table TRADE with corresponding java fields + @Id + @GeneratedValue(strategy= GenerationType.AUTO) + private Integer tradeId; + private String account; + private String type; + private Double buyQuantity; + private Double sellQuantity; + private Double buyPrice; + private Double sellPrice; + private String benchmark; + private Timestamp tradeDate; + private String security; + private String status; + private String trader; + private String book; + private String creationName; + private Timestamp creationDate; + private String revisionName; + private Timestamp revisionDate; + private String dealName; + private String dealType; + private String sourceListId; + private String side; } diff --git a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/User.java b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/User.java index 2be0b8c4ab..f7d6ffe34a 100644 --- a/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/User.java +++ b/Poseiden-skeleton/src/main/java/com/nnk/springboot/domain/User.java @@ -1,10 +1,17 @@ package com.nnk.springboot.domain; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + import javax.persistence.*; import javax.validation.constraints.NotBlank; @Entity @Table(name = "users") +@Data +@NoArgsConstructor +@AllArgsConstructor public class User { @Id @GeneratedValue(strategy= GenerationType.AUTO) @@ -17,44 +24,4 @@ public class User { private String fullname; @NotBlank(message = "Role is mandatory") private String role; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getUsername() { - return username; - } - - public void setUsername(String username) { - this.username = username; - } - - public String getPassword() { - return password; - } - - public void setPassword(String password) { - this.password = password; - } - - public String getFullname() { - return fullname; - } - - public void setFullname(String fullname) { - this.fullname = fullname; - } - - public String getRole() { - return role; - } - - public void setRole(String role) { - this.role = role; - } } From 53dc85d2efe1ec984e3707cea21fb8e96ff9ad08 Mon Sep 17 00:00:00 2001 From: abel Date: Sun, 21 May 2023 19:40:45 +0200 Subject: [PATCH 6/6] POS 6 - Rework pom.xml --- Poseiden-skeleton/pom.xml | 521 +++++++++++++++++++------------------- 1 file changed, 267 insertions(+), 254 deletions(-) diff --git a/Poseiden-skeleton/pom.xml b/Poseiden-skeleton/pom.xml index 1812ceaee5..1787538f69 100644 --- a/Poseiden-skeleton/pom.xml +++ b/Poseiden-skeleton/pom.xml @@ -1,263 +1,276 @@ - - 4.0.0 + + 4.0.0 - net.guides.springboothelloworld - spring-boot-skeleton - 0.0.1-SNAPSHOT - jar + net.guides.springboothelloworld + spring-boot-skeleton + 0.0.1-SNAPSHOT + jar - spring-boot-skeleton - Demo project for Spring Boot + spring-boot-skeleton + Demo project for Spring Boot - - org.springframework.boot - spring-boot-starter-parent - 2.7.8 - - + + org.springframework.boot + spring-boot-starter-parent + 2.7.8 + + - - UTF-8 - UTF-8 - 1.8 - 2.7.8 - 8.0.0.Final - 5.9.2 - 1.9.2 - 3.24.2 - 0.8.8 - 3.0.0 - 1.18.26 - 3.4.2 - 3.7.1 - 2.0.1.Final - + + UTF-8 + UTF-8 + 1.8 + 2.7.8 + 8.0.32 + 6.2.5.Final + 5.9.2 + 1.9.2 + 3.24.2 + 0.8.8 + 3.0.0 + 1.18.26 + 3.4.2 + 3.7.1 + 2.0.1.Final + - - - org.springframework.boot - spring-boot-starter-test - test - - - org.springframework.boot - spring-boot-starter-data-jpa - - - org.springframework.boot - spring-boot-starter-web - - - org.springframework.boot - spring-boot-starter-thymeleaf - - - org.springframework.boot - spring-boot-starter-security - - - org.springframework.boot - spring-boot-devtools - true - - - com.mysql - mysql-connector-j - runtime - - - com.h2database - h2 - - - - org.projectlombok - lombok - ${lombok.version} - true - - - - org.junit.jupiter - junit-jupiter-api - ${junit-jupiter.version} - test - - - org.junit.vintage - junit-vintage-engine - test - - - org.hamcrest - hamcrest-core - - - - - - org.junit.platform - junit-platform-runner - ${junit-platform.version} - test - - - - org.assertj - assertj-core - ${assertj.version} - test - - - javax.validation - validation-api - ${validation-api.version} - - - org.hibernate.validator - hibernate-validator - ${hibernate-validator.version} - - - org.jacoco - jacoco-maven-plugin - ${jacoco.version} - maven-plugin - - - org.apache.maven.plugins - maven-failsafe-plugin - ${failsafe.version} - test - - - - org.apache.maven.plugins - maven-project-info-reports-plugin - ${maven-project-info-reports-plugin.version} - - + + + org.springframework.boot + spring-boot-starter-test + test + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-starter-thymeleaf + + + org.springframework.boot + spring-boot-starter-security + + + org.springframework.security + spring-security-test + test + + + org.springframework.boot + spring-boot-devtools + true + + + + mysql + mysql-connector-java + ${mysql-connector-java.version} + - - - - org.springframework.boot - spring-boot-maven-plugin - - - org.jacoco - jacoco-maven-plugin - ${jacoco.version} - - - pre-unit-test - - prepare-agent - - - ${project.build.directory}/coverage-reports/jacoco-ut.exec - surefireArgLine - - - - post-unit-test - test - - report - - - ${project.build.directory}/coverage-reports/jacoco-ut.exec - ${project.reporting.outputDirectory}/jacoco-ut - - - - pre-integration-test - pre-integration-test - - prepare-agent - - - ${project.build.directory}/coverage-reports/jacoco-it.exec - failsafeArgLine - - - - post-integration-test - post-integration-test - - report - - - ${project.build.directory}/coverage-reports/jacoco-it.exec - ${project.reporting.outputDirectory}/jacoco-it - - - - - - org.springframework.boot - spring-boot-maven-plugin - - - - org.project-lombok - lombok - - - - - - org.apache.maven.plugins - maven-compiler-plugin - - 9 - 9 - - - - - org.apache.maven.plugins - maven-surefire-plugin - - - ${surefireArgLine} - - **/IT*.java - - - - - - org.apache.maven.plugins - maven-failsafe-plugin - - - integration-tests - - integration-test - verify - - - - ${failsafeArgLine} - - - - - - org.apache.maven.plugins - maven-site-plugin - ${maven-site-plugin.version} - + + com.h2database + h2 + + + + org.projectlombok + lombok + ${lombok.version} + true + + + + org.junit.jupiter + junit-jupiter-api + ${junit-jupiter.version} + test + + + org.junit.vintage + junit-vintage-engine + test + + + org.hamcrest + hamcrest-core + + + + + + org.junit.platform + junit-platform-runner + ${junit-platform.version} + test + + + + org.assertj + assertj-core + ${assertj.version} + test + + + javax.validation + validation-api + ${validation-api.version} + + + org.hibernate.validator + hibernate-validator + ${hibernate-validator.version} + + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + maven-plugin + + + org.apache.maven.plugins + maven-failsafe-plugin + ${failsafe.version} + test + + + + org.apache.maven.plugins + maven-project-info-reports-plugin + ${maven-project-info-reports-plugin.version} + + + org.hibernate + hibernate-validator-annotation-processor + 6.2.5.Final + + - - org.apache.maven.plugins - maven-project-info-reports-plugin - ${maven-project-info-reports-plugin.version} - - - + + + + org.springframework.boot + spring-boot-maven-plugin + + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + + + pre-unit-test + + prepare-agent + + + ${project.build.directory}/coverage-reports/jacoco-ut.exec + surefireArgLine + + + + post-unit-test + test + + report + + + ${project.build.directory}/coverage-reports/jacoco-ut.exec + ${project.reporting.outputDirectory}/jacoco-ut + + + + pre-integration-test + pre-integration-test + + prepare-agent + + + ${project.build.directory}/coverage-reports/jacoco-it.exec + failsafeArgLine + + + + post-integration-test + post-integration-test + + report + + + ${project.build.directory}/coverage-reports/jacoco-it.exec + ${project.reporting.outputDirectory}/jacoco-it + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.project-lombok + lombok + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 9 + 9 + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + ${surefireArgLine} + + **/IT*.java + + + + + + org.apache.maven.plugins + maven-failsafe-plugin + + + integration-tests + + integration-test + verify + + + + ${failsafeArgLine} + + + + + + org.apache.maven.plugins + maven-site-plugin + ${maven-site-plugin.version} + + + + org.apache.maven.plugins + maven-project-info-reports-plugin + ${maven-project-info-reports-plugin.version} + + +