Split files to smaller ones and tidy up the whole test package

Author: ozgliderpilot

memex/CONTRIBUTING.md

@@ -39,6 +39,21 @@ For integration tests requiring a database, we use Testcontainers to spin up a M
     *   **Requirement**: A Docker daemon must be running locally for this to work (e.g., by starting Docker Desktop).
 *   **Using an External MongoDB**: If you do not have Docker available, or wish to use a specific external MongoDB instance for testing, you can specify its connection string by setting the `spring.data.mongodb.uri` property in `src/test/resources/application-test.properties`. In this case, Testcontainers will not attempt to start a local MongoDB container.
 
+### Test Data `testid` Range
+
+To ensure test data isolation and prevent unintended side effects, vehicle inspection `testid` values used during test setup and execution **must** fall within a dedicated range. This range is defined by the following properties in `src/test/resources/application-test.properties`:
+*   `memex.test.data.vehicleinspection-testid-range.start`
+*   `memex.test.data.vehicleinspection-testid-range.end`
+
+**Important:**
+*   When writing or modifying tests, ensure all `testid` values used for creating, querying, or deleting test data are within this configured range.
+*   Tests **must not** attempt to read, modify, or delete data outside of this dedicated test ID range. This is crucial for preventing tests from interfering with each other or with any non-test data.
+*   Using a `testid` outside of this range during test data manipulation will lead to test failures.
+
+**Caution**: If you configure the tests to run against a real (non-Testcontainer) MongoDB instance, be aware that the tests **will modify data within this `testid` range on that MongoDB instance.** Ensure this range does not overlap with critical data if using a shared or persistent MongoDB server for testing. It is generally recommended to use Testcontainers or a dedicated, ephemeral test database to avoid accidental data modification.
+
+These properties can be adjusted in `src/test/resources/application-test.properties` if necessary for specific testing needs, but ensure they define a sensible range and that all tests strictly adhere to operating only within the specified `testid` boundaries.
+
 ### Code Coverage
 
 We use **JaCoCo** to measure code coverage by our tests.

memex/src/test/java/com/johnlpage/demo/DemoApplicationTests.java

@@ -1,6 +1,6 @@
 package com.johnlpage.memex.cucumber;
 
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.jetbrains.annotations.NotNull;
 import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Condition;
@@ -10,13 +10,6 @@
 import org.springframework.test.context.DynamicPropertyRegistrar;
 import org.testcontainers.mongodb.MongoDBAtlasLocalContainer;
 
-class MongoUriMissingCondition implements Condition {
-    @Override
-    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
-        String uri = context.getEnvironment().getProperty("spring.data.mongodb.uri");
-        return uri == null || uri.trim().isEmpty();
-    }
-}
 
 @TestConfiguration
 public class CucumberTestsContainersConfig {
@@ -36,4 +29,12 @@ public DynamicPropertyRegistrar mongoDbProperties(MongoDBAtlasLocalContainer mon
             registry.add("spring.data.mongodb.database", () -> "memex");
         };
     }
+
+    static class MongoUriMissingCondition implements Condition {
+        @Override
+        public boolean matches(ConditionContext context, @NotNull AnnotatedTypeMetadata metadata) {
+            String uri = context.getEnvironment().getProperty("spring.data.mongodb.uri");
+            return uri == null || uri.trim().isEmpty();
+        }
+    }
 }

memex/src/test/java/com/johnlpage/memex/cucumber/CucumberTestsContainersConfig.java

@@ -0,0 +1,24 @@
+package com.johnlpage.memex.cucumber.service;
+
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+@Component
+public class MacrosRegister {
+
+    private final Map<String, String> macros = new java.util.HashMap<>();
+
+    public void registerMacro(String macroName, String macroValue) {
+        macros.put(macroName, macroValue);
+    }
+
+    public String replaceMacros(String originalString) {
+        String processedString = originalString;
+        for (Map.Entry<String, String> entry : macros.entrySet()) {
+            processedString = processedString.replace(entry.getKey(), entry.getValue());
+        }
+
+        return processedString;
+    }
+}

memex/src/test/java/com/johnlpage/memex/cucumber/service/MacrosRegister.java

@@ -1,4 +1,4 @@
-package com.johnlpage.memex.cucumber.steps;
+package com.johnlpage.memex.cucumber.service;
 
 import lombok.Getter;
 import org.springframework.beans.factory.annotation.Value;
@@ -11,7 +11,7 @@ public class VehicleInspectionIdRangeValidator {
     @Value("${memex.test.data.vehicleinspection-testid-range.start:10000}")
     private long rangeStart;
 
-    @Value("${memex.test.data.vehicleinspection-testid-range.end:20000}")
+    @Value("${memex.test.data.vehicleinspection-testid-range.end:11000}")
     private long rangeEnd;
 
     public void validate(long id) {

…s/VehicleInspectionIdRangeValidator.java …e/VehicleInspectionIdRangeValidator.javamemex/src/test/java/com/johnlpage/memex/cucumber/steps/VehicleInspectionIdRangeValidator.java renamed to memex/src/test/java/com/johnlpage/memex/cucumber/service/VehicleInspectionIdRangeValidator.java memex/src/test/java/com/johnlpage/memex/cucumber/steps/VehicleInspectionIdRangeValidator.java renamed to memex/src/test/java/com/johnlpage/memex/cucumber/service/VehicleInspectionIdRangeValidator.java

@@ -3,27 +3,23 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.johnlpage.memex.cucumber.service.VehicleInspectionIdRangeValidator;
 import com.johnlpage.memex.model.VehicleInspection;
-import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import org.assertj.core.api.Assertions;
-import org.bson.Document;
-import org.springframework.beans.BeanWrapperImpl;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.kafka.core.KafkaTemplate;
 
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 
-public class VehicleInspectionKafkaConsumerSteps {
+public class KafkaConsumerSteps {
 
     @Autowired
     private KafkaTemplate<String, String> kafkaTemplate;

…VehicleInspectionKafkaConsumerSteps.java …x/cucumber/steps/KafkaConsumerSteps.javamemex/src/test/java/com/johnlpage/memex/cucumber/steps/VehicleInspectionKafkaConsumerSteps.java renamed to memex/src/test/java/com/johnlpage/memex/cucumber/steps/KafkaConsumerSteps.java memex/src/test/java/com/johnlpage/memex/cucumber/steps/VehicleInspectionKafkaConsumerSteps.java renamed to memex/src/test/java/com/johnlpage/memex/cucumber/steps/KafkaConsumerSteps.java

@@ -0,0 +1,112 @@
+package com.johnlpage.memex.cucumber.steps;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.johnlpage.memex.cucumber.service.VehicleInspectionIdRangeValidator;
+import com.johnlpage.memex.model.VehicleInspection;
+import com.mongodb.client.result.DeleteResult;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.Given;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.FindAndModifyOptions;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@Slf4j
+public class MongoPreConditionSteps {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @Autowired
+    private VehicleInspectionIdRangeValidator idRangeValidator;
+
+    @Given("the following vehicle inspections exist:")
+    public void givenVehicleInspectionsExist(DataTable dataTable) throws JsonProcessingException {
+        List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
+
+        for (Map<String, String> row : rows) {
+            String json = row.get("vehicleInspection");
+            VehicleInspection inspection = objectMapper.readValue(json, VehicleInspection.class);
+            Long testId = inspection.getTestid();
+            assertNotNull(testId, "testid is expected to be part of the data input");
+
+            idRangeValidator.validate(testId);
+            Query query = Query.query(Criteria.where("_id").is(testId));
+
+            Document updateDoc = new Document(objectMapper.convertValue(inspection, Map.class));
+            Update update = Update.fromDocument(updateDoc);
+
+            VehicleInspection existingInspection = mongoTemplate.findAndModify(query, update,
+                    FindAndModifyOptions.options().upsert(true).returnNew(true), VehicleInspection.class);
+
+            log.info("Upserted VehicleInspection with id {}: {}", testId, existingInspection);
+        }
+    }
+
+    @Given("the vehicle inspections in range {long}-{long} do not exist")
+    public void theFollowingVehicleInspectionsInRangeDoesNotExist(long startId, long endId) {
+        idRangeValidator.validateRange(startId, endId);
+        Query query = new Query();
+        query.addCriteria(Criteria.where("_id").gte(startId).lte(endId));
+        DeleteResult result = mongoTemplate.remove(query, VehicleInspection.class);
+
+        if(result.getDeletedCount() > 0) {
+            log.info("Removed VehicleInspection within a range {}-{}: {}", startId, endId, result.getDeletedCount());
+        }
+    }
+
+    @Given("the vehicle inspection with id {long} does not exist")
+    public void theFollowingVehicleInspectionDoesNotExist(long testId) {
+        idRangeValidator.validate(testId);
+        Query query = new Query();
+        query.addCriteria(Criteria.where("_id").is(testId));
+        DeleteResult result = mongoTemplate.remove(query, VehicleInspection.class);
+
+        if(result.getDeletedCount() > 0) {
+            log.info("Removed VehicleInspection with id {}: {}", testId, result.getDeletedCount());
+        }
+    }
+
+    @Given("the following vehicle inspections do not exist:")
+    public void givenTheFollowingVehicleInspectionsDoNotExist(DataTable dataTable) {
+        for (Map<String, String> row : dataTable.asMaps()) {
+            if (row.size() != 1) {
+                throw new IllegalArgumentException("Only one column per row is supported in this step.");
+            }
+
+            String key = row.keySet().iterator().next();
+            String value = row.get(key);
+
+            long rangeStart = idRangeValidator.getRangeStart();
+            long rangeEnd = idRangeValidator.getRangeEnd();
+
+            Query query = Query.query(Criteria.where("_id").gte(rangeStart).lte(rangeEnd));
+
+            if (key.equalsIgnoreCase("testid")) {
+                long testid = Long.parseLong(value);
+                idRangeValidator.validate(testid);
+                query = Query.query(Criteria.where("_id").is(testid));
+            } else {
+                query.addCriteria(Criteria.where(key).is(value));
+            }
+            DeleteResult result = mongoTemplate.remove(query, VehicleInspection.class);
+
+            if (result.getDeletedCount() > 0) {
+                log.info("Removed VehicleInspection with {}: {} - Count: {}", key, value, result.getDeletedCount());
+            }
+        }
+    }
+}