feat: new tests for Magma

src/test/java/fr/insee/rmes/configuration/CommonSecurityConfigurationTest.java

@@ -0,0 +1,14 @@
+package fr.insee.rmes.configuration;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class CommonSecurityConfigurationTest {
+
+    @Test
+    void shouldInitializeConstructor(){
+        CommonSecurityConfiguration commonSecurityConfiguration = new CommonSecurityConfiguration();
+        assertNotNull(commonSecurityConfiguration);
+    }
+
+}

src/test/java/fr/insee/rmes/configuration/ForwardedHeaderFilterBeanTest.java

@@ -0,0 +1,17 @@
+package fr.insee.rmes.configuration;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.web.filter.ForwardedHeaderFilter;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ForwardedHeaderFilterBeanTest {
+
+    @Test
+    void shouldInitializeConstructor(){
+        ForwardedHeaderFilterBean forwardedHeaderFilterBean = new ForwardedHeaderFilterBean();
+        ForwardedHeaderFilter forwardedHeaderFilter = forwardedHeaderFilterBean.forwardedHeaderFilter();
+        assertNotNull(forwardedHeaderFilter);
+    }
+
+}

src/test/java/fr/insee/rmes/configuration/InseeSpringdocPropertiesTest.java

@@ -0,0 +1,15 @@
+package fr.insee.rmes.configuration;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class InseeSpringdocPropertiesTest {
+
+    @Test
+    void shouldInitializeConstructor(){
+        InseeSpringdocProperties inseeSpringdocProperties = new InseeSpringdocProperties();
+        assertNotNull(inseeSpringdocProperties);
+    }
+
+
+}

src/test/java/fr/insee/rmes/dto/datasets/PatchDatasetDTOTest.java

@@ -0,0 +1,27 @@
+package fr.insee.rmes.dto.datasets;
+
+import fr.insee.rmes.modelSwagger.dataset.Temporal;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PatchDatasetDTOTest {
+
+    @Test
+    void shouldInitializeConstructor(){
+        PatchDatasetDTO patchDatasetDTO = new PatchDatasetDTO(
+                "issued",
+                "modified",
+                new Temporal("startPeriod","endPeriod"),
+                45,
+                78);
+
+        assertNotNull(patchDatasetDTO);}
+
+    @Test
+    void shouldNotInitializeConstructor(){
+        RuntimeException exception = assertThrows(RuntimeException.class, ()-> new PatchDatasetDTO(null, null, null, null, null));
+        assertTrue(exception.getMessage().contains("All required fields are null"));
+}
+
+
+}

src/test/java/fr/insee/rmes/model/datasets/CatalogRecordContributorTest.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 CatalogRecordContributorTest {
+
+    @Test
+    void shouldInitializeCatalogRecordContributor(){
+        String value = "mockedValue";
+        CatalogRecordContributor catalogRecordContributor = new CatalogRecordContributor(value);
+        assertEquals(value,catalogRecordContributor.getValue());
+    }
+
+}

src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatedTest.java

@@ -0,0 +1,16 @@
+package fr.insee.rmes.model.datasets;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class CatalogRecordCreatedTest {
+
+    @Test
+    void shouldInitializeCatalogRecordCreated(){
+        String value = "mockedValue";
+        CatalogRecordCreated catalogRecordCreated = new CatalogRecordCreated(value);
+        assertEquals(value,catalogRecordCreated.getValue());
+    }
+
+
+}

src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatorTest.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 CatalogRecordCreatorTest {
+
+    @Test
+    void shouldInitializeCatalogRecordCreator(){
+        String value = "mockedValue";
+        CatalogRecordCreator catalogRecordCreator = new CatalogRecordCreator(value);
+        assertEquals(value,catalogRecordCreator.getValue());
+    }
+
+}

src/test/java/fr/insee/rmes/model/datasets/CatalogRecordModifiedTest.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 CatalogRecordModifiedTest {
+
+    @Test
+    void shouldInitializeCatalogRecordModified(){
+        String value = "mockedValue";
+        CatalogRecordModified catalogRecordModified = new CatalogRecordModified(value);
+        assertEquals(value,catalogRecordModified.getValue());
+    }
+
+}

src/test/java/fr/insee/rmes/model/datasets/DataSetByIdTest.java

@@ -0,0 +1,101 @@
+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 java.util.Objects;
+import static org.junit.jupiter.api.Assertions.*;
+
+class DataSetByIdTest {
+
+    Map<String, Object> additionalProperties = Map.of("key1", "value2","key2", "value2");
+
+    String operationStat= "mockedOperationStat";
+    String dateCreation ="mockedDateCreation";
+    String names= "mockedNames";
+    String dateModification= "mockedDateModification";
+    String titreLg1= "mockedTitreLg1";
+    String id= "mockedId";
+    String titreLg2= "mockedTitreLg2";
+    String uri= "uri";
+
+    DataSetById firstDataSetById = new DataSetById();
+    DataSetById secondDataSetById= new DataSetById(operationStat, dateCreation, names, dateModification, titreLg1, id, titreLg2, uri);
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckDateModification(String mockedString){
+        firstDataSetById.setDateModification(mockedString);
+        secondDataSetById.withDateModification(mockedString);
+        assertTrue(Objects.equals(firstDataSetById.getDateModification(), secondDataSetById.getDateModification()) &&
+                Objects.equals(firstDataSetById.getDateModification(), mockedString));
+    }
+
+    @Test
+    void shouldCheckAdditionalProperties(){
+        firstDataSetById.setAdditionalProperty("name","value");
+        secondDataSetById.withAdditionalProperty("name","value");
+        assertTrue(Objects.equals(firstDataSetById.getAdditionalProperties(), secondDataSetById.getAdditionalProperties()) &&
+                !Objects.equals(firstDataSetById.getAdditionalProperties(),additionalProperties));
+    }
+
+
+
+
+}

src/test/java/fr/insee/rmes/model/datasets/DataSetTest.java

@@ -0,0 +1,123 @@
+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 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= "uri";
+    String serie = "mockedSerie";
+
+    Map<String, Object> additionalProperties = Map.of("key1", "value2","key2", "value2");
+
+    DataSet firstDataSet = new DataSet();
+    DataSet secondDataSet= new DataSet(dateCreation,names, dateMiseAJour, serie, titreLg1, id, titreLg2, uri);
+    DataSet thirdDataSet= new DataSet(dateCreation,names, dateMiseAJour, serie, titreLg1, id, titreLg2, uri);
+    DataSet fourthDataSet = new DataSet(statutValidation,dateCreation,names, dateMiseAJour, operationStat, titreLg1, id, titreLg2,uri);
+    DataSet fivethDataSet = new DataSet("idDataset1","uriDataset1", "titreFrDataset1", "titreEnDataset1","s","publié", "s1");
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    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 = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckDateMiseAJour(String mockedString){
+        firstDataSet.setDateMiseAJour(mockedString);
+        secondDataSet.withDateMiseAJour(mockedString);
+        assertTrue(Objects.equals(firstDataSet.getDateMiseAJour(), secondDataSet.getDateMiseAJour()) &&
+                Objects.equals(firstDataSet.getDateMiseAJour(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckNames(String mockedString){
+        thirdDataSet.setNames(mockedString);
+        fourthDataSet.withNames(mockedString);
+        assertTrue(Objects.equals(thirdDataSet.getNames(), fourthDataSet.getNames()) &&
+                Objects.equals(thirdDataSet.getNames(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckSeries(String mockedString){
+        fivethDataSet.setSerie(mockedString);
+        thirdDataSet.withSerie(mockedString);
+        assertTrue(Objects.equals(fivethDataSet.getSerie(), thirdDataSet.getSerie()) &&
+                Objects.equals(fivethDataSet.getSerie(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckTitreLg1(String mockedString){
+        firstDataSet.setTitreLg1(mockedString);
+        secondDataSet.withTitreLg1(mockedString);
+        assertTrue(Objects.equals(firstDataSet.getTitreLg1(), secondDataSet.getTitreLg1()) &&
+                Objects.equals(firstDataSet.getTitreLg1(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckTitreLg2(String mockedString){
+        firstDataSet.setTitreLg2(mockedString);
+        secondDataSet.withTitreLg2(mockedString);
+        assertTrue(Objects.equals(firstDataSet.getTitreLg2(), secondDataSet.getTitreLg2()) &&
+                Objects.equals(firstDataSet.getTitreLg2(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckId(String mockedString){
+        firstDataSet.setId(mockedString);
+        secondDataSet.withId(mockedString);
+        assertTrue(Objects.equals(firstDataSet.getId(), secondDataSet.getId()) &&
+                Objects.equals(firstDataSet.getId(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckUri(String mockedString){
+        firstDataSet.setUri(mockedString);
+        secondDataSet.withUri(mockedString);
+        assertTrue(Objects.equals(firstDataSet.getUri(), secondDataSet.getUri()) &&
+                Objects.equals(firstDataSet.getUri(), mockedString));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" })
+    void shouldCheckStatutValidation(String mockedString){
+        firstDataSet.setStatutValidation(mockedString);
+        assertEquals(firstDataSet.getStatutValidation(), mockedString);
+    }
+
+    @Test
+    void shouldCheckOperation(){
+        assertEquals(operationStat, fourthDataSet.getOperationStat());
+    }
+
+    @Test
+    void shouldCheckAdditionalProperties(){
+        firstDataSet.setAdditionalProperty("name","value");
+        secondDataSet.withAdditionalProperty("name","value");
+        assertTrue(Objects.equals(firstDataSet.getAdditionalProperties(), secondDataSet.getAdditionalProperties()) &&
+                !Objects.equals(firstDataSet.getAdditionalProperties(),additionalProperties));
+    }
+
+}

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 shouldReturnValueForDisseminationStatus(){
+        String string = "mockedString";
+        DisseminationStatus disseminationStatus = new DisseminationStatus(string);
+        assertEquals(string,disseminationStatus.toString());
+    }
+}