From d863f809d9d177280fc88f0bca32cebd625950e7 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 14:56:23 +0200 Subject: [PATCH 001/109] feat: method for PropertiesLoggerTest.java --- .../configuration/PropertiesLoggerTest.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/configuration/PropertiesLoggerTest.java diff --git a/src/test/java/fr/insee/rmes/configuration/PropertiesLoggerTest.java b/src/test/java/fr/insee/rmes/configuration/PropertiesLoggerTest.java new file mode 100644 index 000000000..365754573 --- /dev/null +++ b/src/test/java/fr/insee/rmes/configuration/PropertiesLoggerTest.java @@ -0,0 +1,23 @@ +package fr.insee.rmes.configuration; + +import org.junit.jupiter.api.Test; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import static org.junit.jupiter.api.Assertions.*; + +class PropertiesLoggerTest { + + @Test + void shouldCheckForDuplicatesWhenConsideringStaticElements(){ + List actualStaticElements = List.of(PropertiesLogger.PROPERTY_KEY_FOR_PREFIXES, + PropertiesLogger.PROPERTY_KEY_FOR_MORE_HIDDEN, + PropertiesLogger.PROPERTY_KEY_FOR_SOURCES_IGNORED, + PropertiesLogger.PROPERTY_KEY_FOR_SOURCES_SELECT); + Set expectedStaticElements = new HashSet<>(actualStaticElements); + assertEquals(expectedStaticElements.size(),actualStaticElements.size()); + } + + +} \ No newline at end of file From 5e47b78c7deaf5cc87e73d394d3e87f10e72fa16 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 14:59:14 +0200 Subject: [PATCH 002/109] feat : method for DataSetTest.java --- .../rmes/model/datasets/DataSetTest.java | 124 ++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java b/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java new file mode 100644 index 000000000..92d6fac61 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java @@ -0,0 +1,124 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class DataSetTest { + + String statutValidation="mockedStatutValidation"; + String dateCreation="mockedDateCreation"; + String names="mockedNames"; + String dateMiseAJour="mockedDateMiseAJour"; + String operationStat="mockedOperationStat"; + String titreLg1="mockedTitreLg1"; + String id="mockedId"; + String titreLg2="mockedTitreLg2"; + String uri="mockedUri"; + String serie = "mockedSerie"; + String idDataset1 = "idDataset1"; + String uriDataset1 = "uriDataset1"; + String titreFrDataset1="titreFrDataset1"; + String titreEnDataset1="titreEnDataset1"; + String s= "s"; + String publie = "publie"; + String s1= "s1"; + + DataSet firstDataSet = new DataSet(dateCreation, names, dateMiseAJour, serie, titreLg1, id, titreLg2, uri); + DataSet secondDataSet = new DataSet(statutValidation, dateCreation, names, dateMiseAJour, operationStat,titreLg1,id,titreLg2,uri); + DataSet thirdDataSet = new DataSet(idDataset1,uriDataset1,titreFrDataset1, titreEnDataset1, s, publie,s1); + + @ParameterizedTest + @ValueSource(strings = { "mockedDateCreation1", "mockedDateCreation2", "mockedDateCreation3" }) + void shouldCheckDateCreation(String mockedString){ + firstDataSet.setDateCreation(mockedString); + secondDataSet.withDateCreation(mockedString); + assertTrue(Objects.equals(firstDataSet.getDateCreation(), secondDataSet.getDateCreation()) && + Objects.equals(firstDataSet.getDateCreation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedName1", "mockedName2", "mockedName3" }) + void shouldCheckName(String mockedString){ + firstDataSet.setNames(mockedString); + thirdDataSet.withNames(mockedString); + assertTrue(Objects.equals(firstDataSet.getNames(), thirdDataSet.getNames()) && + Objects.equals(firstDataSet.getNames(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedDateMiseAJour1", "mockedDateMiseAJour2", "mockedDateMiseAJour3" }) + void shouldCheckDateMiseAJour(String mockedString){ + firstDataSet.setDateMiseAJour(mockedString); + thirdDataSet.withDateMiseAJour(mockedString); + assertTrue(Objects.equals(firstDataSet.getDateMiseAJour(), thirdDataSet.getDateMiseAJour()) && + Objects.equals(firstDataSet.getDateMiseAJour(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSerie1", "mockedSerie2", "mockedSerie3" }) + void shouldCheckSerie(String mockedString){ + firstDataSet.setSerie(mockedString); + thirdDataSet.withSerie(mockedString); + assertTrue(Objects.equals(firstDataSet.getSerie(), thirdDataSet.getSerie()) && + Objects.equals(firstDataSet.getSerie(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckTitreLg1(String mockedString){ + firstDataSet.setTitreLg1(mockedString); + thirdDataSet.withTitreLg1(mockedString); + assertTrue(Objects.equals(firstDataSet.getTitreLg1(), thirdDataSet.getTitreLg1()) && + Objects.equals(firstDataSet.getTitreLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstDataSet.setId(mockedString); + thirdDataSet.withId(mockedString); + assertTrue(Objects.equals(firstDataSet.getId(), thirdDataSet.getId()) && + Objects.equals(firstDataSet.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckTitreLg2(String mockedString){ + firstDataSet.setTitreLg2(mockedString); + thirdDataSet.withTitreLg2(mockedString); + assertTrue(Objects.equals(firstDataSet.getTitreLg2(), thirdDataSet.getTitreLg2()) && + Objects.equals(firstDataSet.getTitreLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckUri(String mockedString){ + firstDataSet.setUri(mockedString); + thirdDataSet.withUri(mockedString); + assertTrue(Objects.equals(firstDataSet.getUri(), thirdDataSet.getUri()) && + Objects.equals(firstDataSet.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckStatutValidation(String mockedString){ + firstDataSet.setStatutValidation(mockedString); + assertTrue(Objects.equals(firstDataSet.getStatutValidation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedVersion1/mockedValue1", "mockedVersion2/mockedValue2", "mockedVersion3/mockedValue3" }) + void shouldCheckAdditionalProperties(String mockedString){ + String name = mockedString.split("/")[0]; + String value = mockedString.split("/")[1]; + firstDataSet.setAdditionalProperty(name,value); + secondDataSet.withAdditionalProperty(name,value); + assertTrue(("{" + name + "=" + value + "}").equals(firstDataSet.getAdditionalProperties().toString())&& + ("{" + name + "=" + value + "}").equals(secondDataSet.getAdditionalProperties().toString())); + } + + + +} \ No newline at end of file From eee8a12cc84a9e3e07486892a48ba9a9fc923398 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:02:52 +0200 Subject: [PATCH 003/109] feat: RestClientConfigurationTest.java --- .../RestClientConfigurationTest.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/configuration/RestClientConfigurationTest.java diff --git a/src/test/java/fr/insee/rmes/configuration/RestClientConfigurationTest.java b/src/test/java/fr/insee/rmes/configuration/RestClientConfigurationTest.java new file mode 100644 index 000000000..d886c8c31 --- /dev/null +++ b/src/test/java/fr/insee/rmes/configuration/RestClientConfigurationTest.java @@ -0,0 +1,25 @@ +package fr.insee.rmes.configuration; + +import fr.insee.rmes.utils.config.Config; +import org.junit.jupiter.api.Test; +import org.springframework.web.client.RestClient; +import static org.junit.jupiter.api.Assertions.*; + +class RestClientConfigurationTest { + + @Test + void shouldInitializeDefaultRestClient(){ + RestClientConfiguration restClientConfiguration = new RestClientConfiguration(); + RestClient restClient = restClientConfiguration.restClient(new Config()); + assertTrue(restClient.head().toString().contains("DefaultRestClient")&& + restClient.patch().toString().contains("DefaultRestClient") && + restClient.get().toString().contains("DefaultRestClient") && + restClient.delete().toString().contains("DefaultRestClient") && + restClient.mutate().toString().contains("DefaultRestClient") && + restClient.post().toString().contains("DefaultRestClient") && + restClient.put().toString().contains("DefaultRestClient") && + restClient.options().toString().contains("DefaultRestClient") + ); + + } +} \ No newline at end of file From 05d57d078e72e9b4f8db3d654acd0a34d65aff4d Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:03:48 +0200 Subject: [PATCH 004/109] feat: methods for ConceptSDMXTest.java --- .../rmes/model/concept/ConceptSDMXTest.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/concept/ConceptSDMXTest.java diff --git a/src/test/java/fr/insee/rmes/model/concept/ConceptSDMXTest.java b/src/test/java/fr/insee/rmes/model/concept/ConceptSDMXTest.java new file mode 100644 index 000000000..ef6077147 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/concept/ConceptSDMXTest.java @@ -0,0 +1,35 @@ +package fr.insee.rmes.model.concept; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class ConceptSDMXTest { + + String agence = "mockedAgence"; + String id = "mockedId"; + + ConceptSDMX firstConceptSDMX = new ConceptSDMX(agence,id) ; + ConceptSDMX secondConceptSDMX = new ConceptSDMX(); + + @ParameterizedTest + @ValueSource(strings = { "mockedAgence1", "mockedAgence2", "mockedAgence3" }) + void shouldCheckAgence(String mockedString){ + firstConceptSDMX.setAgence(mockedString); + secondConceptSDMX.setAgence(mockedString); + assertTrue(Objects.equals(firstConceptSDMX.getAgence(), secondConceptSDMX.getAgence()) && + Objects.equals(firstConceptSDMX.getAgence(), mockedString)); + } + + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstConceptSDMX.setId(mockedString); + secondConceptSDMX.setId(mockedString); + assertTrue(Objects.equals(firstConceptSDMX.getId(), secondConceptSDMX.getId()) && + Objects.equals(firstConceptSDMX.getId(), mockedString)); + } + +} \ No newline at end of file From 5b9a61c6f368ae917d888a5cbf56c56673683544 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:05:39 +0200 Subject: [PATCH 005/109] feat: improve methode because of sonar issue --- src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java b/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java index 92d6fac61..f681188a0 100644 --- a/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java +++ b/src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java @@ -105,7 +105,7 @@ void shouldCheckUri(String mockedString){ @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) void shouldCheckStatutValidation(String mockedString){ firstDataSet.setStatutValidation(mockedString); - assertTrue(Objects.equals(firstDataSet.getStatutValidation(), mockedString)); + assertEquals(firstDataSet.getStatutValidation(), mockedString); } @ParameterizedTest From fd6c3049fb94d913cdd924141195b94fb7434cec Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:06:36 +0200 Subject: [PATCH 006/109] feat: method for PatchDatasetDTOTest.java --- .../dto/datasets/PatchDatasetDTOTest.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/dto/datasets/PatchDatasetDTOTest.java diff --git a/src/test/java/fr/insee/rmes/dto/datasets/PatchDatasetDTOTest.java b/src/test/java/fr/insee/rmes/dto/datasets/PatchDatasetDTOTest.java new file mode 100644 index 000000000..8a45a2513 --- /dev/null +++ b/src/test/java/fr/insee/rmes/dto/datasets/PatchDatasetDTOTest.java @@ -0,0 +1,38 @@ +package fr.insee.rmes.dto.datasets; + +import fr.insee.rmes.modelSwagger.dataset.Temporal; +import org.junit.jupiter.api.Test; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class PatchDatasetDTOTest { + + @Test + void shouldThrowAnExceptionWhenPatchDatasetDTO(){ + RuntimeException exception = assertThrows(RuntimeException.class, () -> new PatchDatasetDTO(null,null,null,null,null)); + assertEquals("fr.insee.rmes.utils.exceptions.RmesException: All required fields are null",exception.getMessage()); + } + + @Test + void shouldNotThrowAnExceptionWhenPatchDatasetDTO(){ + String issued = "mockedIssued"; + String modified = "mockedModified"; + Temporal temporal = new Temporal("beginPeriod","endPeriod"); + int numObservation =100; + int numSeries =12; + PatchDatasetDTO patchDatasetDTO = new PatchDatasetDTO(issued,modified,temporal,numObservation,numSeries); + + boolean isIssuedValueKnown = Objects.equals(issued,patchDatasetDTO.issued()); + boolean isModifiedValueKnown = Objects.equals(modified,patchDatasetDTO.modified()); + boolean isTemporalValueKnown = Objects.equals(temporal,patchDatasetDTO.temporal()); + boolean isNumObservationKnown = Objects.equals(numObservation,patchDatasetDTO.numObservations()); + boolean isNumSeriesKnown = Objects.equals(numSeries,patchDatasetDTO.numSeries()); + + assertTrue(isIssuedValueKnown && + isModifiedValueKnown && + isTemporalValueKnown && + isNumObservationKnown && + isNumSeriesKnown); + } + +} \ No newline at end of file From 311538258cf0f325c5c9a92c5ce22e602afda9b3 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:07:29 +0200 Subject: [PATCH 007/109] feat: method for CodeTest.java --- .../insee/rmes/model/CodeList/CodeTest.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/CodeList/CodeTest.java diff --git a/src/test/java/fr/insee/rmes/model/CodeList/CodeTest.java b/src/test/java/fr/insee/rmes/model/CodeList/CodeTest.java new file mode 100644 index 000000000..51adf5e6f --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/CodeList/CodeTest.java @@ -0,0 +1,36 @@ +package fr.insee.rmes.model.CodeList; + +import fr.insee.rmes.modelSwagger.dataset.Label; +import fr.insee.rmes.modelSwagger.dataset.LangContent; +import org.junit.jupiter.api.Test; +import java.util.List; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class CodeTest { + + @Test + void shouldInitializeWhenCode(){ + + String mockedCode = "mockedCode"; + String mockedUri = "mockedUri"; + Label mockedLabel = new Label(List.of(LangContent.lg1("mockedLg1"))); + + Code code = new Code(mockedCode,mockedLabel,mockedUri); + + code.setCode("newMockedCode"); + code.setUri("newMockedUri"); + Label otherLabel2 = new Label(List.of(LangContent.lg2("mockedLg2"))); + code.setLabel(otherLabel2); + + boolean isCodeExpected = Objects.equals( "newMockedCode",code.getCode()); + boolean isUriExpected = Objects.equals( "newMockedUri",code.getUri()); + boolean isLabelExpected = Objects.equals(otherLabel2,code.getLabel()); + + assertTrue(isCodeExpected && isUriExpected && isLabelExpected); + + } + + + +} \ No newline at end of file From 1e595db80a8dda1346f1801437bf44a2d67a5751 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:09:27 +0200 Subject: [PATCH 008/109] feat: methods for CodeListTest.java --- .../rmes/model/CodeList/CodeListTest.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java diff --git a/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java b/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java new file mode 100644 index 000000000..16bf77f09 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java @@ -0,0 +1,37 @@ +package fr.insee.rmes.model.CodeList; + +import fr.insee.rmes.modelSwagger.dataset.Label; +import fr.insee.rmes.modelSwagger.dataset.LangContent; +import org.junit.jupiter.api.Test; +import java.util.List; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CodeListTest { + + @Test + void shouldInitializeWhenCodeList(){ + + Label mockedLabel = new Label(List.of(LangContent.lg1("mockedLabel"))); + Code firstMockedCode = new Code("firstMockedCode",mockedLabel,"firstMockedUri"); + Code lastMockedCode = new Code("lastMockedCode",mockedLabel,"lastMockedUri"); + + CodeList codeList = new CodeList("mockedId",List.of(firstMockedCode,lastMockedCode),mockedLabel); + + String id = "id"; + List codes = List.of( new Code("otherMockedCode",mockedLabel,"otherMockedUri")); + Label label = new Label(List.of(LangContent.lg1("label"))); + + codeList.setId(id); + codeList.setLabel(label); + codeList.setCodes(codes); + + boolean isIdExpected = id.equals(codeList.getId()); + boolean isLabelExpected = label.equals(codeList.getLabel()); + boolean isCodesExpected = codes.equals(codeList.getCodes()); + + assertTrue( isIdExpected && isLabelExpected && isCodesExpected); + + } + + +} \ No newline at end of file From 9a68c95c3441827355ab574a4ca256cba1e4f2cc Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:10:40 +0200 Subject: [PATCH 009/109] feat: method for ConceptByIdTest.java --- .../rmes/model/concept/ConceptByIdTest.java | 126 ++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java diff --git a/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java b/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java new file mode 100644 index 000000000..1d30b0064 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java @@ -0,0 +1,126 @@ +package fr.insee.rmes.model.concept; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class ConceptByIdTest { + + String dateCreation = "mockedDateCreation"; + String dateMiseAJour = "mockedDateMiseAJour"; + String prefLabelLg1= "mockedPrefLabelLg1"; + String prefLabelLg2= "mockedPrefLabelLg2"; + String statutValidation= "mockedStatutValidation"; + String id= "mockedId"; + String dateFinValidite= "mockedDateFinValidite"; + String uri= "mockedUri"; + String version= "mockedVersion"; + String name= "mockedName"; + + ConceptById firstConceptById = new ConceptById(dateCreation,dateMiseAJour, prefLabelLg1, prefLabelLg2,statutValidation, id,dateFinValidite, uri,version, name) ; + ConceptById secondConceptById = new ConceptById(); + + + @ParameterizedTest + @ValueSource(strings = { "mockedDateCreation1", "mockedDateCreation2", "mockedDateCreation3" }) + void shouldCheckDateCreation(String mockedString){ + firstConceptById.setDateCreation(mockedString); + secondConceptById.withDateCreation(mockedString); + assertTrue(Objects.equals(firstConceptById.getDateCreation(), secondConceptById.getDateCreation()) && + Objects.equals(firstConceptById.getDateCreation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedDateMiseAJour1", "mockedDateMiseAJour2", "mockedDateMiseAJour3" }) + void shouldCheckDateMiseAJour(String mockedString){ + firstConceptById.setDateMiseAJour(mockedString); + secondConceptById.withDateMiseAjour(mockedString); + assertTrue(Objects.equals(firstConceptById.getDateMiseAJour(), secondConceptById.getDateMiseAJour()) && + Objects.equals(firstConceptById.getDateMiseAJour(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedPrefLabelLg1", "mockedPrefLabelLg2", "mockedPrefLabelLg3" }) + void shouldCheckPrefLabelLg1(String mockedString){ + firstConceptById.setPrefLabelLg1(mockedString); + secondConceptById.withPrefLabelLg1(mockedString); + assertTrue(Objects.equals(firstConceptById.getPrefLabelLg1(), secondConceptById.getPrefLabelLg1()) && + Objects.equals(firstConceptById.getPrefLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedPrefLabelLg1", "mockedPrefLabelLg2", "mockedPrefLabelLg3" }) + void shouldCheckPrefLabelLg2(String mockedString){ + firstConceptById.setPrefLabelLg2(mockedString); + secondConceptById.withPrefLabelLg2(mockedString); + assertTrue(Objects.equals(firstConceptById.getPrefLabelLg2(), secondConceptById.getPrefLabelLg2()) && + Objects.equals(firstConceptById.getPrefLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedStatutValidation1", "mockedStatutValidation2", "mockedStatutValidation3" }) + void shouldCheckStatutValidation(String mockedString){ + firstConceptById.setStatutValidation(mockedString); + secondConceptById.withStatutValidation(mockedString); + assertTrue(Objects.equals(firstConceptById.getStatutValidation(), secondConceptById.getStatutValidation()) + && Objects.equals(firstConceptById.getStatutValidation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstConceptById.setId(mockedString); + secondConceptById.withId(mockedString); + assertTrue(Objects.equals(firstConceptById.getId(), secondConceptById.getId()) && + Objects.equals(firstConceptById.getId(), mockedString) + ); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedDateFinValidite1", "mockedDateFinValidite2", "mockedDateFinValidite3" }) + void shouldCheckDateFinValidite(String mockedString){ + firstConceptById.setDateFinValidite(mockedString); + secondConceptById.withDateFinValidite(mockedString); + assertTrue(Objects.equals(firstConceptById.getDateFinValidite(), secondConceptById.getDateFinValidite()) && + Objects.equals(firstConceptById.getDateFinValidite(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstConceptById.setUri(mockedString); + secondConceptById.withUri(mockedString); + assertTrue(Objects.equals(firstConceptById.getUri(), secondConceptById.getUri()) && + Objects.equals(firstConceptById.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedVersion1", "mockedVersion2", "mockedVersion3" }) + void shouldCheckVersion(String mockedString){ + firstConceptById.setVersion(mockedString); + secondConceptById.withVersion(mockedString); + assertTrue(Objects.equals(firstConceptById.getVersion(), secondConceptById.getVersion()) && + Objects.equals(firstConceptById.getVersion(), mockedString) + ); + } + + @Test + void shouldCheckName(){ + firstConceptById.setName("mockedName"); + assertEquals("mockedName",firstConceptById.getName()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedVersion1/mockedValue1", "mockedVersion2/mockedValue2", "mockedVersion3/mockedValue3" }) + void shouldCheckAdditionalProperties(String mockedString){ + String name = mockedString.split("/")[0]; + String value = mockedString.split("/")[1]; + firstConceptById.setAdditionalProperty(name,value); + secondConceptById.withAdditionalProperty(name,value); + assertTrue(("{" + name + "=" + value + "}").equals(firstConceptById.getAdditionalProperties().toString())&& + ("{" + name + "=" + value + "}").equals(secondConceptById.getAdditionalProperties().toString())); + } + +} \ No newline at end of file From 1069df591b530fd496c896c34f83c549cdce88e0 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:12:25 +0200 Subject: [PATCH 010/109] feat: method for ConceptDefCourteTest.java --- .../model/concept/ConceptDefCourteTest.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/concept/ConceptDefCourteTest.java diff --git a/src/test/java/fr/insee/rmes/model/concept/ConceptDefCourteTest.java b/src/test/java/fr/insee/rmes/model/concept/ConceptDefCourteTest.java new file mode 100644 index 000000000..49c2b2f81 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/concept/ConceptDefCourteTest.java @@ -0,0 +1,25 @@ +package fr.insee.rmes.model.concept; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class ConceptDefCourteTest { + + @ParameterizedTest + @ValueSource(strings = { "mockedValue1", "mockedValue2", "mockedValue3" }) + void shouldCheckContenuWhenConceptDefCourte(String mockedString){ + ConceptDefCourte conceptDefCourte = new ConceptDefCourte(); + conceptDefCourte.setContenu(mockedString); + assertEquals(mockedString,conceptDefCourte.getContenu()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedValue1", "mockedValue2", "mockedValue3" }) + void shouldCheckLangWhenConceptDefCourte(String mockedString){ + ConceptDefCourte conceptDefCourte = new ConceptDefCourte("mockedContenu","mockedLang"); + conceptDefCourte.setLangue(mockedString); + assertEquals(mockedString,conceptDefCourte.getLangue()); + } + +} \ No newline at end of file From c91ea8d20b61ab9abc3472cdf0f3a07451b9de8e Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:15:00 +0200 Subject: [PATCH 011/109] feat: methods for ConceptListTest.java --- .../rmes/model/concept/ConceptListTest.java | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/concept/ConceptListTest.java diff --git a/src/test/java/fr/insee/rmes/model/concept/ConceptListTest.java b/src/test/java/fr/insee/rmes/model/concept/ConceptListTest.java new file mode 100644 index 000000000..508e0f998 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/concept/ConceptListTest.java @@ -0,0 +1,58 @@ +package fr.insee.rmes.model.concept; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class ConceptListTest { + + String dateMiseAJour = "mockedDateMiseAJour"; + String statutValidation = "mockedStatutValidation"; + String id= "mockedId"; + + ConceptList firstConceptList = new ConceptList(dateMiseAJour,statutValidation, id) ; + ConceptList secondConceptList = new ConceptList(); + + @ParameterizedTest + @ValueSource(strings = { "mockedDateMiseAJour1", "mockedDateMiseAJour2", "mockedDateMiseAJour3" }) + void shouldCheckDateMiseAJour(String mockedString){ + firstConceptList.setDateMiseAJour(mockedString); + secondConceptList.withDateMiseAJour(mockedString); + assertTrue(Objects.equals(firstConceptList.getDateMiseAJour(), secondConceptList.getDateMiseAJour()) && + Objects.equals(mockedString, firstConceptList.getDateMiseAJour()) + ); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedStatutValidation1", "mockedStatutValidation2", "mockedStatutValidation3" }) + void shouldCheckStatutValidation(String mockedString){ + firstConceptList.setStatutValidation(mockedString); + secondConceptList.withStatutValidation(mockedString); + assertTrue(Objects.equals(firstConceptList.getStatutValidation(), secondConceptList.getStatutValidation()) && + Objects.equals(mockedString, firstConceptList.getStatutValidation()) + ); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstConceptList.setId(mockedString); + secondConceptList.withId(mockedString); + assertTrue(Objects.equals(firstConceptList.getId(), secondConceptList.getId()) && + Objects.equals(mockedString, firstConceptList.getId()) + ); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedName1/mockedValue1", "mockedName2/mockedValue2", "mockedName3/mockedValue3" }) + void shouldCheckAdditionalProperties(String mockedString){ + String name = mockedString.split("/")[0]; + String value = mockedString.split("/")[1]; + firstConceptList.setAdditionalProperty(name,value); + secondConceptList.withAdditionalProperty(name,value); + assertTrue(("{" + name + "=" + value + "}").equals(firstConceptList.getAdditionalProperties().toString())&& + ("{" + name + "=" + value + "}").equals(secondConceptList.getAdditionalProperties().toString())); + } + +} \ No newline at end of file From 9cc148cb698ab2058ec93d1fecf89602b177aa60 Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:17:43 +0200 Subject: [PATCH 012/109] feat: improve method because of sonar issue --- .../fr/insee/rmes/model/concept/ConceptByIdTest.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java b/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java index 1d30b0064..7611b75c0 100644 --- a/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java +++ b/src/test/java/fr/insee/rmes/model/concept/ConceptByIdTest.java @@ -115,12 +115,12 @@ void shouldCheckName(){ @ParameterizedTest @ValueSource(strings = { "mockedVersion1/mockedValue1", "mockedVersion2/mockedValue2", "mockedVersion3/mockedValue3" }) void shouldCheckAdditionalProperties(String mockedString){ - String name = mockedString.split("/")[0]; + String nameExample = mockedString.split("/")[0]; String value = mockedString.split("/")[1]; - firstConceptById.setAdditionalProperty(name,value); - secondConceptById.withAdditionalProperty(name,value); - assertTrue(("{" + name + "=" + value + "}").equals(firstConceptById.getAdditionalProperties().toString())&& - ("{" + name + "=" + value + "}").equals(secondConceptById.getAdditionalProperties().toString())); + firstConceptById.setAdditionalProperty(nameExample,value); + secondConceptById.withAdditionalProperty(nameExample,value); + assertTrue(("{" + nameExample + "=" + value + "}").equals(firstConceptById.getAdditionalProperties().toString())&& + ("{" + nameExample + "=" + value + "}").equals(secondConceptById.getAdditionalProperties().toString())); } } \ No newline at end of file From a346a2a9ac1acfdfd4cdfb34120c1530de9211dd Mon Sep 17 00:00:00 2001 From: SM Date: Wed, 30 Jul 2025 15:20:29 +0200 Subject: [PATCH 013/109] feat : try again because was not working --- src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java b/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java index 16bf77f09..13ccfa6a5 100644 --- a/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java +++ b/src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java @@ -31,6 +31,7 @@ void shouldInitializeWhenCodeList(){ assertTrue( isIdExpected && isLabelExpected && isCodesExpected); + } From b7da925b8dd61c606de058e88ccf5691c1533cd4 Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:13:12 +0200 Subject: [PATCH 014/109] feat: method for UriTest.java --- .../java/fr/insee/rmes/model/datasets/UriTest.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/UriTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/UriTest.java b/src/test/java/fr/insee/rmes/model/datasets/UriTest.java new file mode 100644 index 000000000..5ad547908 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/UriTest.java @@ -0,0 +1,13 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class UriTest { + + @Test + void shouldReturnUriToString(){ + Uri uri = new Uri("mockedUri"); + assertEquals("mockedUri",uri.toString()); + } +} \ No newline at end of file From d1cf5f37cf1714986af9583e8254d8cd927e8aa3 Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:14:25 +0200 Subject: [PATCH 015/109] feat: method for IdTest.java --- .../java/fr/insee/rmes/model/datasets/IdTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/IdTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/IdTest.java b/src/test/java/fr/insee/rmes/model/datasets/IdTest.java new file mode 100644 index 000000000..de392f77b --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/IdTest.java @@ -0,0 +1,15 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class IdTest { + + @Test + void shouldReturnToString(){ + String mockedString="mockedString"; + Id id = new Id(mockedString); + assertEquals(mockedString,id.toString()); + } + +} \ No newline at end of file From 600d9de36fecbaae540cf886548f2e41184fe84f Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:15:07 +0200 Subject: [PATCH 016/109] feat: method for SerieTest.java --- .../insee/rmes/model/datasets/SerieTest.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/SerieTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/SerieTest.java b/src/test/java/fr/insee/rmes/model/datasets/SerieTest.java new file mode 100644 index 000000000..a0778bfcc --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/SerieTest.java @@ -0,0 +1,55 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import static org.junit.jupiter.api.Assertions.*; + +class SerieTest { + + String uri= "mockedUri"; + String id= "mockedId"; + String labelSerieLg1= "mockedLabelSerieLg1"; + String labelSerieLg2= "mockedLabelSerieLg2"; + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Serie firstSerie = new Serie(uri,id,labelSerieLg1,labelSerieLg2); + Serie secondSerie = new Serie(); + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstSerie.setUri(mockedString); + assertEquals(mockedString,firstSerie.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstSerie.setId(mockedString); + assertEquals(mockedString,firstSerie.getId()); + } + + @ParameterizedTest + @ValueSource(strings = { "LabelSerieLg1", "LabelSerieLg2", "mockedLabelSerieLg3" }) + void shouldCheckLabelSerieLg1(String mockedString){ + firstSerie.setLabelSerieLg1(mockedString); + assertEquals(mockedString,firstSerie.getLabelSerieLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "LabelSerieLg1", "LabelSerieLg2", "mockedLabelSerieLg3" }) + void shouldCheckLabelSerieLg2(String mockedString){ + firstSerie.setLabelSerieLg2(mockedString); + assertEquals(mockedString,firstSerie.getLabelSerieLg2()); + } + + @Test + void shouldCheckAdditionalProperties(){ + secondSerie.setAdditionalProperties(additionalProperties); + assertEquals(additionalProperties,secondSerie.getAdditionalProperties()); + } + + +} \ No newline at end of file From d3bf6d8906d9ee261564e5a164789c839e334b02 Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:15:52 +0200 Subject: [PATCH 017/109] feat: method for ModifiedTest.java --- .../insee/rmes/model/datasets/ModifiedTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/ModifiedTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/ModifiedTest.java b/src/test/java/fr/insee/rmes/model/datasets/ModifiedTest.java new file mode 100644 index 000000000..1d1698474 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/ModifiedTest.java @@ -0,0 +1,15 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class ModifiedTest { + + @Test + void shouldReturnToString(){ + String mockedString="mockedString"; + Modified modified = new Modified(mockedString); + assertEquals(mockedString,modified.toString()); + } + +} \ No newline at end of file From 89d929d27e1d2b5f8f183c7ccc422168d1b47a1e Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:19:02 +0200 Subject: [PATCH 018/109] feat: method for DataSetByIdtest.java --- .../rmes/model/datasets/DataSetByIdTest.java | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/DataSetByIdTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/DataSetByIdTest.java b/src/test/java/fr/insee/rmes/model/datasets/DataSetByIdTest.java new file mode 100644 index 000000000..17edfd1c5 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/DataSetByIdTest.java @@ -0,0 +1,105 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class DataSetByIdTest { + + String operationStat = "mockedOperationStat"; + String dateCreation = "mockedDateCreation"; + String names= "mockedNames"; + String dateModification= "mockedDateModification"; + String titreLg1= "mockedTitreLg1"; + String id= "mockedId"; + String titreLg2= "mockedTitreLg2"; + String uri= "mockedUri"; + + DataSetById firstDataSetById = new DataSetById(operationStat,dateCreation,names,dateModification,titreLg1,id,titreLg2,uri); + DataSetById secondDataSetById = new DataSetById(); + + @ParameterizedTest + @ValueSource(strings = { "mockedOperationStat1", "mockedOperationStat2", "mockedOperationStat3" }) + void shouldCheckOperationStat(String mockedString){ + firstDataSetById.setOperationStat(mockedString); + secondDataSetById.withOperationStat(mockedString); + assertTrue(Objects.equals(firstDataSetById.getOperationStat(), secondDataSetById.getOperationStat()) && + Objects.equals(firstDataSetById.getOperationStat(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedDateCreation1", "mockedDateCreation2", "mockedDateCreation3" }) + void shouldCheckDateCreation(String mockedString){ + firstDataSetById.setDateCreation(mockedString); + secondDataSetById.withDateCreation(mockedString); + assertTrue(Objects.equals(firstDataSetById.getDateCreation(), secondDataSetById.getDateCreation()) && + Objects.equals(firstDataSetById.getDateCreation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedNames1", "mockedNames2", "mockedNames3" }) + void shouldCheckNames(String mockedString){ + firstDataSetById.setNames(mockedString); + secondDataSetById.withNames(mockedString); + assertTrue(Objects.equals(firstDataSetById.getNames(), secondDataSetById.getNames()) && + Objects.equals(firstDataSetById.getNames(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedDateModification1", "mockedDateModification2", "mockedDateModification3" }) + void shouldCheckDateModification(String mockedString){ + firstDataSetById.setDateModification(mockedString); + secondDataSetById.withDateModification(mockedString); + assertTrue(Objects.equals(firstDataSetById.getDateModification(), secondDataSetById.getDateModification()) && + Objects.equals(firstDataSetById.getDateModification(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckTitreLg1(String mockedString){ + firstDataSetById.setTitreLg1(mockedString); + secondDataSetById.withTitreLg1(mockedString); + assertTrue(Objects.equals(firstDataSetById.getTitreLg1(), secondDataSetById.getTitreLg1()) && + Objects.equals(firstDataSetById.getTitreLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstDataSetById.setId(mockedString); + secondDataSetById.withId(mockedString); + assertTrue(Objects.equals(firstDataSetById.getId(), secondDataSetById.getId()) && + Objects.equals(firstDataSetById.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTitreLg1", "mockedTitreLg2", "mockedTitreLg3" }) + void shouldCheckTitreLg2(String mockedString){ + firstDataSetById.setTitreLg2(mockedString); + secondDataSetById.withTitreLg2(mockedString); + assertTrue(Objects.equals(firstDataSetById.getTitreLg2(), secondDataSetById.getTitreLg2()) && + Objects.equals(firstDataSetById.getTitreLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstDataSetById.setUri(mockedString); + secondDataSetById.withUri(mockedString); + assertTrue(Objects.equals(firstDataSetById.getUri(), secondDataSetById.getUri()) && + Objects.equals(firstDataSetById.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedVersion1/mockedValue1", "mockedVersion2/mockedValue2", "mockedVersion3/mockedValue3" }) + void shouldCheckAdditionalProperties(String mockedString){ + String nameExample = mockedString.split("/")[0]; + String value = mockedString.split("/")[1]; + firstDataSetById.setAdditionalProperty(nameExample,value); + secondDataSetById.withAdditionalProperty(nameExample,value); + assertTrue(("{" + nameExample + "=" + value + "}").equals(firstDataSetById.getAdditionalProperties().toString())&& + ("{" + nameExample + "=" + value + "}").equals(secondDataSetById.getAdditionalProperties().toString())); + } + +} \ No newline at end of file From 36d68f59a3b8b1962fc4b7504a2904312c6e433f Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:20:08 +0200 Subject: [PATCH 019/109] feat: method for ThemeTest.java --- .../insee/rmes/model/datasets/ThemeTest.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/ThemeTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/ThemeTest.java b/src/test/java/fr/insee/rmes/model/datasets/ThemeTest.java new file mode 100644 index 000000000..e2b45febb --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/ThemeTest.java @@ -0,0 +1,55 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import static org.junit.jupiter.api.Assertions.*; + +class ThemeTest { + + String uri = "uri"; + String labelThemeLg1= "labelThemeLg1"; + String labelThemeLg2= "labelThemeLg2"; + String themeTaxonomy="themeTaxonomy"; + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Theme firstTheme = new Theme(uri,labelThemeLg1,labelThemeLg2,themeTaxonomy); + Theme secondTheme = new Theme(); + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstTheme.setUri(mockedString); + assertEquals(mockedString,firstTheme.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelThemeLg1", "mockedLabelThemeLg2", "mockedLabelThemeLg3" }) + void shouldCheckLabelThemeLg1(String mockedString){ + secondTheme.setLabelThemeLg1(mockedString); + assertEquals(mockedString,secondTheme.getLabelThemeLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelThemeLg1", "mockedLabelThemeLg2", "mockedLabelThemeLg3" }) + void shouldCheckLabelThemeLg2(String mockedString){ + secondTheme.setLabelThemeLg2(mockedString); + assertEquals(mockedString,secondTheme.getLabelThemeLg2()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedThemeTaxonomyLg1", "mockedThemeTaxonomy2", "mockedThemeTaxonomy3" }) + void shouldCheckLabelThemeTaxonomy(String mockedString){ + secondTheme.setThemeTaxonomy(mockedString); + assertEquals(mockedString,secondTheme.getThemeTaxonomy()); + } + + @Test + void shouldCheckAdditionalProperties(){ + secondTheme.setAdditionalProperties(additionalProperties); + assertEquals(additionalProperties,secondTheme.getAdditionalProperties()); + } + + +} \ No newline at end of file From 654d40bd289c499d5167613fdd4f64c91ad0ccf1 Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:21:00 +0200 Subject: [PATCH 020/109] feat: method for PatchDatasetPropertiesTest.java --- .../model/datasets/PatchDatasetPropertiesTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/PatchDatasetPropertiesTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/PatchDatasetPropertiesTest.java b/src/test/java/fr/insee/rmes/model/datasets/PatchDatasetPropertiesTest.java new file mode 100644 index 000000000..b7d7be5c2 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/PatchDatasetPropertiesTest.java @@ -0,0 +1,14 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class PatchDatasetPropertiesTest { + + @Test + void shouldCheckClassOfEnumContainsAtLeastOneValue(){ + PatchDatasetProperties[] numberOfValues = PatchDatasetProperties.values(); + assertTrue(numberOfValues.length>0); + } + +} \ No newline at end of file From 2985d48d7df8e335c647d3c4ea0e699e507c1f0d Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:21:56 +0200 Subject: [PATCH 021/109] feat: method for DistributionsTest.java --- .../model/datasets/DistributionsTest.java | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/DistributionsTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/DistributionsTest.java b/src/test/java/fr/insee/rmes/model/datasets/DistributionsTest.java new file mode 100644 index 000000000..5446dc22d --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/DistributionsTest.java @@ -0,0 +1,97 @@ +package fr.insee.rmes.model.datasets; + +import fr.insee.rmes.modelSwagger.dataset.LangContent; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class DistributionsTest { + + String identifier = "mockedIdentifier"; + String byteSize = "mockedByteSize"; + String created= "mockedCreated"; + List description= List.of(LangContent.lg1("lg1"),LangContent.lg2("lg2")); + List downloadURL= List.of("downloadURL1","downloadURL2"); + String format= "mockedFormat"; + String modified= "mockedModified"; + List title= List.of(LangContent.lg1("lg1"),LangContent.lg2("lg2")); + String uri= "mockedUri"; + + Distributions firstDistributions = new Distributions(identifier,byteSize,created,description,downloadURL,format,modified,title,uri); + Distributions secondDistributions = new Distributions(); + Distributions thirdDistributions = new Distributions(identifier,uri); + + @ParameterizedTest + @ValueSource(strings = { "mockedIdentifier1", "mockedIdentifier2", "mockedIdentifier3" }) + void shouldCheckIdentifier(String mockedString){ + firstDistributions.setIdentifier(mockedString); + assertEquals(mockedString,firstDistributions.getIdentifier()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedByteSize1", "mockedByteSize2", "mockedByteSize3" }) + void shouldCheckByteSize(String mockedString){ + secondDistributions.setByteSize(mockedString); + assertEquals(mockedString,secondDistributions.getByteSize()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedCreated1", "mockedCreated2", "mockedCreated3" }) + void shouldCheckCreated(String mockedString){ + thirdDistributions.setCreated(mockedString); + assertEquals(mockedString,thirdDistributions.getCreated()); + } + + @Test + void shouldCheckDescription(){ + secondDistributions.setDescription(description); + assertEquals(description,secondDistributions.getDescription()); + } + + @Test + void shouldCheckDownloadURL(){ + secondDistributions.setDownloadURL(downloadURL); + assertEquals(downloadURL,secondDistributions.getDownloadURL()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedFormat1", "mockedFormat2", "mockedFormat3" }) + void shouldCheckFormat(String mockedString){ + secondDistributions.setFormat(mockedString); + assertEquals(mockedString,secondDistributions.getFormat()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedModified1", "mockedModified2", "mockedModified3" }) + void shouldCheckModified(String mockedString){ + secondDistributions.setModified(mockedString); + assertEquals(mockedString,secondDistributions.getModified()); + } + + @Test + void shouldCheckTitle(){ + secondDistributions.setTitle(title); + assertEquals(title,secondDistributions.getTitle()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + secondDistributions.setUri(mockedString); + assertEquals(mockedString,secondDistributions.getUri()); + } + + @Test + void shouldCheckToString(){ + String actual = firstDistributions.toString(); + assertTrue(actual.contains(identifier) && + actual.contains(byteSize) && + actual.contains(created) && + actual.contains(format) && + actual.contains(modified) && + actual.contains(uri)); + } + +} \ No newline at end of file From cb806cb4d777cd21861667acb332f6e14a3c7747 Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:22:35 +0200 Subject: [PATCH 022/109] feat: method for ProcessStepTest.java --- .../rmes/model/datasets/ProcessStepTest.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/ProcessStepTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/ProcessStepTest.java b/src/test/java/fr/insee/rmes/model/datasets/ProcessStepTest.java new file mode 100644 index 000000000..1e4520e55 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/ProcessStepTest.java @@ -0,0 +1,18 @@ +package fr.insee.rmes.model.datasets; + +import fr.insee.rmes.modelSwagger.dataset.Label; +import fr.insee.rmes.modelSwagger.dataset.LangContent; +import org.junit.jupiter.api.Test; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class ProcessStepTest { + + @Test + void shouldInitializeProcessStep(){ + String id = "mockedId"; + Label label = new Label(List.of(LangContent.lg1("lg1"),LangContent.lg2("lg2"))); + ProcessStep processStep = new ProcessStep(id,label); + assertNotNull(processStep); + } +} \ No newline at end of file From 68b7baaf6c58f6694c2dccae714e5143124d5ccf Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:23:03 +0200 Subject: [PATCH 023/109] feat: method for OperationTest.java --- .../rmes/model/datasets/OperationTest.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/OperationTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/OperationTest.java b/src/test/java/fr/insee/rmes/model/datasets/OperationTest.java new file mode 100644 index 000000000..a3512e895 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/OperationTest.java @@ -0,0 +1,54 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import static org.junit.jupiter.api.Assertions.*; + +class OperationTest { + + String uri= "mockedUri"; + String id= "mockedId"; + String labelOperationLg1="mockedLabelOperationLg1"; + String labelOperationLg2="mockedLabelOperationLg2"; + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Operation firstOperation = new Operation(uri,id,labelOperationLg1,labelOperationLg2); + Operation secondOperation = new Operation(); + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstOperation.setUri(mockedString); + assertEquals(mockedString,firstOperation.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + secondOperation.setId(mockedString); + assertEquals(mockedString,secondOperation.getId()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedOperationLg1", "mockedOperationLg2", "mockedOperationLg3" }) + void shouldCheckOperationLg1(String mockedString){ + firstOperation.setlabelOperationLg1(mockedString); + assertEquals(mockedString,firstOperation.getlabelOperationLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedOperationLg1", "mockedOperationLg2", "mockedOperationLg3" }) + void shouldCheckOperationLg2(String mockedString){ + firstOperation.setlabelOperationLg2(mockedString); + assertEquals(mockedString,firstOperation.getlabelOperationLg2()); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstOperation.setAdditionalProperties(additionalProperties); + assertEquals(additionalProperties,firstOperation.getAdditionalProperties()); + } + +} \ No newline at end of file From bab3313532c4e6c8c1a0a0edf7344801a632d80b Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:24:19 +0200 Subject: [PATCH 024/109] feat : method for DisseminationStatusTest.java --- .../model/datasets/DisseminationStatusTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/datasets/DisseminationStatusTest.java diff --git a/src/test/java/fr/insee/rmes/model/datasets/DisseminationStatusTest.java b/src/test/java/fr/insee/rmes/model/datasets/DisseminationStatusTest.java new file mode 100644 index 000000000..b805d5df5 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/DisseminationStatusTest.java @@ -0,0 +1,14 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class DisseminationStatusTest { + + @Test + void shouldReturnToString(){ + String mockedString="mockedString"; + DisseminationStatus disseminationStatus = new DisseminationStatus(mockedString); + assertEquals(mockedString,disseminationStatus.toString()); + } +} \ No newline at end of file From 8e09284556f8919292c9e4cd64a8e87dd041c83a Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:25:41 +0200 Subject: [PATCH 025/109] feat: method for OperationByIdTest.java --- .../model/operation/OperationByIdTest.java | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/operation/OperationByIdTest.java diff --git a/src/test/java/fr/insee/rmes/model/operation/OperationByIdTest.java b/src/test/java/fr/insee/rmes/model/operation/OperationByIdTest.java new file mode 100644 index 000000000..bfd5caf5b --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/operation/OperationByIdTest.java @@ -0,0 +1,114 @@ +package fr.insee.rmes.model.operation; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class OperationByIdTest { + + String serie = "serie"; + String id="id"; + String operationLabelLg1="operationLabelLg1"; + String operationLabelLg2="operationLabelLg2"; + String seriesLabelLg1="seriesLabelLg1"; + String uri="uri"; + String seriesId="seriesId"; + String seriesLabelLg2="seriesLabelLg2"; + String proprietaire="proprietaire"; + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + OperationById firstOperationById = new OperationById(serie,id,operationLabelLg1,operationLabelLg2,seriesLabelLg1,uri,seriesId,seriesLabelLg2,proprietaire); + OperationById secondOperationById = new OperationById(); + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckSeries(String mockedString){ + firstOperationById.setSeries(mockedString); + secondOperationById.withSeries(mockedString); + assertTrue(Objects.equals(firstOperationById.getSeries(), secondOperationById.getSeries()) && + Objects.equals(firstOperationById.getSeries(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckId(String mockedString){ + firstOperationById.setId(mockedString); + secondOperationById.withOperationId(mockedString); + assertTrue(Objects.equals(firstOperationById.getId(), secondOperationById.getId()) && + Objects.equals(firstOperationById.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg1A", "mockedLabelLg1B", "mockedLabelLg1C" }) + void shouldCheckLabelLg1(String mockedString){ + firstOperationById.setOperationLabelLg1(mockedString); + secondOperationById.withOperationLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationById.getOperationLabelLg1(), secondOperationById.getOperationLabelLg1()) && + Objects.equals(firstOperationById.getOperationLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg2A", "mockedLabelLg2B", "mockedLabelLg2C" }) + void shouldCheckLabelLg2(String mockedString){ + firstOperationById.setOperationLabelLg2(mockedString); + secondOperationById.withOperationLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationById.getOperationLabelLg2(), secondOperationById.getOperationLabelLg2()) && + Objects.equals(firstOperationById.getOperationLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeriesLabelLg1A", "mockedSeriesLabelLg1B", "mockedSeriesLabelLg1C" }) + void shouldCheckSeriesLabelLg1(String mockedString){ + firstOperationById.setSeriesLabelLg1(mockedString); + secondOperationById.withSeriesLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationById.getSeriesLabelLg1(), secondOperationById.getSeriesLabelLg1()) && + Objects.equals(firstOperationById.getSeriesLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstOperationById.setUri(mockedString); + secondOperationById.withUri(mockedString); + assertTrue(Objects.equals(firstOperationById.getUri(), secondOperationById.getUri()) && + Objects.equals(firstOperationById.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeriesId1", "mockedSeriesId2", "mockedSeriesId3" }) + void shouldCheckSeriesId(String mockedString){ + firstOperationById.setSeriesId(mockedString); + secondOperationById.withSeriesId(mockedString); + assertTrue(Objects.equals(firstOperationById.getSeriesId(), secondOperationById.getSeriesId()) && + Objects.equals(firstOperationById.getSeriesId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeriesLabelLg2A", "mockedSeriesLabelLg2B", "mockedSeriesLabelLg2C" }) + void shouldCheckSeriesLabelLg2(String mockedString){ + firstOperationById.setSeriesLabelLg2(mockedString); + secondOperationById.withSeriesLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationById.getSeriesLabelLg2(), secondOperationById.getSeriesLabelLg2()) && + Objects.equals(firstOperationById.getSeriesLabelLg2(), mockedString)); + } + + + @ParameterizedTest + @ValueSource(strings = { "mockedProprietaire1", "mockedProprietaire2", "mockedProprietaire3" }) + void shouldCheckProprietaire(String mockedString){ + firstOperationById.setProprietaire(mockedString); + assertEquals(mockedString,firstOperationById.getProprietaire()); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstOperationById.setAdditionalProperty("name","value"); + secondOperationById.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstOperationById.getAdditionalProperties(), secondOperationById.getAdditionalProperties()) && + !Objects.equals(firstOperationById.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From e2a221dc53a00183aa4f4d26c991c83675f8f96c Mon Sep 17 00:00:00 2001 From: SM Date: Thu, 31 Jul 2025 15:41:54 +0200 Subject: [PATCH 026/109] feat: method for OperationBySerieIdTest.java --- .../operation/OperationBySerieIdTest.java | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/operation/OperationBySerieIdTest.java diff --git a/src/test/java/fr/insee/rmes/model/operation/OperationBySerieIdTest.java b/src/test/java/fr/insee/rmes/model/operation/OperationBySerieIdTest.java new file mode 100644 index 000000000..529b56989 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/operation/OperationBySerieIdTest.java @@ -0,0 +1,150 @@ +package fr.insee.rmes.model.operation; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class OperationBySerieIdTest { + + String series = "series"; + String typeLabelLg1="typeLabelLg1"; + String typeLabelLg2="typeLabelLg2"; + String operationId="operationId"; + String operationLabelLg1="operationLabelLg1"; + String operationLabelLg2="operationLabelLg2"; + String operationAltLabelLg2="operationAltLabelLg2"; + String seriesLabelLg1="seriesLabelLg1"; + String operationAltLabelLg1="operationAltLabelLg1"; + String uri="uri"; + String seriesId="seriesId"; + String seriesLabelLg2="seriesLabelLg2"; + String periodicityId="periodicityId"; + String periodicity="periodicity"; + String periodicityLabelLg1="periodicityLabelLg1"; + String periodicityLabelLg2="periodicityLabelLg2"; + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + OperationBySerieId firstOperationBySerieId= new OperationBySerieId(series,typeLabelLg1,typeLabelLg2,operationId,operationLabelLg1,operationLabelLg2,operationAltLabelLg2,seriesLabelLg1,operationAltLabelLg1,uri,seriesId,seriesLabelLg2,periodicityId,periodicity,periodicityLabelLg1,periodicityLabelLg2); + OperationBySerieId secondOperationBySerieId= new OperationBySerieId(); + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckSeries(String mockedString){ + firstOperationBySerieId.setSeries(mockedString); + secondOperationBySerieId.withSeries(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getSeries(), secondOperationBySerieId.getSeries()) && + Objects.equals(firstOperationBySerieId.getSeries(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTypeLabelLg1A", "mockedTypeLabelLg1B", "mockedTypeLabelLg1C" }) + void shouldCheckLabelLg1(String mockedString){ + firstOperationBySerieId.setTypeLabelLg1(mockedString); + secondOperationBySerieId.withTypeLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getTypeLabelLg1(), secondOperationBySerieId.getTypeLabelLg1()) && + Objects.equals(firstOperationBySerieId.getTypeLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedTypeLabelLg2A", "mockedTypeLabelLg2B", "mockedTypeLabelLg2C" }) + void shouldCheckLabelLg2(String mockedString){ + firstOperationBySerieId.setTypeLabelLg2(mockedString); + secondOperationBySerieId.withTypeLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getTypeLabelLg2(), secondOperationBySerieId.getTypeLabelLg2()) && + Objects.equals(firstOperationBySerieId.getTypeLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckOperationId(String mockedString){ + firstOperationBySerieId.setOperationId(mockedString); + secondOperationBySerieId.withOperationId(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getOperationId(), secondOperationBySerieId.getOperationId()) && + Objects.equals(firstOperationBySerieId.getOperationId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg1A", "mockedLabelLg1B", "mockedLabelLg1C" }) + void shouldCheckOperationLabelLg1(String mockedString){ + firstOperationBySerieId.setOperationLabelLg1(mockedString); + secondOperationBySerieId.withOperationLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getOperationLabelLg1(), secondOperationBySerieId.getOperationLabelLg1()) && + Objects.equals(firstOperationBySerieId.getOperationLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg2A", "mockedLabelLg2B", "mockedLabelLg2C" }) + void shouldCheckOperationLabelLg2(String mockedString){ + firstOperationBySerieId.setOperationLabelLg2(mockedString); + secondOperationBySerieId.withOperationLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getOperationLabelLg2(), secondOperationBySerieId.getOperationLabelLg2()) && + Objects.equals(firstOperationBySerieId.getOperationLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg2A", "mockedLabelLg2B", "mockedLabelLg2C" }) + void shouldCheckOperationAltLabelLg2(String mockedString){ + firstOperationBySerieId.setOperationAltLabelLg2(mockedString); + secondOperationBySerieId.withOperationAltLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getOperationAltLabelLg2(), secondOperationBySerieId.getOperationAltLabelLg2()) && + Objects.equals(firstOperationBySerieId.getOperationAltLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeriesLabelLg1A", "mockedSeriesLabelLg1B", "mockedSeriesLabelLg1C" }) + void shouldCheckSeriesLabelLg1(String mockedString){ + firstOperationBySerieId.setSeriesLabelLg1(mockedString); + secondOperationBySerieId.withSeriesLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getSeriesLabelLg1(), secondOperationBySerieId.getSeriesLabelLg1()) && + Objects.equals(firstOperationBySerieId.getSeriesLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedLabelLg1A", "mockedLabelLg1B", "mockedLabelLg1C" }) + void shouldCheckOperationAltLabelLg1(String mockedString){ + firstOperationBySerieId.setOperationAltLabelLg1(mockedString); + secondOperationBySerieId.withOperationAltLabelLg1(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getOperationAltLabelLg1(), secondOperationBySerieId.getOperationAltLabelLg1()) && + Objects.equals(firstOperationBySerieId.getOperationAltLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedUri1", "mockedUri2", "mockedUri3" }) + void shouldCheckUri(String mockedString){ + firstOperationBySerieId.setUri(mockedString); + secondOperationBySerieId.withUri(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getUri(), secondOperationBySerieId.getUri()) && + Objects.equals(firstOperationBySerieId.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedId1", "mockedId2", "mockedId3" }) + void shouldCheckSeriesId(String mockedString){ + firstOperationBySerieId.setSeriesId(mockedString); + secondOperationBySerieId.withSeriesId(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getSeriesId(), secondOperationBySerieId.getSeriesId()) && + Objects.equals(firstOperationBySerieId.getSeriesId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeriesLabelLg2A", "mockedSeriesLabelLg2B", "mockedSeriesLabelLg2C" }) + void shouldCheckSeriesLabelLg2(String mockedString){ + firstOperationBySerieId.setSeriesLabelLg2(mockedString); + secondOperationBySerieId.withSeriesLabelLg2(mockedString); + assertTrue(Objects.equals(firstOperationBySerieId.getSeriesLabelLg2(), secondOperationBySerieId.getSeriesLabelLg2()) && + Objects.equals(firstOperationBySerieId.getSeriesLabelLg2(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstOperationBySerieId.setAdditionalProperty("name","value"); + secondOperationBySerieId.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstOperationBySerieId.getAdditionalProperties(), secondOperationBySerieId.getAdditionalProperties()) && + !Objects.equals(firstOperationBySerieId.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From 6c54c4a650a31c0be4b3c9d28aa95ebd2e96bd6a Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:15:39 +0200 Subject: [PATCH 027/109] feat: methods for SerieByTest.java --- .../rmes/model/operation/SerieByIdTest.java | 216 ++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/operation/SerieByIdTest.java diff --git a/src/test/java/fr/insee/rmes/model/operation/SerieByIdTest.java b/src/test/java/fr/insee/rmes/model/operation/SerieByIdTest.java new file mode 100644 index 000000000..0d56e5671 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/operation/SerieByIdTest.java @@ -0,0 +1,216 @@ +package fr.insee.rmes.model.operation; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class SerieByIdTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + SerieById firstSerieById = new SerieById( + "type", + "familyId", + "periodicityId", + "periodicityLabelLg2", + "periodicityLabelLg1", + "series", + "typeLabelLg1", + "typeLabelLg2", + "periodicity", + "typeId", + "id", + "seriesLabelLg1", + "seriesAltLabelLg1", + "nbOperation", + "family", + "familyLabelLg1", + "seriesAltLabelLg2", + "familyLabelLg2", + "seriesLabelLg2"); + + SerieById secondSerieById = new SerieById(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckType(String mockedString){ + firstSerieById.setType(mockedString); + secondSerieById.withType(mockedString); + assertTrue(Objects.equals(firstSerieById.getType(),secondSerieById.getType()) && + Objects.equals(firstSerieById.getType(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyId(String mockedString){ + firstSerieById.setFamilyId(mockedString); + secondSerieById.withFamilyId(mockedString); + assertTrue(Objects.equals(firstSerieById.getFamilyId(),secondSerieById.getFamilyId()) && + Objects.equals(firstSerieById.getFamilyId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityId(String mockedString){ + firstSerieById.setPeriodicityId(mockedString); + secondSerieById.withPeriodicityId(mockedString); + assertTrue(Objects.equals(firstSerieById.getPeriodicityId(),secondSerieById.getPeriodicityId()) && + Objects.equals(firstSerieById.getPeriodicityId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityLabelLg2(String mockedString){ + firstSerieById.setPeriodicityLabelLg2(mockedString); + secondSerieById.withPeriodicityLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieById.getPeriodicityLabelLg2(),secondSerieById.getPeriodicityLabelLg2()) && + Objects.equals(firstSerieById.getPeriodicityLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityLabelLg1(String mockedString){ + firstSerieById.setPeriodicityLabelLg1(mockedString); + secondSerieById.withPeriodicityLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieById.getPeriodicityLabelLg1(),secondSerieById.getPeriodicityLabelLg1()) && + Objects.equals(firstSerieById.getPeriodicityLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeries(String mockedString){ + firstSerieById.setSeries(mockedString); + secondSerieById.withSeries(mockedString); + assertTrue(Objects.equals(firstSerieById.getSeries(),secondSerieById.getSeries()) && + Objects.equals(firstSerieById.getSeries(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeLabelLg1(String mockedString){ + firstSerieById.setTypeLabelLg1(mockedString); + secondSerieById.withTypeLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieById.getTypeLabelLg1(),secondSerieById.getTypeLabelLg1()) && + Objects.equals(firstSerieById.getTypeLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeLabelLg2(String mockedString){ + firstSerieById.setTypeLabelLg2(mockedString); + secondSerieById.withTypeLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieById.getTypeLabelLg2(),secondSerieById.getTypeLabelLg2()) && + Objects.equals(firstSerieById.getTypeLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicity(String mockedString){ + firstSerieById.setPeriodicity(mockedString); + secondSerieById.withPeriodicity(mockedString); + assertTrue(Objects.equals(firstSerieById.getPeriodicity(),secondSerieById.getPeriodicity()) && + Objects.equals(firstSerieById.getPeriodicity(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeId(String mockedString){ + firstSerieById.setTypeId(mockedString); + secondSerieById.withTypeId(mockedString); + assertTrue(Objects.equals(firstSerieById.getTypeId(),secondSerieById.getTypeId()) && + Objects.equals(firstSerieById.getTypeId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckId(String mockedString){ + firstSerieById.setId(mockedString); + secondSerieById.withId(mockedString); + assertTrue(Objects.equals(firstSerieById.getId(),secondSerieById.getId()) && + Objects.equals(firstSerieById.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesLabelLg1(String mockedString){ + firstSerieById.setSeriesLabelLg1(mockedString); + secondSerieById.withSeriesLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieById.getSeriesLabelLg1(),secondSerieById.getSeriesLabelLg1()) && + Objects.equals(firstSerieById.getSeriesLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesAltLabelLg1(String mockedString){ + firstSerieById.setSeriesAltLabelLg1(mockedString); + secondSerieById.withSeriesAltLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieById.getSeriesAltLabelLg1(),secondSerieById.getSeriesAltLabelLg1()) && + Objects.equals(firstSerieById.getSeriesAltLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckNbOperations(String mockedString){ + firstSerieById.setNbOperation(mockedString); + secondSerieById.withNbOperation(mockedString); + assertTrue(Objects.equals(firstSerieById.getNbOperation(),secondSerieById.getNbOperation()) && + Objects.equals(firstSerieById.getNbOperation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamily(String mockedString){ + firstSerieById.setFamily(mockedString); + secondSerieById.withFamily(mockedString); + assertTrue(Objects.equals(firstSerieById.getFamily(),secondSerieById.getFamily()) && + Objects.equals(firstSerieById.getFamily(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyLabelLg1(String mockedString){ + firstSerieById.setFamilyLabelLg1(mockedString); + secondSerieById.withFamilyLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieById.getFamilyLabelLg1(),secondSerieById.getFamilyLabelLg1()) && + Objects.equals(firstSerieById.getFamilyLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesAltLabelLg2(String mockedString){ + firstSerieById.setSeriesAltLabelLg2(mockedString); + secondSerieById.withSeriesAltLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieById.getSeriesAltLabelLg2(),secondSerieById.getSeriesAltLabelLg2()) && + Objects.equals(firstSerieById.getSeriesAltLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyLabelLg2(String mockedString){ + firstSerieById.setFamilyLabelLg2(mockedString); + secondSerieById.withFamilyLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieById.getFamilyLabelLg2(),secondSerieById.getFamilyLabelLg2()) && + Objects.equals(firstSerieById.getFamilyLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesLabelLg2(String mockedString){ + firstSerieById.setSeriesLabelLg2(mockedString); + secondSerieById.withSeriesLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieById.getSeriesLabelLg2(),secondSerieById.getSeriesLabelLg2()) && + Objects.equals(firstSerieById.getSeriesLabelLg2(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstSerieById.setAdditionalProperty("name","value"); + secondSerieById.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstSerieById.getAdditionalProperties(),secondSerieById.getAdditionalProperties()) && + !Objects.equals(firstSerieById.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From 8a1cd7b8c19efdb4a736a4379e32e1e243737526 Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:16:59 +0200 Subject: [PATCH 028/109] feat : methods for SerieModelTest.java --- .../rmes/model/operation/SerieModelTest.java | 223 ++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/operation/SerieModelTest.java diff --git a/src/test/java/fr/insee/rmes/model/operation/SerieModelTest.java b/src/test/java/fr/insee/rmes/model/operation/SerieModelTest.java new file mode 100644 index 000000000..57e000658 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/operation/SerieModelTest.java @@ -0,0 +1,223 @@ +package fr.insee.rmes.model.operation; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class SerieModelTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + + SerieModel firstSerieModel = new SerieModel( + "type", + "familyId", + "periodicityId", + "periodicityLabelLg2", + "periodicityLabelLg1", + "series", + "typeLabelLg1", + "typeLabelLg2", + "periodicity", + "typeId", + "id", + "seriesLabelLg1", + "seriesAltLabelLg1", + "nbOperation", + "family", + "familyLabelLg1", + "seriesAltLabelLg2", + "familyLabelLg2", + "seriesLabelLg2", + "proprietaire" + ); + + SerieModel secondSerieModel = new SerieModel(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckType(String mockedString){ + firstSerieModel.setType(mockedString); + secondSerieModel.withType(mockedString); + assertTrue(Objects.equals(firstSerieModel.getType(),secondSerieModel.getType()) && + Objects.equals(firstSerieModel.getType(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyId(String mockedString){ + firstSerieModel.setFamilyId(mockedString); + secondSerieModel.withFamilyId(mockedString); + assertTrue(Objects.equals(firstSerieModel.getFamilyId(),secondSerieModel.getFamilyId()) && + Objects.equals(firstSerieModel.getFamilyId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityId(String mockedString){ + firstSerieModel.setPeriodicityId(mockedString); + secondSerieModel.withPeriodicityId(mockedString); + assertTrue(Objects.equals(firstSerieModel.getPeriodicityId(),secondSerieModel.getPeriodicityId()) && + Objects.equals(firstSerieModel.getPeriodicityId(), mockedString)); + } + + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityLabelLg1(String mockedString){ + firstSerieModel.setPeriodicityLabelLg1(mockedString); + secondSerieModel.withPeriodicityLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieModel.getPeriodicityLabelLg1(),secondSerieModel.getPeriodicityLabelLg1()) && + Objects.equals(firstSerieModel.getPeriodicityLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicityLabelLg2(String mockedString){ + firstSerieModel.setPeriodicityLabelLg2(mockedString); + secondSerieModel.withPeriodicityLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieModel.getPeriodicityLabelLg2(),secondSerieModel.getPeriodicityLabelLg2()) && + Objects.equals(firstSerieModel.getPeriodicityLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeries(String mockedString){ + firstSerieModel.setSeries(mockedString); + secondSerieModel.withSeries(mockedString); + assertTrue(Objects.equals(firstSerieModel.getSeries(),secondSerieModel.getSeries()) && + Objects.equals(firstSerieModel.getSeries(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeLabelLg1(String mockedString){ + firstSerieModel.setTypeLabelLg1(mockedString); + secondSerieModel.withTypeLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieModel.getTypeLabelLg1(),secondSerieModel.getTypeLabelLg1()) && + Objects.equals(firstSerieModel.getTypeLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeLabelLg2(String mockedString){ + firstSerieModel.setTypeLabelLg2(mockedString); + secondSerieModel.withTypeLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieModel.getTypeLabelLg2(),secondSerieModel.getTypeLabelLg2()) && + Objects.equals(firstSerieModel.getTypeLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPeriodicity(String mockedString){ + firstSerieModel.setPeriodicity(mockedString); + secondSerieModel.withPeriodicity(mockedString); + assertTrue(Objects.equals(firstSerieModel.getPeriodicity(),secondSerieModel.getPeriodicity()) && + Objects.equals(firstSerieModel.getPeriodicity(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckTypeId(String mockedString){ + firstSerieModel.setTypeId(mockedString); + secondSerieModel.withTypeId(mockedString); + assertTrue(Objects.equals(firstSerieModel.getTypeId(),secondSerieModel.getTypeId()) && + Objects.equals(firstSerieModel.getTypeId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckId(String mockedString){ + firstSerieModel.setId(mockedString); + secondSerieModel.withId(mockedString); + assertTrue(Objects.equals(firstSerieModel.getId(),secondSerieModel.getId()) && + Objects.equals(firstSerieModel.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesLabelLg1(String mockedString){ + firstSerieModel.setSeriesLabelLg1(mockedString); + secondSerieModel.withSeriesLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieModel.getSeriesLabelLg1(),secondSerieModel.getSeriesLabelLg1()) && + Objects.equals(firstSerieModel.getSeriesLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesAltLabelLg1(String mockedString){ + firstSerieModel.setSeriesAltLabelLg1(mockedString); + secondSerieModel.withSeriesAltLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieModel.getSeriesAltLabelLg1(),secondSerieModel.getSeriesAltLabelLg1()) && + Objects.equals(firstSerieModel.getSeriesAltLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckNbOperations(String mockedString){ + firstSerieModel.setNbOperation(mockedString); + secondSerieModel.withNbOperation(mockedString); + assertTrue(Objects.equals(firstSerieModel.getNbOperation(),secondSerieModel.getNbOperation()) && + Objects.equals(firstSerieModel.getNbOperation(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamily(String mockedString){ + firstSerieModel.setFamily(mockedString); + secondSerieModel.withFamily(mockedString); + assertTrue(Objects.equals(firstSerieModel.getFamily(),secondSerieModel.getFamily()) && + Objects.equals(firstSerieModel.getFamily(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyLabelLg1(String mockedString){ + firstSerieModel.setFamilyLabelLg1(mockedString); + secondSerieModel.withFamilyLabelLg1(mockedString); + assertTrue(Objects.equals(firstSerieModel.getFamilyLabelLg1(),secondSerieModel.getFamilyLabelLg1()) && + Objects.equals(firstSerieModel.getFamilyLabelLg1(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesAltLabelLg2(String mockedString){ + firstSerieModel.setSeriesAltLabelLg2(mockedString); + secondSerieModel.withSeriesAltLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieModel.getSeriesAltLabelLg2(),secondSerieModel.getSeriesAltLabelLg2()) && + Objects.equals(firstSerieModel.getSeriesAltLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckFamilyLabelLg2(String mockedString){ + firstSerieModel.setFamilyLabelLg2(mockedString); + secondSerieModel.withFamilyLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieModel.getFamilyLabelLg2(),secondSerieModel.getFamilyLabelLg2()) && + Objects.equals(firstSerieModel.getFamilyLabelLg2(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSeriesLabelLg2(String mockedString){ + firstSerieModel.setSeriesLabelLg2(mockedString); + secondSerieModel.withSeriesLabelLg2(mockedString); + assertTrue(Objects.equals(firstSerieModel.getSeriesLabelLg2(),secondSerieModel.getSeriesLabelLg2()) && + Objects.equals(firstSerieModel.getSeriesLabelLg2(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstSerieModel.setAdditionalProperty("name","value"); + secondSerieModel.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstSerieModel.getAdditionalProperties(),secondSerieModel.getAdditionalProperties()) && + !Objects.equals(firstSerieModel.getAdditionalProperties(),additionalProperties)); + } + + + + +} \ No newline at end of file From f0a8beecd6d814398c4bff47d090f690c861ca42 Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:19:22 +0200 Subject: [PATCH 029/109] feat : methods for OrganisationModelTest.java --- .../organisation/OrganisationModelTest.java | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/organisation/OrganisationModelTest.java diff --git a/src/test/java/fr/insee/rmes/model/organisation/OrganisationModelTest.java b/src/test/java/fr/insee/rmes/model/organisation/OrganisationModelTest.java new file mode 100644 index 000000000..c38808097 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/organisation/OrganisationModelTest.java @@ -0,0 +1,87 @@ +package fr.insee.rmes.model.organisation; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class OrganisationModelTest { + + OrganisationModel firstOrganisationModel = new OrganisationModel( + "Id", + "uri", + "abreviation", + "prefLabelLg2", + "prefLabelLg1", + "altLabelLg2", + "altLabelLg1", + "uniteDe", + "sousTelleDe" + ); + + OrganisationModel secondOrganisationModel = new OrganisationModel(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckId(String mockedString){ + firstOrganisationModel.setId(mockedString); + assertEquals(firstOrganisationModel.getId(),mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUri(String mockedString){ + secondOrganisationModel.setUri(mockedString); + assertEquals(secondOrganisationModel.getUri(),mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckAbreviation(String mockedString){ + secondOrganisationModel.setAbreviation(mockedString); + assertEquals(secondOrganisationModel.getAbreviation(), mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUniteDe(String mockedString){ + secondOrganisationModel.setUniteDe(mockedString); + assertEquals(secondOrganisationModel.getUniteDe(), mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckSousTelleDe(String mockedString){ + secondOrganisationModel.setSousTelleDe(mockedString); + assertEquals(secondOrganisationModel.getSousTelleDe(), mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPrefLabelLg2(String mockedString){ + secondOrganisationModel.setPrefLabelLg2(mockedString); + assertEquals(secondOrganisationModel.getPrefLabelLg2(), mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckPrefLabelLg1(String mockedString){ + secondOrganisationModel.setPrefLabelLg1(mockedString); + assertEquals(secondOrganisationModel.getPrefLabelLg1(), mockedString); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckAltLabelLg1(String mockedString){ + secondOrganisationModel.setAltLabelLg1(mockedString); + assertEquals(secondOrganisationModel.getAltLabelLg1(), mockedString); + } + + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckAltLabelLg2(String mockedString){ + secondOrganisationModel.setAltLabelLg2(mockedString); + assertEquals(secondOrganisationModel.getAltLabelLg2(), mockedString); + } + +} \ No newline at end of file From ff82bd638fcd834722d6a8c4fac853fdf6df6b5d Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:21:00 +0200 Subject: [PATCH 030/109] feat : method for ValidationStatusTest.java --- .../insee/rmes/model/ValidationStatusTest.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/model/ValidationStatusTest.java diff --git a/src/test/java/fr/insee/rmes/model/ValidationStatusTest.java b/src/test/java/fr/insee/rmes/model/ValidationStatusTest.java new file mode 100644 index 000000000..eba77f4bd --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/ValidationStatusTest.java @@ -0,0 +1,18 @@ +package fr.insee.rmes.model; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class ValidationStatusTest { + + @Test + void shouldCheckClassOfEnumContainsAtLeastOneValue(){ + ValidationStatus[] numberOfValues = ValidationStatus.values(); + assertTrue(numberOfValues.length>0); + } + + @Test + void shouldCheckReturnTheSameValue(){ + assertEquals(ValidationStatus.MODIFIED.getValue(),ValidationStatus.MODIFIED.toString()); + } +} \ No newline at end of file From 6cdb8bf60f4747d4d7738ed5aefb401c42c5f5bd Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:21:36 +0200 Subject: [PATCH 031/109] feat : methods for LabelTest.java --- .../rmes/modelSwagger/codeList/LabelTest.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/modelSwagger/codeList/LabelTest.java diff --git a/src/test/java/fr/insee/rmes/modelSwagger/codeList/LabelTest.java b/src/test/java/fr/insee/rmes/modelSwagger/codeList/LabelTest.java new file mode 100644 index 000000000..10968e795 --- /dev/null +++ b/src/test/java/fr/insee/rmes/modelSwagger/codeList/LabelTest.java @@ -0,0 +1,43 @@ +package fr.insee.rmes.modelSwagger.codeList; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class LabelTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Label firstLabel = new Label("langue","contenu"); + Label secondLabel = new Label(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLangue(String mockedString){ + firstLabel.setLangue(mockedString); + secondLabel.withLangue(mockedString); + assertTrue(Objects.equals(firstLabel.getLangue(),secondLabel.getLangue()) && + Objects.equals(firstLabel.getLangue(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckContenu(String mockedString){ + firstLabel.setContenu(mockedString); + secondLabel.withContenu(mockedString); + assertTrue(Objects.equals(firstLabel.getContenu(),secondLabel.getContenu()) && + Objects.equals(firstLabel.getContenu(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstLabel.setAdditionalProperty("name","value"); + secondLabel.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstLabel.getAdditionalProperties(),secondLabel.getAdditionalProperties()) && + !Objects.equals(firstLabel.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From 849984ddfc9925f89df6dd6908b5123d13fa9149 Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:22:42 +0200 Subject: [PATCH 032/109] feat: methods for ListCodeByIdModelSwaggerTest.java --- .../ListCodeByIdModelSwaggerTest.java | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/modelSwagger/codeList/ListCodeByIdModelSwaggerTest.java diff --git a/src/test/java/fr/insee/rmes/modelSwagger/codeList/ListCodeByIdModelSwaggerTest.java b/src/test/java/fr/insee/rmes/modelSwagger/codeList/ListCodeByIdModelSwaggerTest.java new file mode 100644 index 000000000..1c52f0146 --- /dev/null +++ b/src/test/java/fr/insee/rmes/modelSwagger/codeList/ListCodeByIdModelSwaggerTest.java @@ -0,0 +1,87 @@ +package fr.insee.rmes.modelSwagger.codeList; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class ListCodeByIdModelSwaggerTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + List listCodes = List.of(new Code(),new Code()); + List listLabels= List.of(new Label__1(),new Label__1()); + + ListCodeByIdModelSwagger firstListCode = new ListCodeByIdModelSwagger( + listCodes, + "id", + listLabels, + "uri", + "version", + "dateMiseAJour" + ); + + ListCodeByIdModelSwagger secondListCode = new ListCodeByIdModelSwagger(); + + @Test + void shouldCheckCode(){ + firstListCode.setCodes(listCodes); + secondListCode.withCodes(listCodes); + assertTrue(Objects.equals(firstListCode.getCodes(),secondListCode.getCodes()) && + Objects.equals(firstListCode.getCodes(), listCodes)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckId(String mockedString){ + firstListCode.setId(mockedString); + secondListCode.withId(mockedString); + assertTrue(Objects.equals(firstListCode.getId(),secondListCode.getId()) && + Objects.equals(firstListCode.getId(), mockedString)); + } + + @Test + void shouldCheckLabel(){ + firstListCode.setLabel(listLabels); + secondListCode.withLabel(listLabels); + assertTrue(Objects.equals(firstListCode.getLabel(),secondListCode.getLabel()) && + Objects.equals(firstListCode.getLabel(), listLabels)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUri(String mockedString){ + firstListCode.setUri(mockedString); + secondListCode.withUri(mockedString); + assertTrue(Objects.equals(firstListCode.getUri(),secondListCode.getUri()) && + Objects.equals(firstListCode.getUri(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckVersion(String mockedString){ + firstListCode.setVersion(mockedString); + secondListCode.withVersion(mockedString); + assertTrue(Objects.equals(firstListCode.getVersion(),secondListCode.getVersion()) && + Objects.equals(firstListCode.getVersion(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckDateMiseAJour(String mockedString){ + secondListCode.setDateMiseAJour(mockedString); + assertEquals(secondListCode.getDateMiseAJour(),mockedString); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstListCode.setAdditionalProperty("name","value"); + secondListCode.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstListCode.getAdditionalProperties(),secondListCode.getAdditionalProperties()) && + !Objects.equals(firstListCode.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From 77d7cf2a8f29388f54bc058ce66dae697a892fb7 Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:25:30 +0200 Subject: [PATCH 033/109] feat: method for AllListCodeModelSwaggerTest.java --- .../codeList/AllListCodeModelSwaggerTest.java | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/modelSwagger/codeList/AllListCodeModelSwaggerTest.java diff --git a/src/test/java/fr/insee/rmes/modelSwagger/codeList/AllListCodeModelSwaggerTest.java b/src/test/java/fr/insee/rmes/modelSwagger/codeList/AllListCodeModelSwaggerTest.java new file mode 100644 index 000000000..ad3ab7348 --- /dev/null +++ b/src/test/java/fr/insee/rmes/modelSwagger/codeList/AllListCodeModelSwaggerTest.java @@ -0,0 +1,79 @@ +package fr.insee.rmes.modelSwagger.codeList; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class AllListCodeModelSwaggerTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + AllListCodeModelSwagger firstModel = new AllListCodeModelSwagger( + "ordre", + "id", + "version", + "statutValidation", + "dateMiseAJour" + ); + + AllListCodeModelSwagger secondModel = new AllListCodeModelSwagger(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckOrdre(String mockedString){ + firstModel.setOrdre(mockedString); + secondModel.withOrdre(mockedString); + assertTrue(Objects.equals(firstModel.getOrdre(),secondModel.getOrdre()) && + Objects.equals(firstModel.getOrdre(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckId(String mockedString){ + firstModel.setId(mockedString); + secondModel.withId(mockedString); + assertTrue(Objects.equals(firstModel.getId(),secondModel.getId()) && + Objects.equals(firstModel.getId(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckVersion(String mockedString){ + firstModel.setVersion(mockedString); + secondModel.withVersion(mockedString); + assertTrue(Objects.equals(firstModel.getVersion(),secondModel.getVersion()) && + Objects.equals(firstModel.getVersion(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckStatutValidation(String mockedString){ + firstModel.setStatutValidation(mockedString); + secondModel.withStatutValidation(mockedString); + assertTrue(Objects.equals(firstModel.getStatutValidation(),secondModel.getStatutValidation()) && + Objects.equals(firstModel.getStatutValidation(), mockedString)); + } + + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckDateMiseAJour(String mockedString){ + firstModel.setDateMiseAJour(mockedString); + secondModel.withDateMiseAJour(mockedString); + assertTrue(Objects.equals(firstModel.getDateMiseAJour(),secondModel.getDateMiseAJour()) && + Objects.equals(firstModel.getDateMiseAJour(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstModel.setAdditionalProperty("name","value"); + secondModel.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstModel.getAdditionalProperties(),secondModel.getAdditionalProperties()) && + !Objects.equals(firstModel.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From f161e44e7aa59a21ef9467fa46b9453a964419a0 Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:26:26 +0200 Subject: [PATCH 034/109] feat : methods for Label__1Test.java --- .../modelSwagger/codeList/Label__1Test.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/modelSwagger/codeList/Label__1Test.java diff --git a/src/test/java/fr/insee/rmes/modelSwagger/codeList/Label__1Test.java b/src/test/java/fr/insee/rmes/modelSwagger/codeList/Label__1Test.java new file mode 100644 index 000000000..e9069167d --- /dev/null +++ b/src/test/java/fr/insee/rmes/modelSwagger/codeList/Label__1Test.java @@ -0,0 +1,43 @@ +package fr.insee.rmes.modelSwagger.codeList; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class Label__1Test { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Label__1 firstLabel = new Label__1("langue","contenu"); + Label__1 secondLabel = new Label__1(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLangue(String mockedString){ + firstLabel.setLangue(mockedString); + secondLabel.withLangue(mockedString); + assertTrue(Objects.equals(firstLabel.getLangue(),secondLabel.getLangue()) && + Objects.equals(firstLabel.getLangue(), mockedString)); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckContenu(String mockedString){ + firstLabel.setContenu(mockedString); + secondLabel.withContenu(mockedString); + assertTrue(Objects.equals(firstLabel.getContenu(),secondLabel.getContenu()) && + Objects.equals(firstLabel.getContenu(), mockedString)); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstLabel.setAdditionalProperty("name","value"); + secondLabel.withAdditionalProperty("name","value"); + assertTrue(Objects.equals(firstLabel.getAdditionalProperties(),secondLabel.getAdditionalProperties()) && + !Objects.equals(firstLabel.getAdditionalProperties(),additionalProperties)); + } + +} \ No newline at end of file From bf5fafc086c198354d6c216d296048cf5f477b6e Mon Sep 17 00:00:00 2001 From: SM Date: Fri, 1 Aug 2025 11:28:17 +0200 Subject: [PATCH 035/109] feat : methods for CodeTest.java --- .../rmes/modelSwagger/codeList/CodeTest.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 src/test/java/fr/insee/rmes/modelSwagger/codeList/CodeTest.java diff --git a/src/test/java/fr/insee/rmes/modelSwagger/codeList/CodeTest.java b/src/test/java/fr/insee/rmes/modelSwagger/codeList/CodeTest.java new file mode 100644 index 000000000..2a53957f1 --- /dev/null +++ b/src/test/java/fr/insee/rmes/modelSwagger/codeList/CodeTest.java @@ -0,0 +1,54 @@ +package fr.insee.rmes.modelSwagger.codeList; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class CodeTest { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + List