feat : 355-proposer-des-tests-pour-magma

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<String> 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<String> expectedStaticElements = new HashSet<>(actualStaticElements);
+        assertEquals(expectedStaticElements.size(),actualStaticElements.size());
+    }
+
+
+}

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")
+        );
+
+    }
+}

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

src/test/java/fr/insee/rmes/model/CodeList/CodeListTest.java

@@ -0,0 +1,38 @@
+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<Code> 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);
+
+
+    }
+
+
+}

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

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

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 nameExample = mockedString.split("/")[0];
+        String value = mockedString.split("/")[1];
+        firstConceptById.setAdditionalProperty(nameExample,value);
+        secondConceptById.withAdditionalProperty(nameExample,value);
+        assertTrue(("{" + nameExample + "=" + value + "}").equals(firstConceptById.getAdditionalProperties().toString())&&
+                ("{" + nameExample + "=" + value + "}").equals(secondConceptById.getAdditionalProperties().toString()));
+    }
+
+}

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