Add test cases for validateStructureMap

efsity/src/main/java/org/smartregister/command/ValidateStructureMapCommand.java

@@ -243,7 +243,7 @@ void validateStructureMapForProject(
     }
   }
 
-   Map<String, String> getQuestionnaireToStructureMapIdMap(
+  Map<String, String> getQuestionnaireToStructureMapIdMap(
       JsonArray questionnaires, JsonArray structureMaps) {
     Map<String, String> questionnaireToStructureMapIdMap = new HashMap<>();
 
@@ -266,8 +266,7 @@ Map<String, String> getQuestionnaireToStructureMapIdMap(
     return questionnaireToStructureMapIdMap;
   }
 
-  private boolean hasQuestionnaireReferenceToStructureMap(
-      JsonObject questionnaire, String structureMapId) {
+  boolean hasQuestionnaireReferenceToStructureMap(JsonObject questionnaire, String structureMapId) {
     // Check if the questionnaire has an extension with a reference to the structure map
     if (questionnaire.has("extension")) {
       JsonArray extensions = questionnaire.getAsJsonArray("extension");

efsity/src/test/java/org/smartregister/command/ValidateStructureMapCommandTest.java

@@ -2,12 +2,16 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -17,7 +21,6 @@ public class ValidateStructureMapCommandTest {
   private ValidateStructureMapCommand validateStructureMapCommand;
   private File tempFile;
   private Path tempDirectory;
-  private Path generatedResourcesPath;
 
   @BeforeEach
   public void setUp() throws IOException {
@@ -27,10 +30,20 @@ public void setUp() throws IOException {
 
     try (FileWriter writer = new FileWriter(tempFile)) {
       writer.write(
-          "{\"questionnaire1\": \"structureMap1\", \"questionnaire2\": \"structureMap2\"}");
+          "{\n"
+              + "  \"resourceType\": \"Composition\",\n"
+              + "  \"section\": [\n"
+              + "    {\n"
+              + "      \"title\": \"Questionnaires\",\n"
+              + "      \"section\": [{ \"title\": \"Questionnaire1\" }]\n"
+              + "    },\n"
+              + "    {\n"
+              + "      \"title\": \"StructureMaps\",\n"
+              + "      \"section\": [{ \"title\": \"StructureMap1\" }]\n"
+              + "    }\n"
+              + "  ]\n"
+              + "}");
     }
-
-    generatedResourcesPath = tempDirectory.resolve("generatedResources");
   }
 
   @AfterEach
@@ -47,46 +60,111 @@ public void tearDown() throws IOException {
   }
 
   @Test
-  void testGetResourceFiles() throws IOException {
-    // Create a valid JSON file
-    File jsonFile = new File(tempDirectory.toFile(), "validQuestionnaire.json");
-    try (FileWriter writer = new FileWriter(jsonFile)) {
-      writer.write("{\"resourceType\": \"Questionnaire\"}");
-    }
+  public void testIsProjectModeReturnsFalseForFile() {
+    assertFalse(validateStructureMapCommand.isProjectMode(tempFile.toString()));
+  }
 
-    ArrayList<String> filesArray =
-        ValidateStructureMapCommand.getResourceFiles(tempDirectory.toString());
-    assertTrue(filesArray.contains(jsonFile.getAbsolutePath()));
+  @Test
+  public void testParseCompositionFile() throws IOException {
+    JsonObject composition = validateStructureMapCommand.parseCompositionFile(tempFile.getPath());
+    assertNotNull(composition);
+    assertEquals("Composition", composition.get("resourceType").getAsString());
+  }
 
-    // Test with an invalid file
-    File nonJsonFile = new File(tempDirectory.toFile(), "invalidFile.txt");
-    try (FileWriter writer = new FileWriter(nonJsonFile)) {
-      writer.write("Not a JSON file");
-    }
+  @Test
+  public void testGetQuestionnairesFromComposition() throws IOException {
+    JsonObject composition = validateStructureMapCommand.parseCompositionFile(tempFile.getPath());
+    JsonArray questionnaires =
+        validateStructureMapCommand.getQuestionnairesFromComposition(composition);
+    assertNotNull(questionnaires);
+    assertEquals(1, questionnaires.size());
+    assertEquals(
+        "Questionnaire1", questionnaires.get(0).getAsJsonObject().get("title").getAsString());
+  }
 
-    filesArray = ValidateStructureMapCommand.getResourceFiles(tempDirectory.toString());
-    assertFalse(filesArray.contains(nonJsonFile.getAbsolutePath()));
+  @Test
+  public void testGetStructureMapsFromComposition() throws IOException {
+    JsonObject composition = validateStructureMapCommand.parseCompositionFile(tempFile.getPath());
+    JsonArray structureMaps =
+        validateStructureMapCommand.getStructureMapsFromComposition(composition);
+    assertNotNull(structureMaps);
+    assertEquals(1, structureMaps.size());
+    assertEquals(
+        "StructureMap1", structureMaps.get(0).getAsJsonObject().get("title").getAsString());
   }
 
   @Test
-  void testAddFhirResource() throws IOException {
-    File jsonFile = new File(tempDirectory.toFile(), "questionnaire.json");
-    try (FileWriter writer = new FileWriter(jsonFile)) {
-      writer.write("{\"resourceType\": \"Questionnaire\"}");
-    }
+  public void testGetQuestionnaireToStructureMapIdMap() {
+    // Create a Questionnaire with an extension linking it to a StructureMap
+    JsonArray questionnaires = new JsonArray();
+    JsonObject questionnaire = new JsonObject();
+    questionnaire.addProperty("title", "Questionnaire1");
+
+    // Add the extension with a reference to the StructureMap
+    JsonArray extensions = new JsonArray();
+    JsonObject extension = new JsonObject();
+    extension.addProperty(
+        "url",
+        "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-targetStructureMap");
+
+    JsonObject valueReference = new JsonObject();
+    valueReference.addProperty("reference", "StructureMap/StructureMap1");
+
+    extension.add("valueReference", valueReference);
+    extensions.add(extension);
+
+    questionnaire.add("extension", extensions);
+    questionnaires.add(questionnaire);
+
+    // Create a StructureMap
+    JsonArray structureMaps = new JsonArray();
+    JsonObject structureMap = new JsonObject();
+    structureMap.addProperty("title", "StructureMap1");
+    structureMaps.add(structureMap);
+
+    // Expected map
+    Map<String, String> expectedMap = new HashMap<>();
+    expectedMap.put("Questionnaire1", "StructureMap1");
+
+    // Test actual output from the method
+    Map<String, String> actualMap =
+        validateStructureMapCommand.getQuestionnaireToStructureMapIdMap(
+            questionnaires, structureMaps);
+
+    // Assert equality of expected and actual results
+    assertEquals(expectedMap, actualMap);
+  }
 
-    ArrayList<String> filesArray = new ArrayList<>();
-    ValidateStructureMapCommand.addFhirResource(jsonFile.getAbsolutePath(), filesArray);
+  @Test
+  public void testHasQuestionnaireReferenceToStructureMap() {
+    JsonObject questionnaire = new JsonObject();
+    JsonArray extensions = new JsonArray();
+    JsonObject extension = new JsonObject();
+    extension.addProperty(
+        "url",
+        "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-targetStructureMap");
+    JsonObject valueReference = new JsonObject();
+    valueReference.addProperty("reference", "StructureMap/StructureMap1");
+    extension.add("valueReference", valueReference);
+    extensions.add(extension);
+    questionnaire.add("extension", extensions);
+
+    assertTrue(
+        validateStructureMapCommand.hasQuestionnaireReferenceToStructureMap(
+            questionnaire, "StructureMap1"));
+  }
 
-    assertTrue(filesArray.contains(jsonFile.getAbsolutePath()));
+  @Test
+  public void testAddFhirResourceAddsQuestionnaireResource() throws IOException {
+    ArrayList<String> filesArray = new ArrayList<>();
+    File questionnaireFile = Files.createFile(tempDirectory.resolve("questionnaire.json")).toFile();
 
-    // Test with invalid JSON
-    File invalidJsonFile = new File(tempDirectory.toFile(), "invalid.json");
-    try (FileWriter writer = new FileWriter(invalidJsonFile)) {
-      writer.write("{\"resourceType\": \"Other\"}");
+    try (FileWriter writer = new FileWriter(questionnaireFile)) {
+      writer.write("{\"resourceType\": \"Questionnaire\"}");
     }
 
-    ValidateStructureMapCommand.addFhirResource(invalidJsonFile.getAbsolutePath(), filesArray);
-    assertFalse(filesArray.contains(invalidJsonFile.getAbsolutePath()));
+    ValidateStructureMapCommand.addFhirResource(questionnaireFile.getAbsolutePath(), filesArray);
+    assertEquals(1, filesArray.size());
+    assertTrue(filesArray.get(0).contains("questionnaire.json"));
   }
 }