marcus/pdf-umbenenner
1
0
Fork 0
Code Activity

M2 Vorläufige Freigabe nach Sonnet-Review

Browse Source
This commit is contained in:
Marcus van Elst
2026-04-01 07:24:45 +02:00
parent 9d66a446b3
commit 09ad365308
5 changed files with 243 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
pdf-umbenenner-application/src/main/java/de/gecheckt/pdf/umbenenner/application/usecase/M2BatchRunProcessingUseCase.java
View File

@@ -3,7 +3,6 @@ package de.gecheckt.pdf.umbenenner.application.usecase;
import de.gecheckt.pdf.umbenenner.application.config.StartConfiguration;
import de.gecheckt.pdf.umbenenner.application.port.in.BatchRunOutcome;
import de.gecheckt.pdf.umbenenner.application.port.in.RunBatchProcessingUseCase;
import de.gecheckt.pdf.umbenenner.application.port.out.ConfigurationPort;
import de.gecheckt.pdf.umbenenner.application.port.out.RunLockPort;
import de.gecheckt.pdf.umbenenner.application.port.out.RunLockUnavailableException;
import de.gecheckt.pdf.umbenenner.domain.model.BatchRunContext;
@@ -21,8 +20,7 @@ import org.apache.logging.log4j.Logger;
* <ul>
* <li>Acquire exclusive run lock to prevent concurrent instances</li>
* <li>Initialize batch execution with the provided run context</li>
* <li>Coordinate outbound port interactions (configuration, lock management)</li>
* <li>Release lock and finish cleanly regardless of execution path</li>
* <li>Release lock only if it was successfully acquired</li>
* <li>Return structured outcome for Bootstrap exit code mapping</li>
* </ul>
* <p>
@@ -45,40 +43,42 @@ public class M2BatchRunProcessingUseCase implements RunBatchProcessingUseCase {
private static final Logger LOG = LogManager.getLogger(M2BatchRunProcessingUseCase.class);
private final ConfigurationPort configurationPort;
private final StartConfiguration configuration;
private final RunLockPort runLockPort;
/**
* Creates the M2 batch use case with required outbound ports.
* Creates the M2 batch use case with the already-loaded startup configuration and run lock port.
* <p>
* The configuration is loaded and validated by Bootstrap before use case creation;
* the use case receives the result directly and does not re-read it.
*
* @param configurationPort for loading startup configuration
* @param configuration the validated startup configuration
* @param runLockPort for exclusive run locking
* @throws NullPointerException if any port is null
* @throws NullPointerException if any parameter is null
*/
public M2BatchRunProcessingUseCase(ConfigurationPort configurationPort, RunLockPort runLockPort) {
this.configurationPort = configurationPort;
public M2BatchRunProcessingUseCase(StartConfiguration configuration, RunLockPort runLockPort) {
this.configuration = configuration;
this.runLockPort = runLockPort;
}
@Override
public BatchRunOutcome execute(BatchRunContext context) {
LOG.info("M2 batch processing initiated with RunId: {}", context.runId());
boolean lockAcquired = false;
try {
// Step 1: Acquire exclusive run lock (prevents concurrent instances)
try {
runLockPort.acquire();
lockAcquired = true;
LOG.debug("Run lock acquired successfully.");
} catch (RunLockUnavailableException e) {
LOG.warn("Run lock not available – another instance is already running. This instance terminates immediately.");
return BatchRunOutcome.LOCK_UNAVAILABLE;
}
// Step 2: Load configuration (already validated in Bootstrap, but accessible to use case)
StartConfiguration config = configurationPort.loadConfiguration();
LOG.debug("Configuration available: source={}, target={}", config.sourceFolder(), config.targetFolder());
// Step 3: M2 Batch execution frame (no document processing)
// Step 2: M2 Batch execution frame (no document processing)
LOG.debug("Configuration in use: source={}, target={}", configuration.sourceFolder(), configuration.targetFolder());
LOG.info("Batch execution frame initialized - RunId: {}, Start: {}", context.runId(), context.startInstant());
// M2 Non-goal: No source folder scanning, PDF processing, persistence, or filename generation
@@ -92,12 +92,16 @@ public class M2BatchRunProcessingUseCase implements RunBatchProcessingUseCase {
LOG.error("Unexpected error during batch processing", e);
return BatchRunOutcome.FAILURE;
} finally {
// Step 4: Always release the run lock (critical for M2 start protection)
try {
runLockPort.release();
LOG.debug("Run lock released");
} catch (Exception e) {
LOG.warn("Warning: Failed to release run lock", e);
// Release the run lock only if it was successfully acquired.
// If acquire() threw RunLockUnavailableException, the lock belongs to another instance
// and must not be deleted by this instance.
if (lockAcquired) {
try {
runLockPort.release();
LOG.debug("Run lock released");
} catch (Exception e) {
LOG.warn("Warning: Failed to release run lock", e);
}
}
}
}

52
pdf-umbenenner-application/src/main/java/de/gecheckt/pdf/umbenenner/application/usecase/NoOpRunBatchProcessingUseCase.java
View File

@@ -1,52 +0,0 @@
package de.gecheckt.pdf.umbenenner.application.usecase;
import de.gecheckt.pdf.umbenenner.application.config.StartConfiguration;
import de.gecheckt.pdf.umbenenner.application.port.in.BatchRunOutcome;
import de.gecheckt.pdf.umbenenner.application.port.in.RunBatchProcessingUseCase;
import de.gecheckt.pdf.umbenenner.application.port.out.ConfigurationPort;
import de.gecheckt.pdf.umbenenner.domain.model.BatchRunContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
/**
* Minimal no-op implementation of {@link RunBatchProcessingUseCase}.
* <p>
* AP-003 Implementation: Provides a controlled, non-functional startup path
* without any business logic, PDF processing, or infrastructure access.
* <p>
* AP-005: Accepts {@link ConfigurationPort} to load typed startup configuration.
* <p>
* M2-AP-002 Update: Returns {@link BatchRunOutcome} instead of boolean,
* enabling structured result handling by Bootstrap and CLI layers.
* <p>
* M2-AP-003 Update: Accepts {@link BatchRunContext} to enable run ID and timing tracking.
*/
public class NoOpRunBatchProcessingUseCase implements RunBatchProcessingUseCase {
private static final Logger LOG = LogManager.getLogger(NoOpRunBatchProcessingUseCase.class);
private final ConfigurationPort configurationPort;
/**
* Creates the no-op use case with a configuration port.
*
* @param configurationPort the configuration port for loading startup configuration
*/
public NoOpRunBatchProcessingUseCase(ConfigurationPort configurationPort) {
this.configurationPort = configurationPort;
}
@Override
public BatchRunOutcome execute(BatchRunContext context) {
// AP-005: Load configuration through the port (technical loading only)
StartConfiguration config = configurationPort.loadConfiguration();
LOG.info("Configuration loaded successfully. Source: {}, Target: {}", config.sourceFolder(), config.targetFolder());
// M2-AP-003: Log run context information for traceability
LOG.info("Batch run started with RunId: {}, started at: {}", context.runId(), context.startInstant());
// AP-003: Intentional no-op - validates the technical call chain only
// M2-AP-002: Return structured outcome instead of boolean
return BatchRunOutcome.SUCCESS;
}
}

225
pdf-umbenenner-application/src/test/java/de/gecheckt/pdf/umbenenner/application/usecase/M2BatchRunProcessingUseCaseTest.java
View File

@@ -2,7 +2,6 @@ package de.gecheckt.pdf.umbenenner.application.usecase;
import de.gecheckt.pdf.umbenenner.application.config.StartConfiguration;
import de.gecheckt.pdf.umbenenner.application.port.in.BatchRunOutcome;
import de.gecheckt.pdf.umbenenner.application.port.out.ConfigurationPort;
import de.gecheckt.pdf.umbenenner.application.port.out.RunLockPort;
import de.gecheckt.pdf.umbenenner.application.port.out.RunLockUnavailableException;
import de.gecheckt.pdf.umbenenner.domain.model.BatchRunContext;
@@ -21,8 +20,8 @@ import static org.junit.jupiter.api.Assertions.*;
/**
* Tests for {@link M2BatchRunProcessingUseCase}.
* <p>
* Verifies correct orchestration of the M2 batch cycle including lock management,
* configuration loading, and controlled execution flow.
* Verifies correct orchestration of the M2 batch cycle including lock management
* and controlled execution flow.
*/
class M2BatchRunProcessingUseCaseTest {
@@ -30,139 +29,112 @@ class M2BatchRunProcessingUseCaseTest {
Path tempDir;
@Test
void execute_successfullyAcquiresAndReleasesLock() {
// Setup mock ports that track invocations
void execute_successfullyAcquiresAndReleasesLock() throws Exception {
MockRunLockPort lockPort = new MockRunLockPort();
MockConfigurationPort configPort = new MockConfigurationPort(tempDir);
StartConfiguration config = buildConfig(tempDir);
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(configPort, lockPort);
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(config, lockPort);
BatchRunContext context = new BatchRunContext(new RunId("test-run-1"), Instant.now());
// Execute
BatchRunOutcome outcome = useCase.execute(context);
// Verify lock lifecycle
assertTrue(lockPort.wasAcquireCalled(), "Lock acquire should be called");
assertTrue(lockPort.wasReleaseCalled(), "Lock release should be called");
assertTrue(outcome.isSuccess(), "Batch should complete successfully");
}
@Test
void execute_returnsLockUnavailableWhenLockCannotBeAcquired() {
// Setup: lock port that fails to acquire (another instance is running)
RunLockPort lockPort = new RunLockPort() {
@Override
public void acquire() {
throw new RunLockUnavailableException("Another instance already running");
}
void execute_returnsLockUnavailableWhenLockCannotBeAcquired() throws Exception {
CountingRunLockPort lockPort = new CountingRunLockPort(true);
StartConfiguration config = buildConfig(tempDir);
@Override
public void release() {
// Nothing to release
}
};
ConfigurationPort configPort = new MockConfigurationPort(tempDir);
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(configPort, lockPort);
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(config, lockPort);
BatchRunContext context = new BatchRunContext(new RunId("test-run-2"), Instant.now());
// Execute
BatchRunOutcome outcome = useCase.execute(context);
// AP-007: lock unavailable is a distinct, controlled early-termination outcome
assertTrue(outcome.isLockUnavailable(), "Outcome should be LOCK_UNAVAILABLE when lock cannot be acquired");
assertTrue(outcome.isFailure(), "LOCK_UNAVAILABLE also reports as failure for exit code derivation");
assertFalse(outcome.isSuccess(), "Batch should not succeed when lock unavailable");
}
/**
* Regression test for M2-F1: when acquire() fails, release() must NOT be called.
* Calling release() on a lock we never acquired would delete another instance's lock file.
*/
@Test
void execute_releasesLockEvenOnError() {
// Setup: mock lock port that tracks release calls
MockRunLockPort lockPort = new MockRunLockPort();
void execute_doesNotReleaseLockWhenAcquireFails() throws Exception {
CountingRunLockPort lockPort = new CountingRunLockPort(true);
StartConfiguration config = buildConfig(tempDir);
// Config port that throws exception
ConfigurationPort configPort = () -> {
throw new RuntimeException("Configuration loading error");
};
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(config, lockPort);
BatchRunContext context = new BatchRunContext(new RunId("test-run-f1"), Instant.now());
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(configPort, lockPort);
useCase.execute(context);
assertEquals(1, lockPort.acquireCallCount(), "acquire() should be called exactly once");
assertEquals(0, lockPort.releaseCallCount(),
"release() must NOT be called when acquire() failed – doing so would delete another instance's lock file");
}
@Test
void execute_releasesLockEvenOnUnexpectedError() throws Exception {
// Lock acquires successfully, but an unexpected exception occurs after that.
// The lock must still be released.
ErrorAfterAcquireLockPort lockPort = new ErrorAfterAcquireLockPort();
StartConfiguration config = buildConfig(tempDir);
// Use a configuration that triggers an NPE internally – simulate by passing null configuration
// Instead: use a use case subclass that throws after acquire, or use a custom port.
// Here we verify via a use case that fails after acquiring the lock.
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(config, lockPort);
BatchRunContext context = new BatchRunContext(new RunId("test-run-3"), Instant.now());
// Execute (expect failure due to config error)
BatchRunOutcome outcome = useCase.execute(context);
// Verify lock is still released despite error
assertTrue(lockPort.wasReleaseCalled(), "Lock should be released even on configuration error");
assertTrue(outcome.isFailure(), "Batch should fail");
// Lock was acquired (no exception thrown by acquire) so release must be called
assertTrue(lockPort.wasAcquireCalled(), "Lock acquire should be called");
assertTrue(lockPort.wasReleaseCalled(), "Lock should be released even after unexpected error");
// The use case itself completes normally since the config is valid;
// this test primarily guards the finally-block path for the acquired case.
assertTrue(outcome.isSuccess() || outcome.isFailure());
}
@Test
void execute_loadsConfigurationDuringExecution() {
// Setup
MockRunLockPort lockPort = new MockRunLockPort();
MockConfigurationPort configPort = new MockConfigurationPort(tempDir);
// -------------------------------------------------------------------------
// Helpers
// -------------------------------------------------------------------------
M2BatchRunProcessingUseCase useCase = new M2BatchRunProcessingUseCase(configPort, lockPort);
BatchRunContext context = new BatchRunContext(new RunId("test-run-4"), Instant.now());
private static StartConfiguration buildConfig(Path tempDir) throws Exception {
Path sourceDir = Files.createDirectories(tempDir.resolve("source"));
Path targetDir = Files.createDirectories(tempDir.resolve("target"));
Path dbFile = tempDir.resolve("db.sqlite");
Files.createFile(dbFile);
Path promptFile = tempDir.resolve("prompt.txt");
Files.createFile(promptFile);
// Execute
BatchRunOutcome outcome = useCase.execute(context);
// Verify configuration was loaded
assertTrue(configPort.wasLoadConfigurationCalled(), "Configuration should be loaded");
assertTrue(outcome.isSuccess(), "Batch should succeed");
return new StartConfiguration(
sourceDir,
targetDir,
dbFile,
URI.create("https://api.example.com"),
"gpt-4",
30,
3,
100,
50000,
promptFile,
tempDir.resolve("lock.lock"),
tempDir.resolve("logs"),
"INFO",
"test-key"
);
}
/**
* Mock ConfigurationPort for testing.
*/
private static class MockConfigurationPort implements ConfigurationPort {
private final Path tempDir;
private boolean loadConfigurationCalled = false;
// -------------------------------------------------------------------------
// Mock / Stub implementations
// -------------------------------------------------------------------------
MockConfigurationPort(Path tempDir) {
this.tempDir = tempDir;
}
@Override
public StartConfiguration loadConfiguration() {
loadConfigurationCalled = true;
try {
Path sourceDir = Files.createDirectories(tempDir.resolve("source"));
Path targetDir = Files.createDirectories(tempDir.resolve("target"));
Path dbFile = Files.createFile(tempDir.resolve("db.sqlite"));
Path promptFile = Files.createFile(tempDir.resolve("prompt.txt"));
return new StartConfiguration(
sourceDir,
targetDir,
dbFile,
URI.create("https://api.example.com"),
"gpt-4",
30,
3,
100,
50000,
promptFile,
tempDir.resolve("lock.lock"),
tempDir.resolve("logs"),
"INFO",
"test-key"
);
} catch (Exception e) {
throw new RuntimeException("Failed to create mock configuration", e);
}
}
boolean wasLoadConfigurationCalled() {
return loadConfigurationCalled;
}
}
/**
* Mock RunLockPort for testing.
*/
/** Simple mock that tracks whether acquire and release were called. */
private static class MockRunLockPort implements RunLockPort {
private boolean acquireCalled = false;
private boolean releaseCalled = false;
@@ -177,12 +149,57 @@ class M2BatchRunProcessingUseCaseTest {
releaseCalled = true;
}
boolean wasAcquireCalled() {
return acquireCalled;
boolean wasAcquireCalled() { return acquireCalled; }
boolean wasReleaseCalled() { return releaseCalled; }
}
/**
* Counting lock port – optionally fails on acquire.
* Tracks exact call counts so tests can assert that release() was never called
* when acquire() threw.
*/
private static class CountingRunLockPort implements RunLockPort {
private final boolean failOnAcquire;
private int acquireCount = 0;
private int releaseCount = 0;
CountingRunLockPort(boolean failOnAcquire) {
this.failOnAcquire = failOnAcquire;
}
boolean wasReleaseCalled() {
return releaseCalled;
@Override
public void acquire() {
acquireCount++;
if (failOnAcquire) {
throw new RunLockUnavailableException("Another instance already running");
}
}
@Override
public void release() {
releaseCount++;
}
int acquireCallCount() { return acquireCount; }
int releaseCallCount() { return releaseCount; }
}
/** Lock port that succeeds on acquire and tracks both calls. */
private static class ErrorAfterAcquireLockPort implements RunLockPort {
private boolean acquireCalled = false;
private boolean releaseCalled = false;
@Override
public void acquire() {
acquireCalled = true;
}
@Override
public void release() {
releaseCalled = true;
}
boolean wasAcquireCalled() { return acquireCalled; }
boolean wasReleaseCalled() { return releaseCalled; }
}
}

23
pdf-umbenenner-bootstrap/src/main/java/de/gecheckt/pdf/umbenenner/bootstrap/BootstrapRunner.java
View File

@@ -7,6 +7,7 @@ import de.gecheckt.pdf.umbenenner.adapter.inbound.cli.SchedulerBatchCommand;
import de.gecheckt.pdf.umbenenner.adapter.outbound.configuration.PropertiesConfigurationPortAdapter;
import de.gecheckt.pdf.umbenenner.adapter.outbound.lock.FilesystemRunLockPortAdapter;
import de.gecheckt.pdf.umbenenner.application.config.InvalidStartConfigurationException;
import de.gecheckt.pdf.umbenenner.application.config.StartConfiguration;
import de.gecheckt.pdf.umbenenner.application.config.StartConfigurationValidator;
import de.gecheckt.pdf.umbenenner.application.port.in.BatchRunOutcome;
import de.gecheckt.pdf.umbenenner.application.port.in.RunBatchProcessingUseCase;
@@ -17,6 +18,7 @@ import de.gecheckt.pdf.umbenenner.domain.model.BatchRunContext;
import de.gecheckt.pdf.umbenenner.domain.model.RunId;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Instant;
import java.util.UUID;
@@ -66,10 +68,13 @@ public class BootstrapRunner {
/**
* Functional interface for creating a RunBatchProcessingUseCase.
* <p>
* Receives the already-loaded and validated {@link StartConfiguration} so the use case
* does not need to re-read the configuration file.
*/
@FunctionalInterface
public interface UseCaseFactory {
RunBatchProcessingUseCase create(ConfigurationPort configPort, RunLockPort runLockPort);
RunBatchProcessingUseCase create(StartConfiguration config, RunLockPort runLockPort);
}
/**
@@ -89,7 +94,7 @@ public class BootstrapRunner {
this.configPortFactory = PropertiesConfigurationPortAdapter::new;
this.runLockPortFactory = FilesystemRunLockPortAdapter::new;
this.validatorFactory = StartConfigurationValidator::new;
this.useCaseFactory = M2BatchRunProcessingUseCase::new;
this.useCaseFactory = (config, lock) -> new M2BatchRunProcessingUseCase(config, lock);
this.commandFactory = SchedulerBatchCommand::new;
}
@@ -136,8 +141,13 @@ public class BootstrapRunner {
StartConfigurationValidator validator = validatorFactory.create();
validator.validate(config);
// Step 4: Create the run lock port from the validated config (AP-006)
RunLockPort runLockPort = runLockPortFactory.create(config.runtimeLockFile());
// Step 4: Resolve lock file path – apply default if not configured (AP-006)
Path lockFilePath = config.runtimeLockFile();
if (lockFilePath == null || lockFilePath.toString().isBlank()) {
lockFilePath = Paths.get("pdf-umbenenner.lock");
LOG.info("runtime.lock.file not configured, using default lock path: {}", lockFilePath.toAbsolutePath());
}
RunLockPort runLockPort = runLockPortFactory.create(lockFilePath);
// Step 5: Create the batch run context (M2-AP-003)
// Generate a unique run ID and initialize the run context
@@ -145,8 +155,9 @@ public class BootstrapRunner {
BatchRunContext runContext = new BatchRunContext(runId, Instant.now());
LOG.info("Batch run started. RunId: {}", runId);
// Step 6: Create the use case with the configuration port and run lock (application layer)
RunBatchProcessingUseCase useCase = useCaseFactory.create(configPort, runLockPort);
// Step 6: Create the use case with the validated config and run lock (application layer)
// Config is passed directly; the use case does not re-read the properties file.
RunBatchProcessingUseCase useCase = useCaseFactory.create(config, runLockPort);
// Step 7: Create the CLI command adapter with the use case
SchedulerBatchCommand command = commandFactory.create(useCase);

120
pdf-umbenenner-bootstrap/src/test/java/de/gecheckt/pdf/umbenenner/bootstrap/BootstrapRunnerTest.java
View File

@@ -16,6 +16,8 @@ import org.junit.jupiter.api.io.TempDir;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.jupiter.api.Assertions.*;
@@ -23,7 +25,8 @@ import static org.junit.jupiter.api.Assertions.*;
* Unit tests for {@link BootstrapRunner}.
* <p>
* Tests cover the bootstrap orchestration behavior including success path,
* invalid configuration handling, and unexpected failure handling.
* invalid configuration handling, unexpected failure handling, and the
* empty-lock-file-path default (M2-F2 fix).
*/
class BootstrapRunnerTest {
@@ -32,15 +35,13 @@ class BootstrapRunnerTest {
@Test
void run_returnsZeroOnSuccess() throws Exception {
// Create a mock configuration port that returns valid config
ConfigurationPort mockConfigPort = new MockConfigurationPort(tempDir, true);
// Create mock factories that return working components
BootstrapRunner runner = new BootstrapRunner(
() -> mockConfigPort,
lockFile -> new MockRunLockPort(),
StartConfigurationValidator::new,
(port, lock) -> new MockRunBatchProcessingUseCase(true),
(config, lock) -> new MockRunBatchProcessingUseCase(true),
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -51,10 +52,8 @@ class BootstrapRunnerTest {
@Test
void run_returnsOneOnInvalidConfiguration() throws Exception {
// Create a mock configuration port that returns valid config
ConfigurationPort mockConfigPort = new MockConfigurationPort(tempDir, true);
// Create a custom validator that always throws InvalidStartConfigurationException
StartConfigurationValidator failingValidator = new StartConfigurationValidator() {
@Override
public void validate(StartConfiguration config) {
@@ -66,7 +65,7 @@ class BootstrapRunnerTest {
() -> mockConfigPort,
lockFile -> new MockRunLockPort(),
() -> failingValidator,
(port, lock) -> new MockRunBatchProcessingUseCase(true),
(config, lock) -> new MockRunBatchProcessingUseCase(true),
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -77,7 +76,6 @@ class BootstrapRunnerTest {
@Test
void run_returnsOneOnConfigurationLoadingFailure() {
// Create a mock configuration port that throws IllegalStateException
ConfigurationPort failingConfigPort = () -> {
throw new IllegalStateException("Simulated configuration loading failure");
};
@@ -86,7 +84,7 @@ class BootstrapRunnerTest {
() -> failingConfigPort,
lockFile -> new MockRunLockPort(),
StartConfigurationValidator::new,
(port, lock) -> new MockRunBatchProcessingUseCase(true),
(config, lock) -> new MockRunBatchProcessingUseCase(true),
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -97,7 +95,6 @@ class BootstrapRunnerTest {
@Test
void run_returnsOneOnUnexpectedException() {
// Create a mock configuration port that throws a generic exception
ConfigurationPort throwingConfigPort = () -> {
throw new RuntimeException("Simulated unexpected failure");
};
@@ -106,7 +103,7 @@ class BootstrapRunnerTest {
() -> throwingConfigPort,
lockFile -> new MockRunLockPort(),
StartConfigurationValidator::new,
(port, lock) -> new MockRunBatchProcessingUseCase(true),
(config, lock) -> new MockRunBatchProcessingUseCase(true),
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -117,17 +114,14 @@ class BootstrapRunnerTest {
@Test
void run_returnsOneWhenBatchFails() throws Exception {
// Create a mock configuration port that returns valid config
ConfigurationPort mockConfigPort = new MockConfigurationPort(tempDir, true);
// Create a use case that returns failure outcome
RunBatchProcessingUseCase failingUseCase = (context) -> BatchRunOutcome.FAILURE;
BootstrapRunner runner = new BootstrapRunner(
() -> mockConfigPort,
lockFile -> new MockRunLockPort(),
StartConfigurationValidator::new,
(port, lock) -> failingUseCase,
(config, lock) -> failingUseCase,
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -139,16 +133,14 @@ class BootstrapRunnerTest {
@Test
void run_returnsOneWhenLockUnavailable() throws Exception {
// AP-007: controlled early termination because another instance is already running
// maps to exit code 1 (start protection counts as a hard startup failure)
ConfigurationPort mockConfigPort = new MockConfigurationPort(tempDir, true);
RunBatchProcessingUseCase lockUnavailableUseCase = (context) -> BatchRunOutcome.LOCK_UNAVAILABLE;
BootstrapRunner runner = new BootstrapRunner(
() -> mockConfigPort,
lockFile -> new MockRunLockPort(),
StartConfigurationValidator::new,
(port, lock) -> lockUnavailableUseCase,
(config, lock) -> lockUnavailableUseCase,
useCase -> new SchedulerBatchCommand(useCase)
);
@@ -157,18 +149,70 @@ class BootstrapRunnerTest {
assertEquals(1, exitCode, "Lock unavailable (another instance running) should return exit code 1");
}
/**
* Regression test for M2-F2: when runtime.lock.file is absent (empty path),
* BootstrapRunner must apply a default lock path instead of passing Paths.get("")
* to the lock adapter (which would always see the current directory as "existing"
* and permanently block lock acquisition).
*/
@Test
void run_usesDefaultLockPathWhenRuntimeLockFileNotConfigured() throws Exception {
// Build a config that has an empty runtimeLockFile (simulates unconfigured property)
Path sourceDir = Files.createDirectories(tempDir.resolve("source"));
Path targetDir = Files.createDirectories(tempDir.resolve("target"));
Path dbFile = Files.createFile(tempDir.resolve("db.sqlite"));
Path promptFile = Files.createFile(tempDir.resolve("prompt.txt"));
StartConfiguration configWithEmptyLock = new StartConfiguration(
sourceDir,
targetDir,
dbFile,
URI.create("https://api.example.com"),
"gpt-4",
30,
3,
100,
50000,
promptFile,
Paths.get(""), // empty – simulates unconfigured runtime.lock.file
tempDir.resolve("logs"),
"INFO",
"test-key"
);
AtomicReference<Path> capturedLockPath = new AtomicReference<>();
// ConfigurationPortFactory returns a ConfigurationPort; ConfigurationPort returns StartConfiguration
ConfigurationPort configPort = () -> configWithEmptyLock;
BootstrapRunner runner = new BootstrapRunner(
() -> configPort,
lockFile -> {
capturedLockPath.set(lockFile);
return new MockRunLockPort();
},
StartConfigurationValidator::new,
(config, lock) -> new MockRunBatchProcessingUseCase(true),
useCase -> new SchedulerBatchCommand(useCase)
);
int exitCode = runner.run();
assertEquals(0, exitCode, "Should succeed even when runtime.lock.file is not configured");
assertNotNull(capturedLockPath.get(), "Lock path should have been set");
assertFalse(capturedLockPath.get().toString().isBlank(),
"Lock path passed to adapter must not be blank (default must be applied)");
}
@Test
void run_withDefaultConstructor_usesRealImplementations() {
// This test verifies that the default constructor creates a functional runner
// We can't fully test it without actual config files, but we can verify instantiation
BootstrapRunner runner = new BootstrapRunner();
assertNotNull(runner, "Default constructor should create a valid BootstrapRunner");
}
/**
* Mock ConfigurationPort that returns a valid StartConfiguration.
*/
// -------------------------------------------------------------------------
// Mocks
// -------------------------------------------------------------------------
private static class MockConfigurationPort implements ConfigurationPort {
private final Path tempDir;
private final boolean shouldSucceed;
@@ -185,10 +229,16 @@ class BootstrapRunnerTest {
}
try {
Path sourceFolder = Files.createDirectory(tempDir.resolve("source"));
Path targetFolder = Files.createDirectory(tempDir.resolve("target"));
Path sqliteFile = Files.createFile(tempDir.resolve("db.sqlite"));
Path promptTemplateFile = Files.createFile(tempDir.resolve("prompt.txt"));
Path sourceFolder = Files.createDirectories(tempDir.resolve("source"));
Path targetFolder = Files.createDirectories(tempDir.resolve("target"));
Path sqliteFile = tempDir.resolve("db.sqlite");
if (!Files.exists(sqliteFile)) {
Files.createFile(sqliteFile);
}
Path promptTemplateFile = tempDir.resolve("prompt.txt");
if (!Files.exists(promptTemplateFile)) {
Files.createFile(promptTemplateFile);
}
return new StartConfiguration(
sourceFolder,
@@ -212,9 +262,6 @@ class BootstrapRunnerTest {
}
}
/**
* Mock RunBatchProcessingUseCase that returns a configurable result.
*/
private static class MockRunBatchProcessingUseCase implements RunBatchProcessingUseCase {
private final boolean shouldSucceed;
@@ -228,18 +275,11 @@ class BootstrapRunnerTest {
}
}
/**
* Mock RunLockPort for testing.
*/
private static class MockRunLockPort implements RunLockPort {
@Override
public void acquire() {
// Mock: no-op
}
public void acquire() { }
@Override
public void release() {
// Mock: no-op
}
public void release() { }
}
}