Files
prometeu-studio/prometeu-app/src/test/java/p/studio/app/runtime/HeadlessProcessSessionTest.java
T
bquarkz 71fb80efc3
Test / Tests and coverage occurred while executing withChecks step.
Intrepid/Prometeu/Studio/pipeline/head There was a failure building this commit
feat(studio): ship JavaFX 2 Play and delegate integration tooling
Launch the JavaFX 2 project shell on Java 25 with an interactive viewport,
managed Play lifecycle and project mutation guards. Preserve headless/MCP and
save compatibility, and qualify exact runtime executable bundles.
Separate unit JaCoCo gates from opt-in integration suites and use the internal
Pong fixture for the headless visual pilot.
Move maintenance and native conformance tools into tooling; retain the VS Code
extension and update current navigation links.

Validation: tooling make verify passed, including 1064 Studio unit tests,
JaCoCo thresholds and 22 headless integration tests.
2026-11-19 17:32:03 +00:00

196 lines
15 KiB
Java

package p.studio.app.runtime;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.io.TempDir;
import p.studio.api.automation.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.jupiter.api.Assertions.*;
@org.junit.jupiter.api.Tag("integration")
class HeadlessProcessSessionTest {
@TempDir Path root;
final List<HeadlessProcessSession> sessions = new ArrayList<>();
HeadlessProcessSession start(String mode) throws Exception {
var process = new ProcessBuilder(HeadlessFixture.java(), "-cp", System.getProperty("java.class.path"), HeadlessFixture.class.getName(), mode).directory(root.toFile()).start();
var session = new HeadlessProcessSession(process, new ObjectMapper(), HeadlessFixture.limits(mode), "build"); sessions.add(session); return session;
}
@AfterEach void cleanup() { sessions.forEach(session -> session.abort("test cleanup")); }
@Test void structuredTestCapabilityRefusalHappensBeforeInitializeOrBoot()throws Exception {
var session=start("normal");
var failure=assertThrows(AutomationException.class,()->session.initializeAndBoot(root,root,false,Map.of(),root.resolve("unused.pmc"),true));
assertEquals(AutomationFailure.Code.RUNTIME_INCOMPATIBLE,failure.failure().code());
assertFalse(Files.exists(root.resolve("requests.jsonl")),"Capability refusal must not execute the guest");
}
@Test void lifecycleObservationsPreserveFinalFactsAcrossResetBootAndShutdown() throws Exception {
var session = start("normal"); session.initializeAndBoot(root);
assertEquals(RuntimeObservation.Lifecycle.BOOTED, session.observation().lifecycle());
assertEquals(session.bootReply().values().get("state"), session.observation().nativeDetails().get("state"));
var finalFrame = session.advance(3, ignored -> {}).observation();
assertEquals(3L, finalFrame.progress().completedFrames()); assertNotNull(finalFrame.lastFrame());
var reset = session.call(TaskTools.HeadlessAction.RESET, Map.of());
assertEquals(RuntimeObservation.Lifecycle.UNBOOTED, ((RuntimeObservation)reset.values().get("observation")).lifecycle());
assertNull(session.observation().lastFrame()); assertTrue(session.observation().captureStale());
assertEquals(3L, finalFrame.progress().completedFrames()); assertNotNull(finalFrame.lastFrame());
session.call(TaskTools.HeadlessAction.BOOT, Map.of());
assertEquals(RuntimeObservation.Lifecycle.BOOTED, session.observation().lifecycle());
var stopped = session.stop(Map.of()).toCompletableFuture().get(3, TimeUnit.SECONDS);
assertEquals(RuntimeObservation.Lifecycle.TERMINATED, ((RuntimeObservation)stopped.values().get("observation")).lifecycle());
assertFalse(session.alive());
}
@Test void failedFollowupPreservesTheNativeWatchdogAndKnownZeroFrames() throws Exception {
var session = start("watchdog-inspection-fails"); session.initializeAndBoot(root);
var result = session.advance(3, ignored -> {});
assertEquals(AutomationOutcome.Kind.INFRASTRUCTURE_FAILURE, result.kind());
assertEquals(0, result.completedFrames()); assertNull(result.capture());
var observation = result.observation();
assertEquals(0L, observation.progress().completedFrames());
assertEquals("host_tick_watchdog", ((Map<?, ?>)observation.nativeDetails().get("error")).get("code"));
assertEquals(Set.of("capture", "get_state"), observation.unavailable().stream()
.map(RuntimeObservation.UnavailableObservation::source).collect(java.util.stream.Collectors.toSet()));
assertEquals("BUSY", observation.unavailable().stream().filter(value -> value.source().equals("get_state")).findFirst().orElseThrow().code());
assertTrue(session.alive());
assertEquals(1, Files.readAllLines(root.resolve("requests.jsonl")).stream().filter(line -> line.contains("\"command\":\"advance\"")).count());
}
@Test void productionLoadDiagnosticsSurviveBootFailureAndMcpSerialization() throws Exception {
var mapper = new ObjectMapper();
for (String fixture : List.of("resource", "invalid-role", "retired-opcode", "native", "native-abi", "unknown-native")) {
var session = start("load-fault-" + fixture);
var failure = assertThrows(AutomationException.class, () -> session.initializeAndBoot(root)).failure();
var fault = mapper.readTree(getClass().getResourceAsStream("/runtime/fault-" + fixture + ".json"));
var error = mapper.valueToTree(failure.runtimeError());
assertEquals(fault, error.path("details").path("fault"));
assertTrue(error.path("details").path("fault").path("pc").isNull());
var wire = p.studio.app.mcp.McpToolResult.failure(mapper, failure).wire();
assertEquals(fault, wire.path("structuredContent").path("error").path("runtimeError").path("details").path("fault"));
assertThrows(UnsupportedOperationException.class, () -> failure.runtimeError().put("code", "changed"));
}
}
@Test void fragmentedProtocolPreservesUnsignedFrameIdentityLayoutAndSeparateStderr() throws Exception {
var session = start("normal"); session.initializeAndBoot(root);
var outcome = session.advance(3, ignored -> {});
assertEquals(AutomationOutcome.Kind.SUCCEEDED, outcome.kind());
assertEquals("18446744073709551615", outcome.capture().logicalFrameIndex().toString());
assertEquals("9223372036854775808", outcome.capture().frameId().toString());
assertEquals(3, outcome.capture().stridePixels());
assertTrue(outcome.diagnostics().stream().anyMatch(s -> s.contains("fixture stderr")));
var wire = p.studio.app.mcp.McpToolResult.capture(new ObjectMapper(), outcome.capture(), false).wire();
assertEquals(outcome.capture().frameId(), wire.path("structuredContent").path("value").path("frameId").bigIntegerValue());
session.shutdown().toCompletableFuture().get(3, TimeUnit.SECONDS); assertFalse(session.alive());
}
@Test void memcardNegotiatesExplicitlyAndRefusedShutdownPreservesNativeStateAndRetry() throws Exception {
var session = start("memcard");
session.initializeAndBoot(root, root, true, Map.of("memcardChoice", "persistent", "memcard", Map.of("action", "open", "access", "read_write")));
var failure = assertThrows(ExecutionException.class, () -> session.shutdown().toCompletableFuture().get(3, TimeUnit.SECONDS));
var domain = (AutomationException) failure.getCause();
assertEquals(AutomationFailure.Code.MEMCARD_ERROR, domain.failure().code());
assertTrue(session.alive());
var state = new ObjectMapper().valueToTree(session.call(TaskTools.HeadlessAction.MEMCARD_STATE, Map.of()).values());
assertEquals("18446744073709551615", state.path("memcard").path("request").path("id").textValue());
var wire = p.studio.app.mcp.McpToolResult.failure(new ObjectMapper(), domain.failure()).wire();
assertEquals("unsaved_changes", wire.path("structuredContent").path("error").path("runtimeError").path("details").path("reason").asText());
session.stop(Map.of("discardUnsaved", true, "pendingWrites", "cancel")).toCompletableFuture().get(3, TimeUnit.SECONDS);
assertFalse(session.alive());
var requests = Files.readAllLines(root.resolve("requests.jsonl")).stream().map(line -> {
try { return new ObjectMapper().readTree(line); } catch (Exception e) { throw new RuntimeException(e); }
}).toList();
assertEquals(1, requests.getFirst().path("params").path("protocolVersion").path("minor").intValue());
assertEquals("open", requests.get(1).path("params").path("action").asText());
assertEquals(root.resolve(".studio/memcard.pmc").toString(), requests.get(1).path("params").path("path").asText());
assertFalse(requests.get(3).path("params").has("discardUnsaved"));
assertFalse(Files.exists(root.resolve(".studio/memcard.pmc")));
}
@Test void memcardRejectsOldProvidersAndBadNegotiationBeforeBootOrMount() throws Exception {
for (var mode : List.of("normal", "memcard-negotiation")) {
var session = start(mode);
assertEquals(AutomationFailure.Code.RUNTIME_INCOMPATIBLE, assertThrows(AutomationException.class,
() -> session.initializeAndBoot(root, root, true, Map.of("memcardChoice", "memory_fresh"))).failure().code());
if (Files.exists(root.resolve("requests.jsonl"))) {
var sent = Files.readString(root.resolve("requests.jsonl"));
assertFalse(sent.contains("\"command\":\"boot\"")); assertFalse(sent.contains("memcard_mount"));
}
session.abort("test complete");
}
}
@Test void residentMediaActionIsAnOutcomeAndMalformedNativeStateInvalidatesSession() throws Exception {
var session = start("memcard-action"); session.initializeAndBoot(root, root, true, Map.of("memcardChoice", "memory_fresh"));
assertEquals(AutomationOutcome.Kind.ACTION_REQUIRED, session.advance(3, ignored -> {}).kind());
assertTrue(session.alive());
var malformed = start("memcard-malformed"); malformed.initializeAndBoot(root, root, true, Map.of("memcardChoice", "memory_fresh"));
assertThrows(AutomationException.class, () -> malformed.call(TaskTools.HeadlessAction.MEMCARD_STATE, Map.of()));
assertFalse(malformed.alive());
}
@Test void rejectsBadHandshakeMalformedOversizedAndNonUtf8OutputAndCleansUp() throws Exception {
for (var mode : List.of("major", "capabilities", "limits", "malformed", "oversized", "utf8", "wrong-session", "no-hello")) {
var session = start(mode);
assertThrows(Exception.class, () -> session.initializeAndBoot(root), mode);
session.abort("startup rejection"); assertFalse(session.alive(), mode);
}
}
@Test void crashRetainsOnlyObservedProgressAndNeverRestartsOrReplays() throws Exception {
var session = start("crash"); session.initializeAndBoot(root);
var known = new AtomicReference<TrackedOperation.Progress>();
assertThrows(AutomationException.class, () -> session.advance(30, known::set));
assertEquals(2L, known.get().completedFrames()); assertFalse(session.alive());
assertEquals(RuntimeObservation.Lifecycle.LOST, session.observation().lifecycle());
assertEquals(2L, session.observation().progress().completedFrames());
assertTrue(session.observation().recovery().stream().noneMatch(RuntimeObservation.RecoveryAction::automatic));
assertThrows(AutomationException.class, () -> session.call(TaskTools.HeadlessAction.STATE, Map.of()));
}
@Test void deadlinesStopHungCallsAndCancellationPreservesKnownPartialProgress() throws Exception {
var call = start("hang-call"); call.initializeAndBoot(root);
assertThrows(AutomationException.class, () -> call.call(TaskTools.HeadlessAction.STATE, Map.of())); assertFalse(call.alive());
var session = start("hang-cancel"); session.initializeAndBoot(root);
var known = new AtomicReference<TrackedOperation.Progress>();
assertThrows(AutomationException.class, () -> session.advance(30, known::set));
assertEquals(2L, known.get().completedFrames()); assertFalse(session.alive());
}
@Test void cooperativeCancelReturnsFinalImageAndRejectsConcurrentWork() throws Exception {
var session = start("cooperative"); session.initializeAndBoot(root);
var entered = new CountDownLatch(1);
try (var workers = Executors.newSingleThreadExecutor()) {
var result = workers.submit(() -> session.advance(30, ignored -> entered.countDown()));
assertTrue(entered.await(5, TimeUnit.SECONDS));
assertEquals(AutomationFailure.Code.BUSY, assertThrows(AutomationException.class,
() -> session.call(TaskTools.HeadlessAction.STATE, Map.of())).failure().code());
session.cancel();
var outcome = result.get(10, TimeUnit.SECONDS);
assertEquals(AutomationOutcome.Kind.CANCELLED, outcome.kind()); assertEquals(2, outcome.completedFrames()); assertNotNull(outcome.capture());
}
session.shutdown().toCompletableFuture().get(3, TimeUnit.SECONDS); assertFalse(session.alive());
}
@Test void malformedProgressAndCaptureInvalidateSession() throws Exception {
for (var mode : List.of("bad-progress", "bad-png")) {
var session = start(mode); session.initializeAndBoot(root);
assertThrows(AutomationException.class, () -> session.advance(3, ignored -> {})); assertFalse(session.alive());
assertEquals(RuntimeObservation.Lifecycle.LOST, session.observation().lifecycle());
assertEquals("protocol", ((Map<?, ?>)((Map<?, ?>)session.observation().nativeDetails().get("consumerFailure")).get("details")).get("failureKind"));
}
}
@Test void shutdownEscalatesAndKillsOwnedDescendantsWithoutTouchingUnrelatedProcesses() throws Exception {
var unrelated = new ProcessBuilder(HeadlessFixture.java(), "-cp", System.getProperty("java.class.path"), HeadlessFixture.class.getName(), "child").start();
try {
var session = start("descendant"); session.initializeAndBoot(root);
long child = Long.parseLong(Files.readString(root.resolve("descendant.pid")));
assertTrue(ProcessHandle.of(child).orElseThrow().isAlive());
assertThrows(ExecutionException.class, () -> session.shutdown().toCompletableFuture().get(4, TimeUnit.SECONDS));
assertFalse(session.alive()); assertFalse(ProcessHandle.of(child).map(ProcessHandle::isAlive).orElse(false));
assertTrue(unrelated.isAlive());
session.shutdown().toCompletableFuture().get(2, TimeUnit.SECONDS); // Explicit cleanup retry can acknowledge the dead tree.
} finally { unrelated.destroyForcibly(); unrelated.waitFor(2, TimeUnit.SECONDS); }
}
@Test void missingConfiguredInstallationIsExplicitAndNeverDiscoversAnotherRuntime() throws Exception {
var project = new p.studio.api.project.ProjectReference("game", "1", "pbs", 1, p.studio.api.project.ProjectTarget.Game, root);
var build = p.studio.api.shipper.ShipperPrepareResult.failed(List.of(), List.of());
var missing = new HeadlessProcessGateway(new ObjectMapper(), ignored -> p.studio.api.project.ProjectLocalStudioSetup.defaults());
assertEquals(AutomationFailure.Code.RUNTIME_UNAVAILABLE, assertThrows(AutomationException.class,
() -> missing.boot(project, "build", build)).failure().code());
var unavailable = new HeadlessProcessGateway(new ObjectMapper(), ignored -> new p.studio.api.project.ProjectLocalStudioSetup(root.toString(), null));
assertEquals(AutomationFailure.Code.RUNTIME_UNAVAILABLE, assertThrows(AutomationException.class,
() -> unavailable.boot(project, "build", build)).failure().code());
}
}