From fc128118d1bca2862e28b39aae484b241c2ecd3b Mon Sep 17 00:00:00 2001 From: QDIBYS Date: Fri, 30 Jan 2026 15:50:52 +0100 Subject: [PATCH 1/6] chore: copy medataModel test to IT --- .../metadata/model/MetadataModelITest.java | 233 ++++++++++++++++++ 1 file changed, 233 insertions(+) create mode 100644 src/test/java/fr/insee/bpm/metadata/model/MetadataModelITest.java diff --git a/src/test/java/fr/insee/bpm/metadata/model/MetadataModelITest.java b/src/test/java/fr/insee/bpm/metadata/model/MetadataModelITest.java new file mode 100644 index 0000000..1c3609a --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/MetadataModelITest.java @@ -0,0 +1,233 @@ +package fr.insee.bpm.metadata.model; + +import fr.insee.bpm.metadata.Constants; +import lombok.extern.log4j.Log4j2; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +@Log4j2 +public class MetadataModelITest { + + private MetadataModel metadataModel; + + /** + * Return a VariablesMap object containing variables named as follows: + * - FIRST_NAME, LAST_NAME, AGE at the root + * - CAR_COLOR in a group named CARS_LOOP + */ + public static MetadataModel createCompleteFakeVariablesMap() { + + MetadataModel metadataM = new MetadataModel(); + + // Groups + Group rootGroup = metadataM.getRootGroup(); + Group carsGroup = new Group("CARS_LOOP", Constants.ROOT_GROUP_NAME); + metadataM.putGroup(carsGroup); + + // Variables + metadataM.getVariables().putVariable(new Variable("LAST_NAME", rootGroup, VariableType.STRING, "20")); + metadataM.getVariables().putVariable(new Variable("FIRST_NAME", rootGroup, VariableType.STRING, "50")); + metadataM.getVariables().putVariable(new Variable("AGE", rootGroup, VariableType.INTEGER, "50")); + metadataM.getVariables().putVariable(new Variable("CAR_COLOR", carsGroup, VariableType.STRING, "50")); + + // unique choice question variable + UcqVariable ucq = new UcqVariable("SEXE", rootGroup, VariableType.STRING, "50"); + ucq.addModality("1", "Male"); + ucq.addModality("2", "Female"); + Variable paperUcq1 = new PaperUcq("SEXE_1", ucq, "1"); + Variable paperUcq2 = new PaperUcq("SEXE_2", ucq, "2"); + metadataM.getVariables().putVariable(ucq); + metadataM.getVariables().putVariable(paperUcq1); + metadataM.getVariables().putVariable(paperUcq2); + + // unique choice question variable related to multiple choices question + UcqVariable ucqMcq1 = new UcqVariable("CAR_OWNER", rootGroup, VariableType.STRING, "50"); + ucqMcq1.setQuestionName("VEHICLE_OWNER"); + ucqMcq1.addModality("1", "Yes"); + ucqMcq1.addModality("2", "No"); + UcqVariable ucqMcq2 = new UcqVariable("MOTO_OWNER", rootGroup, VariableType.STRING, "50"); + ucqMcq2.setQuestionName("VEHICLE_OWNER"); + ucqMcq2.addModality("1", "Yes"); + ucqMcq2.addModality("2", "No"); + metadataM.getVariables().putVariable(ucqMcq1); + metadataM.getVariables().putVariable(ucqMcq2); + + // multiple choices question variable + metadataM.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_A").group(rootGroup).questionItemName("RELATIONSHIP").text("Spouse").build()); + metadataM.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_B").group(rootGroup).questionItemName("RELATIONSHIP").text("Child").build()); + metadataM.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_C").group(rootGroup).questionItemName("RELATIONSHIP").text("Parent").build()); + metadataM.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_D").group(rootGroup).questionItemName("RELATIONSHIP").text("Other").build()); + + return metadataM; + } + + @BeforeEach + void createTestVariablesMap() { + metadataModel = new MetadataModel(); + + Group rootGroup = metadataModel.getRootGroup(); + Group individualsGroup = new Group("INDIVIDUALS_LOOP", Constants.ROOT_GROUP_NAME); + Group carsGroup = new Group("CARS_LOOP", "INDIVIDUALS_LOOP"); + + metadataModel.putGroup(individualsGroup); + metadataModel.putGroup(carsGroup); + + metadataModel.getVariables().putVariable( + new Variable("ADDRESS", rootGroup, VariableType.STRING)); + metadataModel.getVariables().putVariable( + new Variable("HOUSEHOLD_INCOME", rootGroup, VariableType.NUMBER)); + metadataModel.getVariables().putVariable( + new Variable("FIRST_NAME", individualsGroup, VariableType.STRING)); + metadataModel.getVariables().putVariable( + new Variable("LAST_NAME", individualsGroup, VariableType.STRING)); + metadataModel.getVariables().putVariable( + new Variable("GENDER", individualsGroup, VariableType.STRING)); + metadataModel.getVariables().putVariable( + new Variable("CAR_COLOR", carsGroup, VariableType.STRING)); + } + + @Test + void testRootGroup() { + assertTrue(metadataModel.hasGroup(Constants.ROOT_GROUP_NAME)); + assertEquals(Constants.ROOT_GROUP_NAME, metadataModel.getRootGroup().getName()); + assertNull(metadataModel.getRootGroup().getParentName()); + } + + @Test + void testGetVariableByName() { + + // Get + Variable rootVariable = metadataModel.getVariables().getVariable("HOUSEHOLD_INCOME"); + Variable group1Variable = metadataModel.getVariables().getVariable("FIRST_NAME"); + Variable group2Variable = metadataModel.getVariables().getVariable("CAR_COLOR"); + + // Get a variable that does not exist + log.debug("Trying to get a variable that does not exist in a test function, " + + "a second message should pop in the log."); + Variable dummyVariable = metadataModel.getVariables().getVariable("DUMMY"); + + // + assertEquals("HOUSEHOLD_INCOME", rootVariable.getName()); + assertEquals("FIRST_NAME", group1Variable.getName()); + assertEquals("CAR_COLOR", group2Variable.getName()); + assertNull(dummyVariable); + } + + @Test + void testRemoveAndHasVariable() { + + // Remove + metadataModel.getVariables().removeVariable("HOUSEHOLD_INCOME"); + metadataModel.getVariables().removeVariable("CAR_COLOR"); + + // Remove a variable that does not exist + log.debug("Trying to remove a variable that does not exist in a test function, " + + "a second message should pop in the log."); + metadataModel.getVariables().removeVariable("FOO"); + + // + assertFalse(metadataModel.getVariables().hasVariable("HOUSEHOLD_INCOME")); + assertTrue(metadataModel.getVariables().hasVariable("FIRST_NAME")); + assertFalse(metadataModel.getVariables().hasVariable("CAR_COLOR")); + } + + @Test + void getIdentifierNamesTest() { + assertEquals( + List.of(Constants.ROOT_IDENTIFIER_NAME, "INDIVIDUALS_LOOP", "CARS_LOOP"), + metadataModel.getIdentifierNames() + ); + } + + @Test + void getFullyQualifiedNameTest() { + assertEquals("HOUSEHOLD_INCOME", + metadataModel.getFullyQualifiedName("HOUSEHOLD_INCOME")); + assertEquals("INDIVIDUALS_LOOP.FIRST_NAME", + metadataModel.getFullyQualifiedName("FIRST_NAME")); + assertEquals("INDIVIDUALS_LOOP.CARS_LOOP.CAR_COLOR", + metadataModel.getFullyQualifiedName("CAR_COLOR")); + } + + @Test + void testGetGroupVariableNames() { + assertTrue(metadataModel.getVariables().getGroupVariableNames(Constants.ROOT_GROUP_NAME) + .containsAll(Set.of("ADDRESS", "HOUSEHOLD_INCOME"))); + assertTrue(metadataModel.getVariables().getGroupVariableNames("INDIVIDUALS_LOOP") + .containsAll(Set.of("FIRST_NAME", "LAST_NAME", "GENDER"))); + assertTrue(metadataModel.getVariables().getGroupVariableNames("CARS_LOOP") + .contains("CAR_COLOR")); + } + + @Test + void testMcqMethods() { + // + Group group = metadataModel.getGroup("INDIVIDUALS_LOOP"); + metadataModel.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_A").group(group).questionItemName("RELATIONSHIP").text("Spouse").build()); + metadataModel.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_B").group(group).questionItemName("RELATIONSHIP").text("Child").build()); + metadataModel.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_C").group(group).questionItemName("RELATIONSHIP").text("Parent").build()); + metadataModel.getVariables().putVariable(McqVariable.builder() + .name("RELATIONSHIP_D").group(group).questionItemName("RELATIONSHIP").text("Other").build()); + // + assertTrue(metadataModel.getVariables().hasMcq("RELATIONSHIP")); + assertSame("RELATIONSHIP", metadataModel.getVariables().getVariable("RELATIONSHIP_A").getQuestionName()); + assertFalse(metadataModel.getVariables().hasMcq("ADDRESS")); + assertFalse(metadataModel.getVariables().hasMcq("FIRST_NAME")); + assertFalse(metadataModel.getVariables().hasMcq("CAR_COLOR")); + assertFalse(metadataModel.getVariables().hasMcq("UNKNOWN_QUESTION")); + // + assertSame(group, metadataModel.getVariables().getMcqGroup("RELATIONSHIP")); + assertNull(metadataModel.getVariables().getMcqGroup("ADDRESS")); + assertNull(metadataModel.getVariables().getMcqGroup("FIRST_NAME")); + assertNull(metadataModel.getVariables().getMcqGroup("CAR_COLOR")); + assertNull(metadataModel.getVariables().getMcqGroup("UNKNOWN_QUESTION")); + } + + /* Variables map objects to test multimode management */ + + @Test + void testGetVariablesNames() { + MetadataModel metadataMod = createCompleteFakeVariablesMap(); + // KSE et KGA à trouver, une par liste + List ucqMcqVariablesNames = metadataMod.getVariables().getUcqVariablesNames(); + List mcqVariablesNames = metadataMod.getVariables().getMcqVariablesNames(); + Set variablesNames = metadataMod.getVariables().getVariableNames(); + // Check ucq + assertTrue(ucqMcqVariablesNames.contains("VEHICLE_OWNER")); + assertFalse(ucqMcqVariablesNames.contains("CAR_OWNER")); + // Check mcq + assertFalse(mcqVariablesNames.contains("VEHICLE_OWNER")); + assertTrue(mcqVariablesNames.contains("RELATIONSHIP")); + assertFalse(mcqVariablesNames.contains("RELATIONSHIP_A")); + // Check mcq + assertFalse(variablesNames.contains("VEHICLE_OWNER")); + assertTrue(variablesNames.contains("CAR_OWNER")); + assertTrue(variablesNames.contains("MOTO_OWNER")); + + assertTrue(metadataMod.getVariables().hasMcq("RELATIONSHIP")); + assertTrue(metadataMod.getVariables().hasUcq("CAR_OWNER")); + assertTrue(metadataMod.getVariables().hasUcqMcq("CAR_OWNER")); + assertFalse(metadataMod.getVariables().hasUcqMcq("VEHICLE_OWNER")); + assertFalse(metadataMod.getVariables().hasMcq("ADDRESS")); + assertFalse(metadataMod.getVariables().hasMcq("FIRST_NAME")); + assertFalse(metadataMod.getVariables().hasMcq("CAR_COLOR")); + assertFalse(metadataMod.getVariables().hasMcq("UNKNOWN_QUESTION")); + } + +} From 99e3b5f7dd697e4ef1d22802fcb75e6af5de46ce Mon Sep 17 00:00:00 2001 From: QDIBYS Date: Fri, 30 Jan 2026 15:55:45 +0100 Subject: [PATCH 2/6] test: init models tests --- .../bpm/metadata/model/MetadataModel.java | 10 +- .../model/CalculatedVariablesTest.java | 61 +++ .../insee/bpm/metadata/model/GroupTest.java | 43 +- .../bpm/metadata/model/MetadataModelTest.java | 444 ++++++++++-------- .../bpm/metadata/model/PaperUcqTest.java | 41 ++ .../bpm/metadata/model/UcqVariableTest.java | 128 +++++ .../{VariableTest.java => VariableITest.java} | 2 +- 7 files changed, 528 insertions(+), 201 deletions(-) create mode 100644 src/test/java/fr/insee/bpm/metadata/model/CalculatedVariablesTest.java create mode 100644 src/test/java/fr/insee/bpm/metadata/model/PaperUcqTest.java create mode 100644 src/test/java/fr/insee/bpm/metadata/model/UcqVariableTest.java rename src/test/java/fr/insee/bpm/metadata/model/{VariableTest.java => VariableITest.java} (99%) diff --git a/src/main/java/fr/insee/bpm/metadata/model/MetadataModel.java b/src/main/java/fr/insee/bpm/metadata/model/MetadataModel.java index 538f568..f78f118 100644 --- a/src/main/java/fr/insee/bpm/metadata/model/MetadataModel.java +++ b/src/main/java/fr/insee/bpm/metadata/model/MetadataModel.java @@ -16,7 +16,8 @@ import java.util.stream.Collectors; @Slf4j -@Getter @Setter +@Getter +@Setter public class MetadataModel { private VariablesMap variables = new VariablesMap(); @@ -74,11 +75,14 @@ public List getSubGroupNames() { public int getGroupsCount() { return groups.size(); } - + /** Identifiers are not represented by Variable objects, they are: * - the root identifier (fixed value), * - each subgroup name is also an identifier name. - * @return The list of all identifiers associated to the variables map. */ + * @return The list of all identifiers associated to the variables map. + * DEPRECATED : Same logic as getGroupNames + * */ + @Deprecated(forRemoval = true) public List getIdentifierNames() { List res = new ArrayList<>(List.of(Constants.ROOT_IDENTIFIER_NAME)); res.addAll(getSubGroupNames()); diff --git a/src/test/java/fr/insee/bpm/metadata/model/CalculatedVariablesTest.java b/src/test/java/fr/insee/bpm/metadata/model/CalculatedVariablesTest.java new file mode 100644 index 0000000..2f2a862 --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/CalculatedVariablesTest.java @@ -0,0 +1,61 @@ +package fr.insee.bpm.metadata.model; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; + +class CalculatedVariablesTest { + + private CalculatedVariables calculatedVariables; + + public static final String VARIABLE_NAME = "test"; + + + @BeforeEach + void setUp() { + calculatedVariables = new CalculatedVariables(); + } + + @Test + void putVariable() { + //GIVEN + CalculatedVariables.CalculatedVariable calculatedVariable = new CalculatedVariables.CalculatedVariable(VARIABLE_NAME, ""); + + //WHEN + calculatedVariables.putVariable(calculatedVariable); + + //THEN + Assertions.assertThat(calculatedVariables).containsEntry(VARIABLE_NAME, calculatedVariable); + } + + @Test + void getVtlExpression() { + //GIVEN + String expectedVtlExpression = "testVtl"; + CalculatedVariables.CalculatedVariable calculatedVariable = new CalculatedVariables.CalculatedVariable(VARIABLE_NAME, expectedVtlExpression); + calculatedVariables.put(VARIABLE_NAME, calculatedVariable); + + //WHEN + String vtlExpression = calculatedVariables.getVtlExpression(VARIABLE_NAME); + + //THEN + Assertions.assertThat(vtlExpression).isEqualTo(expectedVtlExpression); + } + + @Test + void getDependantVariables() { + //GIVEN + String dependantVariableName = "testDependant"; + CalculatedVariables.CalculatedVariable calculatedVariable = new CalculatedVariables.CalculatedVariable(VARIABLE_NAME, ""); + calculatedVariable.dependantVariables.add(dependantVariableName); + calculatedVariables.put(VARIABLE_NAME, calculatedVariable); + + //WHEN + List actualDependantVariables = calculatedVariables.getDependantVariables(VARIABLE_NAME); + + //THEN + Assertions.assertThat(actualDependantVariables).containsExactly(dependantVariableName); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/bpm/metadata/model/GroupTest.java b/src/test/java/fr/insee/bpm/metadata/model/GroupTest.java index aa5ce9c..2eeac81 100644 --- a/src/test/java/fr/insee/bpm/metadata/model/GroupTest.java +++ b/src/test/java/fr/insee/bpm/metadata/model/GroupTest.java @@ -1,19 +1,50 @@ package fr.insee.bpm.metadata.model; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import static org.junit.jupiter.api.Assertions.assertThrows; - class GroupTest { +class GroupTest { + + private Group group; + + @BeforeEach + void setUp() { + group = new Group(); + } @Test - // @SuppressWarnings({"null", "ConstantConditions"}) - void nullParentName() { - assertThrows(NullPointerException.class, () -> new Group("TEST", null)); + @SuppressWarnings({"null", "ConstantConditions"}) + void constructorNullParentNameTest() { + assertThrows(NullPointerException.class, + () -> new Group("TEST", null) + ); } @Test - void emptyParentName() { - assertThrows(IllegalArgumentException.class, () -> new Group("TEST", "")); + void constructorEmptyParentNameTest() { + assertThrows(IllegalArgumentException.class, + () -> new Group("TEST", "") + ); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void isRootTest(boolean expectedBool) { + //GIVEN + if(!expectedBool){ + group.parentName = "parentName"; + } + + //WHEN + boolean result = group.isRoot(); + + //THEN + Assertions.assertThat(result).isEqualTo(expectedBool); + } } diff --git a/src/test/java/fr/insee/bpm/metadata/model/MetadataModelTest.java b/src/test/java/fr/insee/bpm/metadata/model/MetadataModelTest.java index cd9378b..ea709db 100644 --- a/src/test/java/fr/insee/bpm/metadata/model/MetadataModelTest.java +++ b/src/test/java/fr/insee/bpm/metadata/model/MetadataModelTest.java @@ -1,233 +1,295 @@ package fr.insee.bpm.metadata.model; import fr.insee.bpm.metadata.Constants; -import lombok.extern.log4j.Log4j2; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; 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.Set; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -@Log4j2 -public class MetadataModelTest { +class MetadataModelTest { private MetadataModel metadataModel; - /** - * Return a VariablesMap object containing variables named as follows: - * - FIRST_NAME, LAST_NAME, AGE at the root - * - CAR_COLOR in a group named CARS_LOOP - */ - public static MetadataModel createCompleteFakeVariablesMap() { - - MetadataModel metadataM = new MetadataModel(); - - // Groups - Group rootGroup = metadataM.getRootGroup(); - Group carsGroup = new Group("CARS_LOOP", Constants.ROOT_GROUP_NAME); - metadataM.putGroup(carsGroup); - - // Variables - metadataM.getVariables().putVariable(new Variable("LAST_NAME", rootGroup, VariableType.STRING, "20")); - metadataM.getVariables().putVariable(new Variable("FIRST_NAME", rootGroup, VariableType.STRING, "50")); - metadataM.getVariables().putVariable(new Variable("AGE", rootGroup, VariableType.INTEGER, "50")); - metadataM.getVariables().putVariable(new Variable("CAR_COLOR", carsGroup, VariableType.STRING, "50")); - - // unique choice question variable - UcqVariable ucq = new UcqVariable("SEXE", rootGroup, VariableType.STRING, "50"); - ucq.addModality("1", "Male"); - ucq.addModality("2", "Female"); - Variable paperUcq1 = new PaperUcq("SEXE_1", ucq, "1"); - Variable paperUcq2 = new PaperUcq("SEXE_2", ucq, "2"); - metadataM.getVariables().putVariable(ucq); - metadataM.getVariables().putVariable(paperUcq1); - metadataM.getVariables().putVariable(paperUcq2); - - // unique choice question variable related to multiple choices question - UcqVariable ucqMcq1 = new UcqVariable("CAR_OWNER", rootGroup, VariableType.STRING, "50"); - ucqMcq1.setQuestionName("VEHICLE_OWNER"); - ucqMcq1.addModality("1", "Yes"); - ucqMcq1.addModality("2", "No"); - UcqVariable ucqMcq2 = new UcqVariable("MOTO_OWNER", rootGroup, VariableType.STRING, "50"); - ucqMcq2.setQuestionName("VEHICLE_OWNER"); - ucqMcq2.addModality("1", "Yes"); - ucqMcq2.addModality("2", "No"); - metadataM.getVariables().putVariable(ucqMcq1); - metadataM.getVariables().putVariable(ucqMcq2); - - // multiple choices question variable - metadataM.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_A").group(rootGroup).questionItemName("RELATIONSHIP").text("Spouse").build()); - metadataM.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_B").group(rootGroup).questionItemName("RELATIONSHIP").text("Child").build()); - metadataM.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_C").group(rootGroup).questionItemName("RELATIONSHIP").text("Parent").build()); - metadataM.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_D").group(rootGroup).questionItemName("RELATIONSHIP").text("Other").build()); - - return metadataM; - } - @BeforeEach - void createTestVariablesMap() { + void setUp() { metadataModel = new MetadataModel(); + } + + @Test + void constructorPutRootGroupTest(){ + //WHEN + //Already done in setUp + + //THEN + Assertions.assertThat(metadataModel.getGroups()).containsKey(Constants.ROOT_GROUP_NAME); + Assertions.assertThat(metadataModel.getGroups().get(Constants.ROOT_GROUP_NAME)).isNotNull(); + Assertions.assertThat(metadataModel.getGroups().get(Constants.ROOT_GROUP_NAME).isRoot()).isTrue(); + } + + @Test + void putGroupTest(){ + //GIVEN + String groupName = "group"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + + //WHEN + metadataModel.putGroup(group); + + + //THEN + Assertions.assertThat(metadataModel.getGroups()).containsEntry(groupName, group); + } + + @Test + void getGroupTest(){ + //GIVEN + String groupName = "group"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + + //WHEN + Group result = metadataModel.getGroup(groupName); + + + //THEN + Assertions.assertThat(result).isEqualTo(group); + } + + @Test + void getRootGroupTest_noRootGroup(){ + //GIVEN + metadataModel.getGroups().remove(Constants.ROOT_GROUP_NAME); + + //WHEN + Group result = metadataModel.getRootGroup(); + + //THEN + Assertions.assertThat(result).isNull(); + } + + @Test + void getRootGroupTest(){ + //WHEN + Group result = metadataModel.getRootGroup(); + + //THEN + Assertions.assertThat(result).isNotNull(); + Assertions.assertThat(result.isRoot()).isTrue(); + Assertions.assertThat(result.getName()).isEqualTo(Constants.ROOT_GROUP_NAME); + } + + @Test + void getReportingDataGroupTest_notPresent(){ + //GIVEN + metadataModel.getGroups().remove(Constants.REPORTING_DATA_GROUP_NAME); + + //WHEN + Group result = metadataModel.getReportingDataGroup(); + + //THEN + Assertions.assertThat(result).isNull(); + } - Group rootGroup = metadataModel.getRootGroup(); - Group individualsGroup = new Group("INDIVIDUALS_LOOP", Constants.ROOT_GROUP_NAME); - Group carsGroup = new Group("CARS_LOOP", "INDIVIDUALS_LOOP"); + @Test + void getReportingDataGroupTest(){ + //GIVEN + metadataModel.getGroups().put(Constants.REPORTING_DATA_GROUP_NAME, new Group(Constants.REPORTING_DATA_GROUP_NAME)); + + //WHEN + Group result = metadataModel.getReportingDataGroup(); + + //THEN + Assertions.assertThat(result).isNotNull(); + Assertions.assertThat(result.getName()).isEqualTo(Constants.REPORTING_DATA_GROUP_NAME); + } - metadataModel.putGroup(individualsGroup); - metadataModel.putGroup(carsGroup); + @Test + void getGroupNamesTest(){ + //GIVEN + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + + //WHEN + List result = metadataModel.getGroupNames(); + + //THEN + Assertions.assertThat(result).containsExactlyInAnyOrder( + Constants.ROOT_GROUP_NAME, groupName + ); + } - metadataModel.getVariables().putVariable( - new Variable("ADDRESS", rootGroup, VariableType.STRING)); - metadataModel.getVariables().putVariable( - new Variable("HOUSEHOLD_INCOME", rootGroup, VariableType.NUMBER)); - metadataModel.getVariables().putVariable( - new Variable("FIRST_NAME", individualsGroup, VariableType.STRING)); - metadataModel.getVariables().putVariable( - new Variable("LAST_NAME", individualsGroup, VariableType.STRING)); - metadataModel.getVariables().putVariable( - new Variable("GENDER", individualsGroup, VariableType.STRING)); - metadataModel.getVariables().putVariable( - new Variable("CAR_COLOR", carsGroup, VariableType.STRING)); + @Test + void getSubGroupNamesTest(){ + //GIVEN + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + + //WHEN + List result = metadataModel.getSubGroupNames(); + + //THEN + Assertions.assertThat(result).containsExactly( + groupName + ); } @Test - void testRootGroup() { - assertTrue(metadataModel.hasGroup(Constants.ROOT_GROUP_NAME)); - assertEquals(Constants.ROOT_GROUP_NAME, metadataModel.getRootGroup().getName()); - assertNull(metadataModel.getRootGroup().getParentName()); + void getGroupsCountTest(){ + //GIVEN + int expectedGroupCount = metadataModel.getGroups().size(); + + //WHEN + THEN + Assertions.assertThat(metadataModel.getGroupsCount()).isEqualTo(expectedGroupCount); } @Test - void testGetVariableByName() { + void hasGroupTest(){ + //GIVEN + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + String absentGroupName = "absentGroupe"; + + //WHEN + THEN + Assertions.assertThat(metadataModel.hasGroup(groupName)).isTrue(); + Assertions.assertThat(metadataModel.hasGroup(absentGroupName)).isFalse(); + } + + @ParameterizedTest + @ValueSource(strings = {"","unknownVariable"}) + void getFullyQualifiedNameTest_unknownVariableOrEmpty(String variableName) { + //WHEN + THEN + Assertions.assertThat(metadataModel.getFullyQualifiedName(variableName)).isNull(); + } - // Get - Variable rootVariable = metadataModel.getVariables().getVariable("HOUSEHOLD_INCOME"); - Variable group1Variable = metadataModel.getVariables().getVariable("FIRST_NAME"); - Variable group2Variable = metadataModel.getVariables().getVariable("CAR_COLOR"); + @Test + void getFullyQualifiedNameTest_root() { + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable( + variableName, + metadataModel.getRootGroup(), + VariableType.STRING + ); + metadataModel.getVariables().variables.put(variableName, variable); - // Get a variable that does not exist - log.debug("Trying to get a variable that does not exist in a test function, " + - "a second message should pop in the log."); - Variable dummyVariable = metadataModel.getVariables().getVariable("DUMMY"); + //WHEN + String fullyQualifiedName = metadataModel.getFullyQualifiedName(variableName); - // - assertEquals("HOUSEHOLD_INCOME", rootVariable.getName()); - assertEquals("FIRST_NAME", group1Variable.getName()); - assertEquals("CAR_COLOR", group2Variable.getName()); - assertNull(dummyVariable); + //THEN + Assertions.assertThat(fullyQualifiedName).isEqualTo(variableName); } @Test - void testRemoveAndHasVariable() { + void getFullyQualifiedNameTest_group() { + //GIVEN + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + String variableName = "testVariable"; + Variable variable = new Variable( + variableName, + group, + VariableType.STRING + ); + metadataModel.getVariables().variables.put(variableName, variable); - // Remove - metadataModel.getVariables().removeVariable("HOUSEHOLD_INCOME"); - metadataModel.getVariables().removeVariable("CAR_COLOR"); - // Remove a variable that does not exist - log.debug("Trying to remove a variable that does not exist in a test function, " + - "a second message should pop in the log."); - metadataModel.getVariables().removeVariable("FOO"); + //WHEN + String fullyQualifiedName = metadataModel.getFullyQualifiedName(variableName); - // - assertFalse(metadataModel.getVariables().hasVariable("HOUSEHOLD_INCOME")); - assertTrue(metadataModel.getVariables().hasVariable("FIRST_NAME")); - assertFalse(metadataModel.getVariables().hasVariable("CAR_COLOR")); + //THEN + Assertions.assertThat(fullyQualifiedName).isEqualTo( + group.name + Constants.METADATA_SEPARATOR + variableName + ); } @Test - void getIdentifierNamesTest() { - assertEquals( - List.of(Constants.ROOT_IDENTIFIER_NAME, "INDIVIDUALS_LOOP", "CARS_LOOP"), - metadataModel.getIdentifierNames() + void getFullyQualifiedNamesTest() { + //GIVEN + //Group variable + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + String variableName = "testVariable"; + Variable variable = new Variable( + variableName, + group, + VariableType.STRING + ); + metadataModel.getVariables().variables.put(variableName, variable); + //Root variable + String rootVariableName = "testVariable2"; + Variable rootVariable = new Variable( + rootVariableName, + metadataModel.getRootGroup(), + VariableType.STRING + ); + metadataModel.getVariables().variables.put(rootVariableName, rootVariable); + + + //WHEN + Set fullyQualifiedNames = metadataModel.getFullyQualifiedNames(); + + //THEN + Assertions.assertThat(fullyQualifiedNames).containsExactlyInAnyOrder( + rootVariableName, + group.name + Constants.METADATA_SEPARATOR + variableName ); } + @Test - void getFullyQualifiedNameTest() { - assertEquals("HOUSEHOLD_INCOME", - metadataModel.getFullyQualifiedName("HOUSEHOLD_INCOME")); - assertEquals("INDIVIDUALS_LOOP.FIRST_NAME", - metadataModel.getFullyQualifiedName("FIRST_NAME")); - assertEquals("INDIVIDUALS_LOOP.CARS_LOOP.CAR_COLOR", - metadataModel.getFullyQualifiedName("CAR_COLOR")); - } - - @Test - void testGetGroupVariableNames() { - assertTrue(metadataModel.getVariables().getGroupVariableNames(Constants.ROOT_GROUP_NAME) - .containsAll(Set.of("ADDRESS", "HOUSEHOLD_INCOME"))); - assertTrue(metadataModel.getVariables().getGroupVariableNames("INDIVIDUALS_LOOP") - .containsAll(Set.of("FIRST_NAME", "LAST_NAME", "GENDER"))); - assertTrue(metadataModel.getVariables().getGroupVariableNames("CARS_LOOP") - .contains("CAR_COLOR")); - } - - @Test - void testMcqMethods() { - // - Group group = metadataModel.getGroup("INDIVIDUALS_LOOP"); - metadataModel.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_A").group(group).questionItemName("RELATIONSHIP").text("Spouse").build()); - metadataModel.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_B").group(group).questionItemName("RELATIONSHIP").text("Child").build()); - metadataModel.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_C").group(group).questionItemName("RELATIONSHIP").text("Parent").build()); - metadataModel.getVariables().putVariable(McqVariable.builder() - .name("RELATIONSHIP_D").group(group).questionItemName("RELATIONSHIP").text("Other").build()); - // - assertTrue(metadataModel.getVariables().hasMcq("RELATIONSHIP")); - assertSame("RELATIONSHIP", metadataModel.getVariables().getVariable("RELATIONSHIP_A").getQuestionName()); - assertFalse(metadataModel.getVariables().hasMcq("ADDRESS")); - assertFalse(metadataModel.getVariables().hasMcq("FIRST_NAME")); - assertFalse(metadataModel.getVariables().hasMcq("CAR_COLOR")); - assertFalse(metadataModel.getVariables().hasMcq("UNKNOWN_QUESTION")); - // - assertSame(group, metadataModel.getVariables().getMcqGroup("RELATIONSHIP")); - assertNull(metadataModel.getVariables().getMcqGroup("ADDRESS")); - assertNull(metadataModel.getVariables().getMcqGroup("FIRST_NAME")); - assertNull(metadataModel.getVariables().getMcqGroup("CAR_COLOR")); - assertNull(metadataModel.getVariables().getMcqGroup("UNKNOWN_QUESTION")); - } - - /* Variables map objects to test multimode management */ - - @Test - void testGetVariablesNames() { - MetadataModel metadataMod = createCompleteFakeVariablesMap(); - // KSE et KGA à trouver, une par liste - List ucqMcqVariablesNames = metadataMod.getVariables().getUcqVariablesNames(); - List mcqVariablesNames = metadataMod.getVariables().getMcqVariablesNames(); - Set variablesNames = metadataMod.getVariables().getVariableNames(); - // Check ucq - assertTrue(ucqMcqVariablesNames.contains("VEHICLE_OWNER")); - assertFalse(ucqMcqVariablesNames.contains("CAR_OWNER")); - // Check mcq - assertFalse(mcqVariablesNames.contains("VEHICLE_OWNER")); - assertTrue(mcqVariablesNames.contains("RELATIONSHIP")); - assertFalse(mcqVariablesNames.contains("RELATIONSHIP_A")); - // Check mcq - assertFalse(variablesNames.contains("VEHICLE_OWNER")); - assertTrue(variablesNames.contains("CAR_OWNER")); - assertTrue(variablesNames.contains("MOTO_OWNER")); - - assertTrue(metadataMod.getVariables().hasMcq("RELATIONSHIP")); - assertTrue(metadataMod.getVariables().hasUcq("CAR_OWNER")); - assertTrue(metadataMod.getVariables().hasUcqMcq("CAR_OWNER")); - assertFalse(metadataMod.getVariables().hasUcqMcq("VEHICLE_OWNER")); - assertFalse(metadataMod.getVariables().hasMcq("ADDRESS")); - assertFalse(metadataMod.getVariables().hasMcq("FIRST_NAME")); - assertFalse(metadataMod.getVariables().hasMcq("CAR_COLOR")); - assertFalse(metadataMod.getVariables().hasMcq("UNKNOWN_QUESTION")); + void getDistinctVariableNamesAndFullyQualifiedNamesTest() { + //GIVEN + //Group variable + String groupName = "testGroup"; + Group group = new Group(groupName, Constants.ROOT_GROUP_NAME); + metadataModel.getGroups().put(groupName, group); + String variableName = "testVariable"; + Variable variable = new Variable( + variableName, + group, + VariableType.STRING + ); + metadataModel.getVariables().variables.put(variableName, variable); + //Root variable + String rootVariableName = "testVariable2"; + Variable rootVariable = new Variable( + rootVariableName, + metadataModel.getRootGroup(), + VariableType.STRING + ); + metadataModel.getVariables().variables.put(rootVariableName, rootVariable); + + //WHEN + Set variableNames = metadataModel.getDistinctVariableNamesAndFullyQualifiedNames(); + + //THEN + Assertions.assertThat(variableNames).containsExactlyInAnyOrder( + rootVariableName, + variableName, + group.name + Constants.METADATA_SEPARATOR + variableName + ); } + @Test + void getSequencesName() { + //GIVEN + String sequenceName = "testSequence"; + Sequence sequence = new Sequence(sequenceName); + metadataModel.getSequences().add(sequence); + + //WHEN + List sequenceNames = metadataModel.getSequencesName(); + + //THEN + Assertions.assertThat(sequenceNames).containsExactly(sequenceName); + } } diff --git a/src/test/java/fr/insee/bpm/metadata/model/PaperUcqTest.java b/src/test/java/fr/insee/bpm/metadata/model/PaperUcqTest.java new file mode 100644 index 0000000..1e0adc1 --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/PaperUcqTest.java @@ -0,0 +1,41 @@ +package fr.insee.bpm.metadata.model; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +class PaperUcqTest { + + PaperUcq paperUcq; + + @Test + void argsConstructorTest() { + //GIVEN + String paperUcqName = "testPap"; + String correspondingValue = "testValue"; + + String ucqVariableName = "testVariableUcq"; + + UcqVariable ucqVariableMock = mock(UcqVariable.class); + doReturn(ucqVariableName).when(ucqVariableMock).getName(); + + UcqModality ucqModality = new UcqModality(); + doReturn(ucqModality).when(ucqVariableMock).getModalityFromValue(any()); + + paperUcq = new PaperUcq( + paperUcqName, + ucqVariableMock, + correspondingValue + ); + + //WHEN + //THEN + Assertions.assertThat(paperUcq.name).isEqualTo(paperUcqName); + Assertions.assertThat(paperUcq.ucqName).isEqualTo(ucqVariableName); + Assertions.assertThat(paperUcq.getType()).isEqualTo(VariableType.BOOLEAN); + Assertions.assertThat(ucqModality.variableName).isEqualTo(paperUcqName); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/bpm/metadata/model/UcqVariableTest.java b/src/test/java/fr/insee/bpm/metadata/model/UcqVariableTest.java new file mode 100644 index 0000000..41d3734 --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/UcqVariableTest.java @@ -0,0 +1,128 @@ +package fr.insee.bpm.metadata.model; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class UcqVariableTest { + + UcqVariable ucqVariable; + + @BeforeEach + void setUp() { + ucqVariable = new UcqVariable(); + } + + @Test + void addModalityTest_ucqModality(){ + //GIVEN + UcqModality ucqModality = new UcqModality(); + + //WHEN + ucqVariable.addModality(ucqModality); + + //THEN + Assertions.assertThat(ucqVariable.modalities).containsExactly(ucqModality); + } + + @Test + void addModalityTest_valueText(){ + //GIVEN + String expectedText = "test"; + String expectedValue = "testValue"; + + //WHEN + ucqVariable.addModality(expectedValue, expectedText); + + //THEN + Assertions.assertThat(ucqVariable.modalities).hasSize(1); + Assertions.assertThat(ucqVariable.modalities.getFirst().text).isEqualTo(expectedText); + Assertions.assertThat(ucqVariable.modalities.getFirst().value).isEqualTo(expectedValue); + } + + @Test + void addModalityTest_valueTextVariableName(){ + //GIVEN + String expectedText = "test"; + String expectedValue = "testValue"; + String expectedVariableName = "testVariable"; + + //WHEN + ucqVariable.addModality(expectedValue, expectedText, expectedVariableName); + + //THEN + Assertions.assertThat(ucqVariable.modalities).hasSize(1); + Assertions.assertThat(ucqVariable.modalities.getFirst().text).isEqualTo(expectedText); + Assertions.assertThat(ucqVariable.modalities.getFirst().value).isEqualTo(expectedValue); + Assertions.assertThat(ucqVariable.modalities.getFirst().variableName).isEqualTo(expectedVariableName); + } + + @Test + void getValuesTest(){ + //GIVEN + String expectedValue = "testValue"; + ucqVariable.modalities.add(new UcqModality(expectedValue, "test")); + + //WHEN + THEN + Assertions.assertThat(ucqVariable.getValues()).containsExactly(expectedValue); + + } + + @Test + void getModalityNamesTest(){ + //GIVEN + String expectedName = "testName"; + ucqVariable.modalities.add(new UcqModality("testValue", "testText", expectedName)); + + //WHEN + THEN + Assertions.assertThat(ucqVariable.getModalityNames()).containsExactly(expectedName); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void getModalityFromValueTest(boolean isMultiple){ + //GIVEN + String value = "testValue"; + ucqVariable.modalities.add(new UcqModality(value, "testText")); + if(isMultiple){ + ucqVariable.modalities.add(new UcqModality(value, "testText2")); + } + + //WHEN + UcqModality ucqModality = ucqVariable.getModalityFromValue(value); + + //THEN + Assertions.assertThat(ucqModality.value).isEqualTo(value); + } + + @Test + void getModalityFromValueTest_empty(){ + Assertions.assertThat(ucqVariable.getModalityFromValue("test")).isNull(); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void getModalityFromNameTest(boolean isMultiple){ + //GIVEN + String variableName = "testVariable"; + ucqVariable.modalities.add(new UcqModality("testValue", "testText", variableName)); + if(isMultiple){ + ucqVariable.modalities.add(new UcqModality("testValue2", "testText2", variableName)); + } + + //WHEN + UcqModality ucqModality = ucqVariable.getModalityFromName(variableName); + + //THEN + Assertions.assertThat(ucqModality.variableName).isEqualTo(variableName); + } + + @Test + void getModalityFromNameTest_empty(){ + Assertions.assertThat(ucqVariable.getModalityFromName("test")).isNull(); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/bpm/metadata/model/VariableTest.java b/src/test/java/fr/insee/bpm/metadata/model/VariableITest.java similarity index 99% rename from src/test/java/fr/insee/bpm/metadata/model/VariableTest.java rename to src/test/java/fr/insee/bpm/metadata/model/VariableITest.java index 082126f..3ab1afa 100644 --- a/src/test/java/fr/insee/bpm/metadata/model/VariableTest.java +++ b/src/test/java/fr/insee/bpm/metadata/model/VariableITest.java @@ -18,7 +18,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -class VariableTest { +class VariableITest { static final String DDI_FOLDER = TestConstants.UNIT_TESTS_DIRECTORY + "/ddi"; From 37b8269ac8fb2ff45aa2913b7fa9d8ad3e00cf7e Mon Sep 17 00:00:00 2001 From: QDIBYS Date: Fri, 30 Jan 2026 17:03:03 +0100 Subject: [PATCH 3/6] test: models unit tests --- .../bpm/metadata/model/VariableTest.java | 47 +++ .../bpm/metadata/model/VariablesMapTest.java | 313 ++++++++++++++++++ 2 files changed, 360 insertions(+) create mode 100644 src/test/java/fr/insee/bpm/metadata/model/VariableTest.java create mode 100644 src/test/java/fr/insee/bpm/metadata/model/VariablesMapTest.java diff --git a/src/test/java/fr/insee/bpm/metadata/model/VariableTest.java b/src/test/java/fr/insee/bpm/metadata/model/VariableTest.java new file mode 100644 index 0000000..cb98539 --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/VariableTest.java @@ -0,0 +1,47 @@ +package fr.insee.bpm.metadata.model; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class VariableTest { + + Variable variable; + + @BeforeEach + void setUp() { + variable = new Variable(); + } + + @Test + void getGroupNameTest(){ + //GIVEN + String groupName = "testGroup"; + variable.group = new Group(groupName); + + //WHEN + THEN + Assertions.assertThat(variable.getGroupName()).isEqualTo(groupName); + } + + @Test + void getExpectedLengthTest(){ + //GIVEN + variable.sasFormat = "3.test"; + + //WHEN + THEN + Assertions.assertThat(variable.getExpectedLength()).isEqualTo(3); + } + + @Test + void getExpectedLengthTest_noDot(){ + //GIVEN + variable.sasFormat = "2"; + + //WHEN + THEN + Assertions.assertThat(variable.getExpectedLength()).isEqualTo(2); + } + @Test + void getExpectedLengthTest_empty(){ + Assertions.assertThat(variable.getExpectedLength()).isEqualTo(1); + } +} \ No newline at end of file diff --git a/src/test/java/fr/insee/bpm/metadata/model/VariablesMapTest.java b/src/test/java/fr/insee/bpm/metadata/model/VariablesMapTest.java new file mode 100644 index 0000000..ba9c2a6 --- /dev/null +++ b/src/test/java/fr/insee/bpm/metadata/model/VariablesMapTest.java @@ -0,0 +1,313 @@ +package fr.insee.bpm.metadata.model; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class VariablesMapTest { + + VariablesMap variablesMap; + + @BeforeEach + void setUp() { + variablesMap = new VariablesMap(); + } + + @Test + void putVariableTest(){ + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group(), VariableType.STRING); + + //WHEN + variablesMap.putVariable(variable); + + //THEN + Assertions.assertThat(variablesMap.variables).containsEntry(variableName, variable); + } + + @Test + void putVariableTest_empty(){ + //GIVEN + Variable variable = new Variable(); + + //WHEN + variablesMap.putVariable(variable); + + //THEN + Assertions.assertThat(variablesMap.variables).isEmpty(); + } + + @Test + void removeVariableTest(){ + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group(), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + + //WHEN + variablesMap.removeVariable(variableName); + + //THEN + Assertions.assertThat(variablesMap.variables).doesNotContainKey(variableName); + } + + @Test + void getVariableTest(){ + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group(), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getVariable(variableName)).isEqualTo(variable); + } + + @Test + void getVariableTest_null(){ + //WHEN + THEN + Assertions.assertThat(variablesMap.getVariable("test")).isNull(); + } + + @Test + void getVariableNamesTest(){ + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group(), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + String variableName2 = "testVariable2"; + variable = new Variable(variableName, new Group(), VariableType.STRING); + variablesMap.getVariables().put(variableName2, variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getVariableNames()).containsExactlyInAnyOrder( + variableName, variableName2 + ); + } + + @Test + void getVariableNamesTest_null(){ + //GIVEN + variablesMap.variables = null; + + //WHEN + THEN + Assertions.assertThat(variablesMap.getVariableNames()).isNotNull().isEmpty(); + } + + @Test + void getGroupVariableNamesTest(){ + //GIVEN + //With group + String variableName = "testVariable"; + String groupName = "testGroup"; + Variable variable = new Variable(variableName, new Group(groupName), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + //No group + variable = new Variable("testVariable2", new Group("testGroup2"), VariableType.STRING); + variablesMap.getVariables().put("testVariable2", variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getGroupVariableNames(groupName)).containsExactly(variableName); + } + + @Test + void getGroupVariableNamesAsListTest(){ + //GIVEN + //With group + String variableName = "testVariable"; + String groupName = "testGroup"; + Variable variable = new Variable(variableName, new Group(groupName), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + //No group + variable = new Variable("testVariable2", new Group("testGroup2"), VariableType.STRING); + variablesMap.getVariables().put("testVariable2", variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getGroupVariableNamesAsList(groupName)).containsExactly(variableName); + } + + @Test + void hasVariableTest(){ + //GIVEN + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group(), VariableType.STRING); + variablesMap.getVariables().put(variableName, variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.hasVariable(variableName)).isTrue(); + Assertions.assertThat(variablesMap.hasVariable("absentVariable")).isFalse(); + } + + @Test + void hasMcqTest(){ + //GIVEN + String questionName = "question"; + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + mcqVariable.questionName = questionName; + variablesMap.getVariables().put(variableName, mcqVariable); + String questionName2 = "question2"; + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + ucqVariable.questionName = questionName2; + variablesMap.getVariables().put(variableName2, mcqVariable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.hasMcq(questionName)).isTrue(); + Assertions.assertThat(variablesMap.hasMcq(questionName2)).isFalse(); + Assertions.assertThat(variablesMap.hasMcq("absentQuestion")).isFalse(); + } + + @Test + void getMcqGroupTest(){ + //GIVEN + String questionName = "question"; + String variableName = "testVariable"; + String groupName = "testGroup"; + Group group = new Group(groupName); + McqVariable mcqVariable = new McqVariable(variableName, group, VariableType.BOOLEAN); + mcqVariable.questionName = questionName; + variablesMap.getVariables().put(variableName, mcqVariable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getMcqGroup(questionName)).isEqualTo(group); + Assertions.assertThat(variablesMap.getMcqGroup("absentQuestion")).isNull(); + } + + @Test + void isInQuestionGridTest(){ + //GIVEN + String questionName = "question"; + String variableName = "testVariable"; + Variable variable = new Variable(variableName, new Group("testGroup"), VariableType.STRING); + variable.questionName = questionName; + variable.isInQuestionGrid = true; + variablesMap.getVariables().put(variableName, variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.isInQuestionGrid(questionName)).isTrue(); + Assertions.assertThat(variablesMap.isInQuestionGrid("absentQuestion")).isFalse(); + } + + @Test + void getQuestionGridGroup(){ + //GIVEN + String questionName = "question"; + String variableName = "testVariable"; + String groupName = "testGroup"; + Group group = new Group(groupName); + Variable variable = new Variable(variableName, group, VariableType.STRING); + variable.questionName = questionName; + variable.isInQuestionGrid = true; + variablesMap.getVariables().put(variableName, variable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.getQuestionGridGroup(questionName)).isEqualTo(group); + Assertions.assertThat(variablesMap.getQuestionGridGroup("absentQuestion")).isNull(); + } + + @Test + void hasUcqTest(){ + //GIVEN + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + variablesMap.getVariables().put(variableName, mcqVariable); + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + variablesMap.getVariables().put(variableName2, ucqVariable); + + + //WHEN + THEN + Assertions.assertThat(variablesMap.hasUcq(variableName)).isFalse(); + Assertions.assertThat(variablesMap.hasUcq(variableName2)).isTrue(); + Assertions.assertThat(variablesMap.hasUcq("absentVariable")).isFalse(); + } + + @Test + void hasUcqMcqTest(){ + //GIVEN + String variableName = "testVariable"; + UcqVariable ucqVariable = new UcqVariable(variableName, new Group("testGroup2"), VariableType.STRING); + ucqVariable.questionName = "question"; + variablesMap.getVariables().put(variableName, ucqVariable); + String variableName2 = "testVariable2"; + ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + ucqVariable.questionName = ""; + variablesMap.getVariables().put(variableName2, ucqVariable); + + //WHEN + THEN + Assertions.assertThat(variablesMap.hasUcqMcq(variableName)).isTrue(); + Assertions.assertThat(variablesMap.hasUcqMcq(variableName2)).isFalse(); + Assertions.assertThat(variablesMap.hasUcqMcq("absentVariable")).isFalse(); + } + + @Test + void getUcqVariablesTest(){ + //GIVEN + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + variablesMap.getVariables().put(variableName, mcqVariable); + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + variablesMap.getVariables().put(variableName2, ucqVariable); + + + //WHEN + THEN + Assertions.assertThat(variablesMap.getUcqVariables()).containsExactly(ucqVariable); + } + + @Test + void getUcqVariablesNamesTest(){ + //GIVEN + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + variablesMap.getVariables().put(variableName, mcqVariable); + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + String questionName = "question"; + ucqVariable.questionName = questionName; + variablesMap.getVariables().put(variableName2, ucqVariable); + + + //WHEN + THEN + Assertions.assertThat(variablesMap.getUcqVariablesNames()).containsExactly(questionName); + } + + @Test + void getMcqVariablesNamesTest(){ + //GIVEN + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + String questionName = "question"; + mcqVariable.questionName = questionName; + variablesMap.getVariables().put(variableName, mcqVariable); + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + variablesMap.getVariables().put(variableName2, ucqVariable); + + + //WHEN + THEN + Assertions.assertThat(variablesMap.getMcqVariablesNames()).containsExactly(questionName); + } + + @Test + void getPaperUcqTest(){ + //GIVEN + String variableName = "testVariable"; + McqVariable mcqVariable = new McqVariable(variableName, new Group("testGroup"), VariableType.BOOLEAN); + String questionName = "question"; + mcqVariable.questionName = questionName; + variablesMap.getVariables().put(variableName, mcqVariable); + String variableName2 = "testVariable2"; + UcqVariable ucqVariable = new UcqVariable(variableName2, new Group("testGroup2"), VariableType.STRING); + String testValue = "testValue"; + ucqVariable.modalities.add(new UcqModality(testValue, "testText")); + variablesMap.getVariables().put(variableName2, ucqVariable); + PaperUcq paperUcq = new PaperUcq("testVariable3", ucqVariable, testValue); + variablesMap.getVariables().put("testVariable3", paperUcq); + + + //WHEN + THEN + Assertions.assertThat(variablesMap.getPaperUcq()).containsExactly(paperUcq); + } +} \ No newline at end of file From 119201b78642d1c5e5b850884e5f07cfb1d971c4 Mon Sep 17 00:00:00 2001 From: QDIBYS Date: Fri, 30 Jan 2026 17:19:19 +0100 Subject: [PATCH 4/6] test: variable type tests --- .run/Unit tests.run.xml | 14 +++++ .../bpm/metadata/model/VariableType.java | 3 +- .../bpm/metadata/model/VariableTypeTest.java | 52 +++++++++++++++++++ .../bpm/metadata/model/VariablesMapTest.java | 3 +- ...DDIReaderTest.java => DDIReaderITest.java} | 2 +- 5 files changed, 70 insertions(+), 4 deletions(-) create mode 100644 .run/Unit tests.run.xml create mode 100644 src/test/java/fr/insee/bpm/metadata/model/VariableTypeTest.java rename src/test/java/fr/insee/bpm/metadata/reader/ddi/{DDIReaderTest.java => DDIReaderITest.java} (99%) diff --git a/.run/Unit tests.run.xml b/.run/Unit tests.run.xml new file mode 100644 index 0000000..e4d1149 --- /dev/null +++ b/.run/Unit tests.run.xml @@ -0,0 +1,14 @@ + + + +