matches = new LinkedHashSet<>();
+ NodeList children = parent.getChildNodes();
+ for (int index = 0; index < children.getLength(); index++) {
+ Node child = children.item(index);
+ if (child instanceof Element element && name.equals(element.getTagName())) {
+ matches.add(element);
+ }
+ }
+ return matches;
+ }
+
+ private static String directChildText(Element parent, String name) {
+ Element child = directChild(parent, name);
+ return child == null ? null : child.getTextContent().trim();
+ }
+
+ /** Finds the repository root from root- or module-scoped Maven execution. */
+ private static Path projectRoot() {
+ Path current = Paths.get(System.getProperty("user.dir")).toAbsolutePath();
+ Path lastPomParent = null;
+ while (current != null) {
+ if (Files.exists(current.resolve(".git"))) {
+ return current;
+ }
+ if (Files.exists(current.resolve("pom.xml"))) {
+ lastPomParent = current;
+ }
+ current = current.getParent();
+ }
+ if (lastPomParent != null) {
+ return lastPomParent;
+ }
+ throw new IllegalStateException("Could not find project root");
+ }
+}
diff --git a/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobCoveragePolicyTest.java b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobCoveragePolicyTest.java
index 4a728d75..d520b43e 100644
--- a/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobCoveragePolicyTest.java
+++ b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobCoveragePolicyTest.java
@@ -8,19 +8,22 @@
import java.nio.file.Path;
import java.nio.file.Paths;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
- * Keeps the durable-job production slice bound to an executable 100% coverage policy.
+ * Keeps the durable-job production slice bound to an executable, non-vacuous 100% coverage policy.
*
* The policy is intentionally scoped to the production classes introduced by the durable-job
- * intake slice. It requires current Java-compatible JaCoCo instrumentation and zero missed
- * instructions, lines, methods, or branches while the ordinary {@code mvn test} lifecycle runs.
+ * intake slice. It requires current Java-compatible JaCoCo instrumentation, a non-empty selected
+ * production bundle, and zero missed instructions, lines, methods, or branches while the ordinary
+ * {@code mvn test} lifecycle runs.
*/
class EtlJobCoveragePolicyTest {
/**
- * Requires the ETL module build to fail when any durable-job production path is untested.
+ * Requires the ETL module build to fail when the selected durable-job bundle is empty or any
+ * selected durable-job production path is untested.
*
* @throws IOException when the module build descriptor cannot be read
*/
@@ -36,10 +39,18 @@ void etlModuleEnforcesCompleteInstructionAndBranchCoverageForTheDurableJobSlice(
assertTrue(modulePom.contains("test"));
assertTrue(modulePom.contains("report"));
assertTrue(modulePom.contains("check"));
- assertTrue(modulePom.contains("com.xtrmetl.etl.job.*"));
+ assertTrue(modulePom.contains("com/xtrmetl/etl/job/*.class"));
assertTrue(modulePom.contains(
+ "com/xtrmetl/etl/controller/EtlJobController*.class"
+ ));
+ assertFalse(modulePom.contains("com.xtrmetl.etl.job.*"));
+ assertFalse(modulePom.contains(
"com.xtrmetl.etl.controller.EtlJobController*"
));
+ assertTrue(modulePom.contains("BUNDLE"));
+ assertTrue(modulePom.contains("CLASS"));
+ assertTrue(modulePom.contains("TOTALCOUNT"));
+ assertTrue(modulePom.contains("1"));
assertTrue(modulePom.contains("INSTRUCTION"));
assertTrue(modulePom.contains("LINE"));
assertTrue(modulePom.contains("METHOD"));
diff --git a/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceBoundaryTest.java b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceBoundaryTest.java
index 6ce140d6..2d254b0b 100644
--- a/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceBoundaryTest.java
+++ b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceBoundaryTest.java
@@ -10,10 +10,18 @@
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.support.TransactionSynchronizationManager;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.security.Security;
+import java.util.HashMap;
+import java.util.Map;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -69,6 +77,44 @@ void returnsImmediateConflictWhenAnotherSubmissionOwnsTheTryLock() {
verifyNoInteractions(jdbcTemplate);
}
+ @Test
+ void reportsPlatformFailureWhenRequiredSha256DigestIsUnavailable() {
+ JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
+ EtlRequestLock requestLock = mock(EtlRequestLock.class);
+ EtlJobService service = service(jdbcTemplate, requestLock, new EtlBatchProperties());
+ Provider[] originalProviders = Security.getProviders();
+ Provider[] sha256Providers = Security.getProviders("MessageDigest.SHA-256");
+ assertNotNull(sha256Providers);
+ assertTrue(sha256Providers.length > 0);
+
+ Map originalPositions = new HashMap<>();
+ for (int index = 0; index < originalProviders.length; index++) {
+ originalPositions.put(originalProviders[index].getName(), index + 1);
+ }
+
+ try {
+ for (Provider provider : sha256Providers) {
+ Security.removeProvider(provider.getName());
+ }
+ assertThrows(NoSuchAlgorithmException.class, () -> MessageDigest.getInstance("SHA-256"));
+
+ IllegalStateException exception = assertThrows(
+ IllegalStateException.class,
+ () -> service.findOwned(UUID.randomUUID(), "tenant_alpha")
+ );
+
+ assertEquals("SHA-256 is required by the Java platform", exception.getMessage());
+ assertEquals(NoSuchAlgorithmException.class, exception.getCause().getClass());
+ } finally {
+ for (Provider provider : originalProviders) {
+ if (Security.getProvider(provider.getName()) == null) {
+ Security.insertProviderAt(provider, originalPositions.get(provider.getName()));
+ }
+ }
+ }
+ verifyNoInteractions(requestLock, jdbcTemplate);
+ }
+
@Test
void rejectsInvalidKeysAndPrincipalScopesBeforeTransactionOrDatabaseAccess() {
JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
@@ -110,6 +156,10 @@ void rejectsEveryCoveredPayloadAdmissionFailureBeforePersistence() {
EtlRequestError.INVALID_JSON,
() -> service.submit(null, IDEMPOTENCY_KEY, "tenant_alpha")
);
+ assertError(
+ EtlRequestError.INVALID_JSON,
+ () -> service.submit(" ", IDEMPOTENCY_KEY, "tenant_alpha")
+ );
assertError(
EtlRequestError.INVALID_JSON,
() -> service.submit("null", IDEMPOTENCY_KEY, "tenant_alpha")
@@ -154,10 +204,50 @@ void rejectsEveryCoveredPayloadAdmissionFailureBeforePersistence() {
EtlRequestError.INVALID_RECORD,
() -> service.submit("[{\"id\":\" record_alpha\"}]", IDEMPOTENCY_KEY, "tenant_alpha")
);
+ assertError(
+ EtlRequestError.INVALID_RECORD,
+ () -> service.submit(
+ payloadWithIdentifier("\u00a0record_alpha"),
+ IDEMPOTENCY_KEY,
+ "tenant_alpha"
+ )
+ );
+ assertError(
+ EtlRequestError.INVALID_RECORD,
+ () -> service.submit(
+ payloadWithIdentifier("x".repeat(257)),
+ IDEMPOTENCY_KEY,
+ "tenant_alpha"
+ )
+ );
assertError(
EtlRequestError.INVALID_RECORD,
() -> service.submit("[{\"id\":\"record\\u0000alpha\"}]", IDEMPOTENCY_KEY, "tenant_alpha")
);
+ assertError(
+ EtlRequestError.INVALID_RECORD,
+ () -> service.submit(
+ payloadWithIdentifier("record" + Character.toString(0x200e) + "alpha"),
+ IDEMPOTENCY_KEY,
+ "tenant_alpha"
+ )
+ );
+ assertError(
+ EtlRequestError.INVALID_RECORD,
+ () -> service.submit(
+ payloadWithIdentifier("record" + Character.toString(0x2028) + "alpha"),
+ IDEMPOTENCY_KEY,
+ "tenant_alpha"
+ )
+ );
+ assertError(
+ EtlRequestError.INVALID_RECORD,
+ () -> service.submit(
+ payloadWithIdentifier("record" + Character.toString(0x2029) + "alpha"),
+ IDEMPOTENCY_KEY,
+ "tenant_alpha"
+ )
+ );
assertError(
EtlRequestError.INVALID_RECORD,
() -> service.submit(
@@ -203,6 +293,10 @@ void validatesConstructorAndLookupRequiredValues() {
verifyNoInteractions(requestLock, jdbcTemplate);
}
+ private static String payloadWithIdentifier(String identifier) {
+ return "[{\"id\":\"" + identifier + "\"}]";
+ }
+
private static EtlJobService service(
JdbcTemplate jdbcTemplate,
EtlRequestLock requestLock,
diff --git a/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceDefensiveBranchTest.java b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceDefensiveBranchTest.java
new file mode 100644
index 00000000..556eb460
--- /dev/null
+++ b/etl-service/src/test/java/com/xtrmetl/etl/job/EtlJobServiceDefensiveBranchTest.java
@@ -0,0 +1,85 @@
+package com.xtrmetl.etl.job;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.xtrmetl.etl.service.EtlBatchProperties;
+import com.xtrmetl.etl.service.EtlRequestError;
+import com.xtrmetl.etl.service.EtlRequestException;
+import com.xtrmetl.etl.service.EtlRequestLock;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+/**
+ * Exercises defensive JSON-tree outcomes that ordinary Jackson parsing cannot reliably manufacture.
+ *
+ * The service accepts an application-provided {@link ObjectMapper}, copies it, and therefore owns
+ * the boundary between parser output and durable admission. These tests keep that boundary fail-closed
+ * when a compatible mapper reports end-of-input without a tree or exposes a Java {@code null} array
+ * element instead of Jackson's usual {@code NullNode}. Neither case may reach transaction locks or
+ * persistence.
+ */
+class EtlJobServiceDefensiveBranchTest {
+
+ private static final String IDEMPOTENCY_KEY = "550e8400-e29b-41d4-a716-446655440000";
+ private static final String PRINCIPAL_SCOPE = "tenant_alpha";
+
+ @Test
+ void rejectsParserEndOfInputWhenMapperProducesNoTree() throws Exception {
+ JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
+ EtlRequestLock requestLock = mock(EtlRequestLock.class);
+ ObjectMapper sourceMapper = mock(ObjectMapper.class);
+ ObjectMapper copiedMapper = mock(ObjectMapper.class);
+ when(sourceMapper.copy()).thenReturn(copiedMapper);
+ when(copiedMapper.readTree("parser-end-of-input")).thenReturn(null);
+ EtlJobService service = new EtlJobService(
+ jdbcTemplate,
+ sourceMapper,
+ new EtlBatchProperties(),
+ requestLock
+ );
+
+ EtlRequestException exception = assertThrows(
+ EtlRequestException.class,
+ () -> service.submit("parser-end-of-input", IDEMPOTENCY_KEY, PRINCIPAL_SCOPE)
+ );
+
+ assertEquals(EtlRequestError.INVALID_JSON, exception.error());
+ verifyNoInteractions(requestLock, jdbcTemplate);
+ }
+
+ @Test
+ void rejectsNullParserArrayElementBeforeTransactionOrPersistence() throws Exception {
+ JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
+ EtlRequestLock requestLock = mock(EtlRequestLock.class);
+ ObjectMapper sourceMapper = mock(ObjectMapper.class);
+ ObjectMapper copiedMapper = mock(ObjectMapper.class);
+ JsonNode root = mock(JsonNode.class);
+ when(sourceMapper.copy()).thenReturn(copiedMapper);
+ when(copiedMapper.readTree("parser-null-array-element")).thenReturn(root);
+ when(root.isArray()).thenReturn(true);
+ when(root.size()).thenReturn(1);
+ when(root.iterator()).thenReturn(Collections.singletonList((JsonNode) null).iterator());
+ EtlJobService service = new EtlJobService(
+ jdbcTemplate,
+ sourceMapper,
+ new EtlBatchProperties(),
+ requestLock
+ );
+
+ EtlRequestException exception = assertThrows(
+ EtlRequestException.class,
+ () -> service.submit("parser-null-array-element", IDEMPOTENCY_KEY, PRINCIPAL_SCOPE)
+ );
+
+ assertEquals(EtlRequestError.INVALID_RECORD, exception.error());
+ verifyNoInteractions(requestLock, jdbcTemplate);
+ }
+}