diff --git a/src/test/java/fr/insee/rmes/configuration/CommonSecurityConfigurationTest.java b/src/test/java/fr/insee/rmes/configuration/CommonSecurityConfigurationTest.java new file mode 100644 index 000000000..02a8a82df --- /dev/null +++ b/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); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/configuration/ForwardedHeaderFilterBeanTest.java b/src/test/java/fr/insee/rmes/configuration/ForwardedHeaderFilterBeanTest.java new file mode 100644 index 000000000..b11c85c08 --- /dev/null +++ b/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); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/configuration/InseeSpringdocPropertiesTest.java b/src/test/java/fr/insee/rmes/configuration/InseeSpringdocPropertiesTest.java new file mode 100644 index 000000000..2bc70b303 --- /dev/null +++ b/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); + } + + +} \ No newline at end of file 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..16b2547a5 --- /dev/null +++ b/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")); +} + + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordContributorTest.java b/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordContributorTest.java new file mode 100644 index 000000000..ab8cf3ad3 --- /dev/null +++ b/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()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatedTest.java b/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatedTest.java new file mode 100644 index 000000000..088484e35 --- /dev/null +++ b/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()); + } + + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatorTest.java b/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordCreatorTest.java new file mode 100644 index 000000000..5a1df3a91 --- /dev/null +++ b/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()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordModifiedTest.java b/src/test/java/fr/insee/rmes/model/datasets/CatalogRecordModifiedTest.java new file mode 100644 index 000000000..82284fb4d --- /dev/null +++ b/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()); + } + +} \ No newline at end of file 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..2f6d9e7be --- /dev/null +++ b/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 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)); + } + + + + +} \ No newline at end of file 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..aa4c0b159 --- /dev/null +++ b/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 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)); + } + +} \ No newline at end of file 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..6454cc9a1 --- /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 shouldReturnValueForDisseminationStatus(){ + String string = "mockedString"; + DisseminationStatus disseminationStatus = new DisseminationStatus(string); + assertEquals(string,disseminationStatus.toString()); + } +} \ No newline at end of file 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..0d24ec1d2 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/DistributionsTest.java @@ -0,0 +1,88 @@ +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 { + + Distributions distributions = new Distributions("mockedIdentifier","mockedUri"); + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckIdentifier(String mockedString){ + distributions.setIdentifier(mockedString); + assertEquals(mockedString,distributions.getIdentifier()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckByteSize(String mockedString){ + distributions.setByteSize(mockedString); + assertEquals(mockedString,distributions.getByteSize()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckCreated(String mockedString){ + distributions.setCreated(mockedString); + assertEquals(mockedString,distributions.getCreated()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckFormat(String mockedString){ + distributions.setFormat(mockedString); + assertEquals(mockedString,distributions.getFormat()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckModified(String mockedString){ + distributions.setModified(mockedString); + assertEquals(mockedString,distributions.getModified()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedSeries1", "mockedSeries2", "mockedSeries3" }) + void shouldCheckUri(String mockedString){ + distributions.setUri(mockedString); + assertEquals(mockedString,distributions.getUri()); + } + + @Test + void shouldCheckDescription(){ + List list = List.of (new LangContent(),new LangContent()); + distributions.setDescription(list); + assertEquals(list,distributions.getDescription()); + } + + @Test + void shouldCheckDownloadUrl(){ + List list = List.of ("url1","url2"); + distributions.setDownloadURL(list); + assertEquals(list,distributions.getDownloadURL()); + } + + @Test + void shouldCheckTitle(){ + List list = List.of (new LangContent(),new LangContent()); + distributions.setTitle(list); + assertEquals(list,distributions.getTitle()); + } + + @Test + void shouldCheckToStringContainsSomeAttributesOfDistribution(){ + Distributions distribution = new Distributions("identifier","uri"); + List list = List.of (new LangContent("lang","content")); + distribution.setTitle(list); + String actual= distribution.toString(); + assertTrue(actual.contains(distribution.getUri()) && + actual.contains(distribution.getIdentifier()) && + actual.contains(distribution.getTitle().toString())); + } + +} \ No newline at end of file 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..70740a6f1 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/IdTest.java @@ -0,0 +1,14 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class IdTest { + @ParameterizedTest + @ValueSource(strings = { "element1", "element2","element3" }) + void shouldReturnStringWhenToString(String string){ + Id id = new Id(string); + assertEquals(string,id.toString()); + } +} 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..b0e9137f0 --- /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.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class ModifiedTest { + + @ParameterizedTest + @ValueSource(strings = { "element1", "element2","element3" }) + void shouldReturnStringWhenToString(String string){ + Modified modified = new Modified(string); + assertEquals(string,modified.toString()); + } +} \ No newline at end of file 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..8e7393c8d --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/OperationTest.java @@ -0,0 +1,51 @@ +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 { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Operation firstOperation = new Operation("uri","id","labelOperationLg1","labelOperationLg2"); + Operation secondOperation = new Operation(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUriValue(String mockedString){ + secondOperation.setUri(mockedString); + assertEquals(mockedString,secondOperation.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckIdValue(String mockedString){ + firstOperation.setId(mockedString); + assertEquals(mockedString,firstOperation.getId()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelSerieLg1Value(String mockedString){ + firstOperation.setlabelOperationLg1(mockedString); + assertEquals(mockedString,firstOperation.getlabelOperationLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelSerieLg2Value(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 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..8fd208f0d --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/PatchDatasetPropertiesTest.java @@ -0,0 +1,18 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.api.Test; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class PatchDatasetPropertiesTest { + + @Test + void shouldCheckForDuplicates(){ + List values = Arrays.asList(PatchDatasetProperties.values()); + HashSet set = new HashSet<>(values); + assertEquals(set.size(),values.size()); + } + +} \ No newline at end of file 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..ebc4a279a --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/ProcessStepTest.java @@ -0,0 +1,19 @@ +package fr.insee.rmes.model.datasets; + +import fr.insee.rmes.modelSwagger.dataset.Label; +import fr.insee.rmes.modelSwagger.dataset.LangContent; +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 ProcessStepTest { + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldReturnNotNullProcessStep(String mockedString){ + ProcessStep processStep = new ProcessStep(mockedString,new Label(List.of(new LangContent()))); + assertNotNull(processStep); + } + +} \ No newline at end of file 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..ff4b1d9e7 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/SerieTest.java @@ -0,0 +1,50 @@ +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 { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Serie firstSerie = new Serie("uri", "id", "labelSerieLg1", "labelSerieLg2"); + Serie secondSerie = new Serie(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUriValue(String mockedString){ + secondSerie.setUri(mockedString); + assertEquals(mockedString,secondSerie.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckIdValue(String mockedString){ + firstSerie.setId(mockedString); + assertEquals(mockedString,firstSerie.getId()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelSerieLg1Value(String mockedString){ + firstSerie.setLabelSerieLg1(mockedString); + assertEquals(mockedString,firstSerie.getLabelSerieLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelSerieLg2Value(String mockedString){ + firstSerie.setLabelSerieLg2(mockedString); + assertEquals(mockedString,firstSerie.getLabelSerieLg2()); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstSerie.setAdditionalProperties(additionalProperties); + assertEquals(additionalProperties,firstSerie.getAdditionalProperties()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/model/datasets/SpatialTemporalTest.java b/src/test/java/fr/insee/rmes/model/datasets/SpatialTemporalTest.java new file mode 100644 index 000000000..4cb078929 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/SpatialTemporalTest.java @@ -0,0 +1,15 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class SpatialTemporalTest { + + @ParameterizedTest + @ValueSource(strings = { "element1", "element2","element3" }) + void shouldCheckSpatialTemporalAttributeValue(String string){ + SpatialTemporal spatialTemporal = new SpatialTemporal(string); + assertEquals(string,spatialTemporal.getSpatialTemporal()); + } +} \ No newline at end of file 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..2abee019e --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/ThemeTest.java @@ -0,0 +1,50 @@ +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 { + + Map additionalProperties = Map.of("key1", "value2","key2", "value2"); + + Theme firstTheme = new Theme("uri", "labelThemeLg1","labelThemeLg2","themeTaxonomy"); + Theme secondTheme = new Theme(); + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckUriValue(String mockedString){ + secondTheme.setUri(mockedString); + assertEquals(mockedString,secondTheme.getUri()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelThemeLg1Value(String mockedString){ + firstTheme.setLabelThemeLg1(mockedString); + assertEquals(mockedString,firstTheme.getLabelThemeLg1()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckLabelThemeLg2Value(String mockedString){ + firstTheme.setLabelThemeLg2(mockedString); + assertEquals(mockedString,firstTheme.getLabelThemeLg2()); + } + + @ParameterizedTest + @ValueSource(strings = { "mockedElement1", "mockedElement2", "mockedElement3" }) + void shouldCheckThemeTaxonomyValue(String mockedString){ + firstTheme.setThemeTaxonomy(mockedString); + assertEquals(mockedString,firstTheme.getThemeTaxonomy()); + } + + @Test + void shouldCheckAdditionalProperties(){ + firstTheme.setAdditionalProperties(additionalProperties); + assertEquals(additionalProperties,firstTheme.getAdditionalProperties()); + } + +} \ No newline at end of file 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..c8ad678b4 --- /dev/null +++ b/src/test/java/fr/insee/rmes/model/datasets/UriTest.java @@ -0,0 +1,16 @@ +package fr.insee.rmes.model.datasets; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.*; + +class UriTest { + + @ParameterizedTest + @ValueSource(strings = { "element1", "element2","element3" }) + void shouldReturnStringWhenToString(String string){ + Uri uri = new Uri(string); + assertEquals(string,uri.toString()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/persistence/ObjectTypeTest.java b/src/test/java/fr/insee/rmes/persistence/ObjectTypeTest.java new file mode 100644 index 000000000..6dd5565dd --- /dev/null +++ b/src/test/java/fr/insee/rmes/persistence/ObjectTypeTest.java @@ -0,0 +1,88 @@ +package fr.insee.rmes.persistence; + +import fr.insee.rmes.persistence.ontologies.*; +import fr.insee.rmes.utils.Constants; +import org.eclipse.rdf4j.model.vocabulary.FOAF; +import org.eclipse.rdf4j.model.vocabulary.SKOS; +import org.junit.jupiter.api.Test; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class ObjectTypeTest { + + List objects = List.of( + ObjectType.CONCEPT, + ObjectType.COLLECTION, + ObjectType.FAMILY, + ObjectType.SERIES, + ObjectType.OPERATION, + ObjectType.INDICATOR, + ObjectType.DOCUMENTATION, + ObjectType.DOCUMENT, + ObjectType.LINK, + ObjectType.GEO_STAT_TERRITORY, + ObjectType.ORGANIZATION, + ObjectType.STRUCTURE, + ObjectType.CODE_LIST, + ObjectType.MEASURE_PROPERTY, + ObjectType.ATTRIBUTE_PROPERTY, + ObjectType.DIMENSION_PROPERTY, + ObjectType.UNDEFINED); + + @Test + void shouldReturnLabelTypeForAllEnum(){ + + List labelTypes = List.of( + Constants.CONCEPT, + Constants.COLLECTION, + Constants.FAMILY, + "series", + "operation", + "indicator", + "documentation", + Constants.DOCUMENT, + "link", + "geoFeature", + "organization", + "structure", + Constants.CODELIST, + "measureProperty", + "attributeProperty", + "dimensionProperty", + Constants.UNDEFINED + ); + + HashSet set = new HashSet<>(); + + for (int i=0 ; i < objects.size() ; i++){ + boolean value = Objects.equals(objects.get(i).getLabelType(), labelTypes.get(i)); + set.add(value); + } + + assertTrue(set.size()==1 && set.contains(true)); + } + + @Test + void shouldReturnUriTypeForConcept(){ + assertTrue(ObjectType.CONCEPT.getUri()==SKOS.CONCEPT && + ObjectType.COLLECTION.getUri()== SKOS.COLLECTION && + ObjectType.FAMILY.getUri()== INSEE.FAMILY && + ObjectType.SERIES.getUri()==INSEE.SERIES && + ObjectType.OPERATION.getUri()==INSEE.OPERATION && + ObjectType.INDICATOR.getUri()== INSEE.INDICATOR && + ObjectType.DOCUMENTATION.getUri()==SDMX_MM.METADATA_REPORT && + ObjectType.DOCUMENT.getUri()==FOAF.DOCUMENT && + ObjectType.LINK.getUri()==FOAF.DOCUMENT && + ObjectType.GEO_STAT_TERRITORY.getUri()==GEO.FEATURE && + ObjectType.ORGANIZATION.getUri()==ORG.ORGANIZATION && + ObjectType.STRUCTURE.getUri()==QB.DATA_STRUCTURE_DEFINITION && + ObjectType.CODE_LIST.getUri()== QB.CODE_LIST && + ObjectType.MEASURE_PROPERTY.getUri()==QB.MEASURE_PROPERTY && + ObjectType.ATTRIBUTE_PROPERTY.getUri()==QB.ATTRIBUTE_PROPERTY && + ObjectType.DIMENSION_PROPERTY.getUri()==QB.DIMENSION_PROPERTY && + ObjectType.UNDEFINED.getUri()==null); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/persistence/RdfUtilsTest.java b/src/test/java/fr/insee/rmes/persistence/RdfUtilsTest.java new file mode 100644 index 000000000..7d9cfb1a5 --- /dev/null +++ b/src/test/java/fr/insee/rmes/persistence/RdfUtilsTest.java @@ -0,0 +1,13 @@ +package fr.insee.rmes.persistence; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class RdfUtilsTest { + + @Test + void shouldReturnNotNullValueFactory(){ + assertNotNull(RdfUtils.factory.toString()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/persistence/RepositoryUtilsTest.java b/src/test/java/fr/insee/rmes/persistence/RepositoryUtilsTest.java new file mode 100644 index 000000000..b68b1a4dd --- /dev/null +++ b/src/test/java/fr/insee/rmes/persistence/RepositoryUtilsTest.java @@ -0,0 +1,24 @@ +package fr.insee.rmes.persistence; + +import org.eclipse.rdf4j.repository.Repository; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class RepositoryUtilsTest { + + @Test + void shouldNullInitRepository(){ + String emptySesameServer=""; + String nullSesameServer=null; + boolean nullBecauseOfEmptySesameServer= RepositoryUtils.initRepository(emptySesameServer,"mockedRepositoryID")==null; + boolean nullBecauseOfNullSesameServer= RepositoryUtils.initRepository(nullSesameServer,"mockedRepositoryID")==null; + assertTrue(nullBecauseOfEmptySesameServer && nullBecauseOfNullSesameServer); + } + + @Test + void shouldReturnNotNullRepository(){ + Repository result = RepositoryUtils.initRepository("emptySesameServer","mockedRepositoryID"); + assertNotNull(result); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/persistence/rdfQueries/QueryUtilsTest.java b/src/test/java/fr/insee/rmes/persistence/rdfQueries/QueryUtilsTest.java new file mode 100644 index 000000000..248b8542c --- /dev/null +++ b/src/test/java/fr/insee/rmes/persistence/rdfQueries/QueryUtilsTest.java @@ -0,0 +1,43 @@ +package fr.insee.rmes.persistence.rdfQueries; + +import fr.insee.rmes.utils.Constants; +import org.json.JSONArray; +import org.json.JSONObject; +import org.junit.jupiter.api.Test; +import org.springframework.util.StringUtils; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class QueryUtilsTest { + + @Test + void shouldReturnCorrectEmptyGroupConcat() { + List res = List.of("[{\"altLabel\":\"\"}]","example"); + boolean isCorrectEmptyGroupConcatFirst = "[]".equals(QueryUtils.correctEmptyGroupConcat(res.getFirst())); + boolean isCorrectEmptyGroupConcatLast = "example".equals(QueryUtils.correctEmptyGroupConcat(res.getLast())); + assertTrue(isCorrectEmptyGroupConcatFirst && isCorrectEmptyGroupConcatLast); + } + + @Test + void shouldReturnCorrectTransformRdfTypeInString() { + JSONArray jsonArray = new JSONArray(); + + JSONObject jsonObjectFirst = new JSONObject(); + jsonObjectFirst.put("FirstAttribute","FirstAttributeExample").put("FirstCreator","FirstCreatorExample"); + + JSONObject jsonObjectLast = new JSONObject(); + jsonObjectLast.put("LastAttribute","LastAttributeExample").put(Constants.TYPE_OF_OBJECT,"https://creatorExample/myCreator"); + + jsonArray.put(jsonObjectFirst).put(jsonObjectLast); + + JSONArray results = QueryUtils.transformRdfTypeInString(jsonArray); + + assertEquals("[{\"FirstAttribute\":\"FirstAttributeExample\",\"FirstCreator\":\"FirstCreatorExample\"},{\"LastAttribute\":\"LastAttributeExample\",\"type\":\"undefined\"}]",results.toString()); + } + + @Test + void shouldCheckNumberOfPrefixesIsNotZero() { + int numberOfPrefixes = StringUtils.countOccurrencesOf(QueryUtils.PREFIXES, "PREFIX"); + assertTrue(numberOfPrefixes>0); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/services/utils/CommonMethodsTest.java b/src/test/java/fr/insee/rmes/services/utils/CommonMethodsTest.java new file mode 100644 index 000000000..320142ba4 --- /dev/null +++ b/src/test/java/fr/insee/rmes/services/utils/CommonMethodsTest.java @@ -0,0 +1,32 @@ +package fr.insee.rmes.services.utils; + +import org.json.JSONObject; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class CommonMethodsTest { + + @Test + void shouldNotRemovePrefLabelsWhenBothPrefLabelsAreAbsents(){ + JSONObject jsonObject = new JSONObject().put("sentence","hello the world").put("animal","rabbit"); + String before= jsonObject.toString(); + CommonMethods.removePrefLabels(jsonObject); + assertEquals(before,jsonObject.toString()); + } + + @Test + void shouldNotRemovePrefLabelsWhenOneOfPrefLabelsIsAbsent(){ + JSONObject jsonObject = new JSONObject().put("prefLabelLg1","label1").put("animal","rabbit"); + String before= jsonObject.toString(); + CommonMethods.removePrefLabels(jsonObject); + assertEquals(before,jsonObject.toString()); + } + + @Test + void shouldRemovePrefLabelsWhenNoPrefLabelsIsAbsent(){ + JSONObject jsonObject = new JSONObject().put("prefLabelLg1","label1").put("animal","rabbit").put("prefLabelLg2","label2"); + CommonMethods.removePrefLabels(jsonObject); + assertEquals("{\"animal\":\"rabbit\"}",jsonObject.toString()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/utils/ConstantsTest.java b/src/test/java/fr/insee/rmes/utils/ConstantsTest.java new file mode 100644 index 000000000..adde08743 --- /dev/null +++ b/src/test/java/fr/insee/rmes/utils/ConstantsTest.java @@ -0,0 +1,44 @@ +package fr.insee.rmes.utils; + +import org.junit.jupiter.api.Test; +import java.util.HashSet; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class ConstantsTest { + + @Test + void shouldConfirmTheExistenceOfDuplicatesInStaticConstants(){ + + List elements = List.of( + Constants.CODELIST, + Constants.CODELISTS_QUERIES_PATH, + Constants.COMPONENTS_QUERIES_PATH, + Constants.CONCEPT, + Constants.CONCEPTS_QUERIES_PATH, + Constants.COLLECTION, + Constants.DATASETS_QUERIES_PATH, + Constants.DOCUMENT, + Constants.FAMILY, + Constants.ID, + Constants.LABEL, + Constants.NOTATION, + Constants.POGUES_QUERIES_PATH, + Constants.PREF_LABEL_LG1, + Constants.PREF_LABEL_LG2, + Constants.ORGANISATIONS_QUERIES_PATH, + Constants.STRUCTURES_QUERIES_PATH, + Constants.STATUT_VALIDATION, + Constants.TYPE_OF_OBJECT, + Constants.UNDEFINED, + Constants.URI, + Constants.URL, + Constants.VALUE, + Constants.PARENTS); + + HashSet values = new HashSet<>(elements); + + assertNotEquals(values.size(),elements.size()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/utils/config/freemarker/FreemarkerConfigTest.java b/src/test/java/fr/insee/rmes/utils/config/freemarker/FreemarkerConfigTest.java new file mode 100644 index 000000000..9a3d14fa1 --- /dev/null +++ b/src/test/java/fr/insee/rmes/utils/config/freemarker/FreemarkerConfigTest.java @@ -0,0 +1,26 @@ +package fr.insee.rmes.utils.config.freemarker; + +import org.junit.jupiter.api.Test; +import static fr.insee.rmes.utils.config.freemarker.FreemarkerConfig.cfg; +import static org.junit.jupiter.api.Assertions.*; + +class FreemarkerConfigTest { + + @Test + void shouldInitializeCfg(){ + var before = cfg; + FreemarkerConfig.init(); + var after = cfg; + assertNotEquals(after,before); + } + + @Test + void shouldCompareGetCfgAndInit(){ + FreemarkerConfig.init(); + var before = cfg; + FreemarkerConfig.getCfg(); + var after = cfg; + assertEquals(after,before); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/utils/exceptions/RestMessageTest.java b/src/test/java/fr/insee/rmes/utils/exceptions/RestMessageTest.java new file mode 100644 index 000000000..e762a207e --- /dev/null +++ b/src/test/java/fr/insee/rmes/utils/exceptions/RestMessageTest.java @@ -0,0 +1,30 @@ +package fr.insee.rmes.utils.exceptions; + +import org.junit.jupiter.api.Test; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class RestMessageTest { + + @Test + void shouldInitializeRestMessage(){ + int status =200; + String message = "mockedMessage"; + String details = "mockedDetails"; + + RestMessage restMessage = new RestMessage(100, "message", "details"); + + restMessage.setStatus(status); + restMessage.setMessage(message); + restMessage.setDetails(details); + + boolean correctValueOfStatus = restMessage.getStatus()== status; + boolean correctValueOfMessage = Objects.equals(restMessage.getMessage(), message); + boolean correctValueOfDetails = Objects.equals(restMessage.getDetails(), details); + + assertTrue(correctValueOfStatus && correctValueOfMessage && correctValueOfDetails ); + + + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionHandlerTest.java b/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionHandlerTest.java new file mode 100644 index 000000000..0ae04b743 --- /dev/null +++ b/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionHandlerTest.java @@ -0,0 +1,29 @@ +package fr.insee.rmes.utils.exceptions; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.http.ResponseEntity; +import static java.lang.String.valueOf; +import static org.junit.jupiter.api.Assertions.*; + +class RmesExceptionHandlerTest { + + @ParameterizedTest + @ValueSource(ints = { 200, 301,302,401,403,404,500,502,503,504 }) + void shouldCheckHandleRmesException(int code){ + RmesExceptionHandler rmesExceptionHandler = new RmesExceptionHandler(); + ResponseEntity response = rmesExceptionHandler.handleRmesException(new RmesException(code,"mockedMessage","mockedStatus")); + assertTrue(response.toString().contains(valueOf(code))); + } + + @ParameterizedTest + @ValueSource(ints = { 499,1001,874,2156,741 }) + void shouldReturnIllegalArgumentExceptionWhenHandleRmesException(int fakeCode){ + RmesExceptionHandler rmesExceptionHandler = new RmesExceptionHandler(); + RmesException exampleRmesException = new RmesException(fakeCode,"mockedMessage","mockedStatus"); + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, ()->rmesExceptionHandler.handleRmesException(exampleRmesException)); + String expected = "No matching constant for ["+fakeCode+"]"; + assertEquals(expected,exception.getMessage()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionTest.java b/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionTest.java new file mode 100644 index 000000000..455c17649 --- /dev/null +++ b/src/test/java/fr/insee/rmes/utils/exceptions/RmesExceptionTest.java @@ -0,0 +1,80 @@ +package fr.insee.rmes.utils.exceptions; + +import org.json.JSONArray; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.http.HttpStatus; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.*; + +class RmesExceptionTest { + + int status = 200; + String message = "mockedMessage"; + String details = "mockedDetails"; + JSONArray jsonArrayDetails = new JSONArray().put("details"); + int errorCode = 0; + HttpStatus statusBis = HttpStatus.OK; + + + RmesException firstRmesException = new RmesException(status,message,details); + RmesException secondRmesException = new RmesException(status,message,jsonArrayDetails); + RmesException thirdRmesException = new RmesException(status,errorCode,message,details); + RmesException sixthRmesException = new RmesException(status,errorCode,message,jsonArrayDetails); + RmesException seventhRmesException = new RmesException(status,errorCode,message,details); + + + @Test + void shouldReturnGetDetails(){ + RmesException fourthRmesException = new RmesException(status,errorCode,details); + RmesException fifthRmesException = new RmesException(status,errorCode,jsonArrayDetails); + RmesException eigththRmesException = new RmesException(statusBis, message, details); + + assertTrue(Objects.equals(fourthRmesException.getMessageAndDetails2(), "null {\"code\":0}") && + Objects.equals(fifthRmesException.getMessageAndDetails2(), "null {\"code\":0}") && + Objects.equals(eigththRmesException.getDetails(), details) + ); + } + + + @Test + void shouldReturnGetMessage(){ + HashSet setMessages = new HashSet<>(); + setMessages.add(firstRmesException.getMessage()); + setMessages.add(secondRmesException.getMessage()); + setMessages.add(thirdRmesException.getMessage()); + setMessages.add(sixthRmesException.getMessage()); + setMessages.add(seventhRmesException.getMessage()); + assertTrue(setMessages.size()==1 && setMessages.contains(null)); + } + + @ParameterizedTest + @ValueSource(ints = { 2, 4,400,56,32,5669,8852 }) + void shouldReturnRestMessageWhenToRestMessageAndGetStatus(int mockedStatus){ + List rmesExceptions = List.of( + new RmesException(mockedStatus,message,details), + new RmesException(mockedStatus,message,jsonArrayDetails), + new RmesException(mockedStatus,errorCode,message,details), + new RmesException(mockedStatus,errorCode,details), + new RmesException(mockedStatus,errorCode,jsonArrayDetails), + new RmesException(mockedStatus,errorCode,message,jsonArrayDetails), + new RmesException(mockedStatus,errorCode,message,details), + new RmesException(mockedStatus, message, details)); + + HashSet setOfRestMessage = new HashSet<>(); + HashSet setOfRmesExceptionGetMessage = new HashSet<>(); + + for(RmesException rmesException : rmesExceptions){ + setOfRestMessage.add(rmesException.toRestMessage().getStatus()==mockedStatus); + setOfRmesExceptionGetMessage.add(rmesException.getStatus()==mockedStatus); + } + + assertTrue(setOfRestMessage.size()==1 && + setOfRestMessage.contains(true) && + setOfRmesExceptionGetMessage.size()==1 && + setOfRmesExceptionGetMessage.contains(true)); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/security/configuration/TokenConverterConfigurationTest.java b/src/test/java/fr/insee/security/configuration/TokenConverterConfigurationTest.java new file mode 100644 index 000000000..e23cf25e4 --- /dev/null +++ b/src/test/java/fr/insee/security/configuration/TokenConverterConfigurationTest.java @@ -0,0 +1,22 @@ +package fr.insee.security.configuration; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class TokenConverterConfigurationTest { + + @Test + void shouldGrantedAuthorityDefault(){ + String actual = TokenConverterConfiguration.grantedAuthorityDefaults().toString(); + String expected = "org.springframework.security.config.core.GrantedAuthorityDefaults@"; + assertTrue(actual.contains(expected)); + } + + @Test + void shouldJwtAuthenticationConverter(){ + InseeSecurityTokenProperties property = new InseeSecurityTokenProperties("oidcClaimRole","oidcClaimUsername","oidcRolesInClaimRole","email"); + TokenConverterConfiguration token = new TokenConverterConfiguration(property); + assertNotNull(token.jwtAuthenticationConverter()); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/security/configuration/UserDecoderConfigurationTest.java b/src/test/java/fr/insee/security/configuration/UserDecoderConfigurationTest.java new file mode 100644 index 000000000..25b9dbf5f --- /dev/null +++ b/src/test/java/fr/insee/security/configuration/UserDecoderConfigurationTest.java @@ -0,0 +1,17 @@ +package fr.insee.security.configuration; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class UserDecoderConfigurationTest { + + @Test + void shouldJwtAuthenticationConverter(){ + InseeSecurityTokenProperties property = new InseeSecurityTokenProperties("oidcClaimRole","oidcClaimUsername","oidcRolesInClaimRole","email"); + UserDecoderConfiguration token = new UserDecoderConfiguration(property); + String signature = token.userDecoder().toString(); + String expected = "fr.insee.security.configuration.UserDecoderConfiguration"; + assertTrue(signature.contains(expected)); + } + +} \ No newline at end of file diff --git a/src/test/java/fr/insee/security/internal/InseeJwtGrantedAuthoritiesConverterTest.java b/src/test/java/fr/insee/security/internal/InseeJwtGrantedAuthoritiesConverterTest.java new file mode 100644 index 000000000..c901574cc --- /dev/null +++ b/src/test/java/fr/insee/security/internal/InseeJwtGrantedAuthoritiesConverterTest.java @@ -0,0 +1,31 @@ +package fr.insee.security.internal; + +import org.json.JSONObject; +import org.junit.jupiter.api.Test; +import org.springframework.security.oauth2.jwt.Jwt; +import java.time.Instant; +import java.util.HashMap; +import java.util.Map; +import static org.junit.jupiter.api.Assertions.*; + +class InseeJwtGrantedAuthoritiesConverterTest { + + @Test + void shouldReturnBullPointerExceptionWhenConvertResult() { + InseeJwtGrantedAuthoritiesConverter converter= new InseeJwtGrantedAuthoritiesConverter("roleClaimKey","keyForRolesInRoleClaim"); + + Map headers = new HashMap<>(); + headers.put("key",new JSONObject().put("firstMockedKey","firstMockedElement")); + + Map claims = new HashMap<>(); + claims.put("key",new JSONObject().put("secondMockedKey","secondMockedElement")); + + Instant issuedAt = Instant.ofEpochSecond(100); + Instant expiresAt = Instant.ofEpochSecond(200); + + Jwt jwt = new Jwt("tokenValue",issuedAt,expiresAt, headers, claims); + + assertThrows(NullPointerException.class, ()->converter.convert(jwt)); + + } +} \ No newline at end of file