package p.studio.app.runtime; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.*; import org.junit.jupiter.api.io.TempDir; import org.springframework.boot.WebApplicationType; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.context.ConfigurableApplicationContext; import p.studio.api.automation.*; import p.studio.api.project.*; import p.studio.api.session.*; import p.studio.api.shipper.Shipper; import p.studio.app.StudioApplicationConfiguration; import p.studio.core.project.ProjectLocalStudioSetupStore; import java.nio.file.*; import java.util.*; import java.util.concurrent.TimeUnit; import static org.junit.jupiter.api.Assertions.*; /** Actual app composition and saved-source services; no runtime/build/LSP doubles. */ @org.junit.jupiter.api.Tag("integration") class HeadlessTaskIntegrationTest { @TempDir Path root; ConfigurableApplicationContext app; ProjectSession project; TaskTools tasks; LanguageQueries language; ObjectMapper mapper; Path source; String task, code; final Set ownedProcesses = new HashSet<>(); @BeforeEach void open() throws Exception { root = root.toRealPath(); String installation = System.getProperty("studio.test.runtimeInstall", ""); assertFalse(installation.isBlank(), "Supply -PstudioRuntimeInstall="); app = new SpringApplicationBuilder(StudioApplicationConfiguration.class).web(WebApplicationType.NONE).headless(true).run(); mapper = app.getBean(ObjectMapper.class); for (var ref : p.studio.compiler.FrontendRegistryService.require("pbs").documentation().orElseThrow().references(1, p.studio.AppMode.Game)) { if (!ref.id().startsWith("pbs:example:game:1:")) continue; Path file = root.resolve(ref.id().substring("pbs:example:game:1:".length())); Files.createDirectories(file.getParent()); Files.writeString(file, ref.text()); } source = root.resolve("src/main.pbs"); code = Files.readString(source); var reference = app.getBean(ProjectCatalog.class).openProject(root); app.getBean(ProjectLocalStudioSetupStore.class).save(reference, new ProjectLocalStudioSetup(installation, null)); project = app.getBean(ProjectSessionFactory.class).open(reference); tasks = app.getBean(TaskTools.class); language = app.getBean(LanguageQueries.class); assertTrue(project.automation().grant(false).toCompletableFuture().get(5, TimeUnit.SECONDS).success()); task = tasks.acquire(root).task().value(); } @AfterEach void close() { try { if (project != null) project.close(); } finally { if (app != null) app.close(); } assertTrue(ownedProcesses.stream().noneMatch(ProcessHandle::isAlive), "Managed runtime processes must stop on project closure"); } TrackedOperation finished(String request) throws Exception { long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(30); do { var result = tasks.operation(root, task, new OperationLookup(null, request)); if (result.workerTerminated()) return result; Thread.sleep(5); } while (System.nanoTime() < deadline); throw new AssertionError("Operation did not finish: " + request); } TrackedOperation build(String request) throws Exception { tasks.build(root, task, request); return finished(request); } String successfulBuild(String request) throws Exception { var result = build(request); assertNull(result.failure()); assertNotNull(result.buildResult()); assertTrue(result.buildResult().success(), result.buildResult().diagnostics().toString()); assertNotNull(result.buildId()); return result.buildId(); } TaskTools.HeadlessReply call(TaskTools.HeadlessAction action, String build) { var reply = tasks.headless(root, task, action, build, Map.of()); if (action == TaskTools.HeadlessAction.BOOT) { String installation = Path.of(System.getProperty("studio.test.runtimeInstall")).toAbsolutePath().toString(); ProcessHandle.current().descendants().filter(process -> process.info().command().orElse("").startsWith(installation + "/")) .forEach(ownedProcesses::add); assertFalse(ownedProcesses.isEmpty(), "Observe the actual packaged runtime process"); } return reply; } AutomationOutcome advance(String request) throws Exception { tasks.advance(root, task, request, 3); var result = finished(request); assertNull(result.failure(), String.valueOf(result.failure())); assertNotNull(result.runtimeResult()); return result.runtimeResult(); } com.fasterxml.jackson.databind.JsonNode diagnostics() { return mapper.valueToTree(language.query(root, task, "diagnostics", Map.of("uri", source.toUri().toString()))).path("result"); } void authorityRetained() { assertEquals(ControlState.AGENT_WORKING, project.automation().snapshot().state()); } @Test void originalCaptureEvidenceSurvivesLaterFramesRebuildReleaseAndReopen() throws Exception { call(TaskTools.HeadlessAction.BOOT,successfulBuild("evidence-build")); tasks.advance(root,task,"evidence-frame",1);var original=finished("evidence-frame"); var evidence=app.getBean(EvidenceTools.class); var saved=evidence.persist(root,task,"save-original",new OperationLookup(null,"evidence-frame")); var artifact=saved.artifacts().getFirst(); assertArrayEquals(original.runtimeResult().capture().png(),evidence.image(root,task,artifact.id())); advance("later-frame"); assertEquals(saved,evidence.persist(root,task,"save-original",new OperationLookup(null,"evidence-frame"))); assertTrue(evidence.metadata(root,task,artifact.id()).stale()); assertEquals(original.runtimeResult().capture().frameId(),artifact.provenance().get("frameId")); // This derived reference has a deliberate wrong sample; independent pixel oracles are tested separately. var codec=new p.studio.app.evidence.PngEvidenceCodec();var pixels=codec.decode(original.runtimeResult().capture().png()); byte[] different=pixels.rgba();different[0]=(byte)(Byte.toUnsignedInt(different[0])^1); Path reference=root.resolve("known-different.png");Files.write(reference,codec.encode(new Evidence.Pixels(pixels.width(),pixels.height(),different))); var expected=evidence.importReference(root,task,"import-delta",reference,null).artifacts().getFirst(); var report=evidence.compare(root,task,"known-failure",expected.id(),artifact.id(),Evidence.Parameters.exact(Evidence.Alpha.compare)); assertEquals(Evidence.Verdict.rejected,report.report().verdict());assertEquals(1,report.report().differentPixels()); assertEquals(new Evidence.Rect(0,0,1,1),report.report().boundingBox()); successfulBuild("evidence-rebuild"); tasks.release(root,task).toCompletableFuture().get(10,TimeUnit.SECONDS);project.close(); var ref=app.getBean(ProjectCatalog.class).openProject(root);project=app.getBean(ProjectSessionFactory.class).open(ref); project.automation().grant(false).toCompletableFuture().get(5,TimeUnit.SECONDS);task=tasks.acquire(root).task().value(); assertArrayEquals(original.runtimeResult().capture().png(),evidence.image(root,task,artifact.id())); assertEquals(saved,evidence.persist(root,task,"save-original",new OperationLookup(null,"evidence-frame"))); System.out.println("VISUAL_EVIDENCE "+mapper.writeValueAsString(Map.of("kind","native-checkpoint","artifact",artifact,"report",report.report(),"nativeAdvanceRequests",2,"persistenceExtraAdvanceOrCaptureRequests",0))); } @Test void pongPilotUsesDisposableCopyAndIndependentRegionReferences() throws Exception { String fixture=System.getProperty("studio.test.pong"); assertNotNull(fixture,"Run headlessProcessTest to select Studio's test-projects/pong fixture"); Path originalProject=Path.of(fixture).toAbsolutePath().normalize(); assertTrue(Files.isRegularFile(originalProject.resolve("prometeu.json")),"Repository-owned Pong fixture is required"); String originalSource=Files.readString(originalProject.resolve("src/main.pbs")); project.close();Path copy=root.resolve("Pong Headless");Files.createDirectories(copy); for(String name:List.of("prometeu.json","src","assets")) { Path from=originalProject.resolve(name); if(!Files.exists(from))continue; // Pong has no external assets. if(Files.isDirectory(from))try(var paths=Files.walk(from)) { for(var p:paths.toList()){var target=copy.resolve(originalProject.relativize(p));if(Files.isDirectory(p))Files.createDirectories(target);else Files.copy(p,target);} }else Files.copy(from,copy.resolve(name)); } root=copy.toRealPath();var ref=app.getBean(ProjectCatalog.class).openProject(root); app.getBean(ProjectLocalStudioSetupStore.class).save(ref,new ProjectLocalStudioSetup(System.getProperty("studio.test.runtimeInstall"),null)); project=app.getBean(ProjectSessionFactory.class).open(ref);project.automation().grant(false).toCompletableFuture().get(5,TimeUnit.SECONDS);task=tasks.acquire(root).task().value(); String build=successfulBuild("pong-pilot-build");call(TaskTools.HeadlessAction.BOOT,build); var evidence=app.getBean(EvidenceTools.class);var measurements=new ArrayList>(); var mcp=app.getBean(p.studio.app.mcp.McpToolRegistry.class); long beforeWireBytes=0,afterWireBytes=0;int beforeCalls=0,afterCalls=0; var legacyPaths=new ArrayList(); String[] names={"menu-accent","serve-ball","moved-paddle"}; // Fixed expectations from the fixture's draw/input contract, never from a native capture. Evidence.Rect[] regions={new Evidence.Rect(113,114,1,80),new Evidence.Rect(237,152,6,6),new Evidence.Rect(42,72,8,36)}; int[][] colors={{77,237,205},{236,244,250},{77,237,205}}; long totalPngBytes=0; for(int i=0;i(List.of(Path.of(System.getProperty("java.home"),"bin","java").toString(),script.toString()));command.addAll(legacyPaths); var legacy=new ProcessBuilder(command).redirectErrorStream(true).start();assertTrue(legacy.waitFor(30,TimeUnit.SECONDS)); String legacyOutput=new String(legacy.getInputStream().readAllBytes(),java.nio.charset.StandardCharsets.UTF_8);assertEquals(0,legacy.exitValue(),legacyOutput); assertEquals(originalSource,Files.readString(originalProject.resolve("src/main.pbs")),"Build and runtime must use only the disposable copy"); var output=Map.of("kind","pong-pilot","limitations","Solid-color references specify only the declared ROIs independently of native captures. These checks cover menu, serve and input-driven paddle movement, not full-game visual equivalence.", "results",measurements,"measurement",Map.of("sharedGuestAdvanceRequests",3,"before",Map.of("mcpCalls",beforeCalls,"wireResponseBytes",beforeWireBytes,"imagePngBytes",totalPngBytes,"externalComparisonScripts",1,"externalScriptOutput",legacyOutput), "after",Map.of("mcpCalls",afterCalls,"wireResponseBytes",afterWireBytes,"imageTransferBytesForMetrics",0,"externalComparisonScripts",0), "basis","Actual local MCP adapter dispatches and serialized response bytes, excluding shared build/advance/asynchronous polling. Both comparison paths use the same three retained guest checkpoints. Legacy full-image exact metrics differ from ROI-specific checks by design.")); System.out.println("VISUAL_EVIDENCE "+mapper.writeValueAsString(output)); } @Test void actualWatchdogPreservesNativeCauseZeroProgressAndDoesNotReplayOnLookup() throws Exception { Files.writeString(source, code.replace("fn frame() -> void {", "fn frame() -> void { while (true) { }")); call(TaskTools.HeadlessAction.BOOT, successfulBuild("watchdog-build")); tasks.advance(root, task, "watchdog", 1); var result = finished("watchdog"); assertNull(result.failure()); assertEquals(AutomationOutcome.Kind.INFRASTRUCTURE_FAILURE, result.runtimeResult().kind()); assertEquals(0L, result.progress().completedFrames()); assertEquals("watchdog_expired", ((Map)result.observation().nativeDetails().get("error")).get("code")); assertTrue(result.observation().captureStale()); assertEquals("watchdog", result.observation().context().get("clientRequestId")); var artifactHashes = new LinkedHashMap(); for (var file : finished("watchdog-build").buildResult().emittedArtifacts()) if (Files.isRegularFile(file)) artifactHashes.put(root.relativize(file).toString(), HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(Files.readAllBytes(file)))); System.out.println("HEADLESS_OBSERVATION " + mapper.writeValueAsString(Map.of( "sourceSha256", HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(Files.readAllBytes(source))), "artifacts", artifactHashes, "observation", result.observation().toMap()))); var before = call(TaskTools.HeadlessAction.STATE, null).values().get("state"); var lookup = tasks.operation(root, task, new OperationLookup(null, "watchdog")); assertEquals(result.observation(), lookup.observation()); assertEquals(before, call(TaskTools.HeadlessAction.STATE, null).values().get("state")); assertNull(call(TaskTools.HeadlessAction.FAULT, null).values().get("fault")); authorityRetained(); Files.writeString(source, code); call(TaskTools.HeadlessAction.BOOT, successfulBuild("corrected-watchdog")); assertEquals(AutomationOutcome.Kind.SUCCEEDED, advance("after-watchdog").kind()); } @Test void savedEditsRebuildRealArtifactsAndCorrelateDevWithoutSnapshots() throws Exception { assertTrue(diagnostics().isEmpty()); assertThrows(ControlDeniedException.class, () -> app.getBean(Shipper.class).prepare(project.projectReference(), ignored -> {})); String first = successfulBuild("first"); String session = (String) call(TaskTools.HeadlessAction.BOOT, first).values().get("sessionId"); var initial = advance("initial"); assertEquals(AutomationOutcome.Kind.SUCCEEDED, initial.kind()); assertEquals(first, initial.capture().buildId()); assertArrayEquals(initial.capture().png(), project.automation().snapshot().capture().png()); call(TaskTools.HeadlessAction.RESET, null); assertTrue(project.automation().snapshot().stale()); assertEquals(RuntimeObservation.Lifecycle.UNBOOTED, project.automation().snapshot().runtimeObservation().lifecycle()); var historical = finished("initial").observation(); assertEquals(first, historical.buildId()); assertEquals(3L, historical.progress().completedFrames()); assertNotEquals(historical.lifecycle(), finished("initial").currentObservation().lifecycle()); assertEquals(AutomationFailure.Code.NO_FRAME_AVAILABLE, assertThrows(AutomationException.class, () -> call(TaskTools.HeadlessAction.CAPTURE, null)).failure().code()); assertEquals(session, call(TaskTools.HeadlessAction.BOOT, first).values().get("sessionId")); assertArrayEquals(initial.capture().png(), advance("rebooted").capture().png()); // Native agent-style edit: same project files, no clean-tree or apply step. Files.writeString(source, code.replace("Color.rgb(16, 20, 28)", "Color.rgb(80, 40, 20)")); assertTrue(diagnostics().isEmpty()); String second = successfulBuild("second"); assertNotEquals(first, second); assertTrue(project.automation().snapshot().stale()); assertTrue(finished("initial").captureStale()); assertEquals(AutomationFailure.Code.SESSION_NOT_FOUND, assertThrows(AutomationException.class, () -> call(TaskTools.HeadlessAction.STATE, null)).failure().code()); assertEquals(AutomationFailure.Code.BUILD_NOT_FOUND, assertThrows(AutomationException.class, () -> call(TaskTools.HeadlessAction.BOOT, first)).failure().code()); assertTrue(ownedProcesses.stream().noneMatch(ProcessHandle::isAlive), "Rebuild must stop the previous runtime"); assertNotEquals(session, call(TaskTools.HeadlessAction.BOOT, second).values().get("sessionId")); var changed = advance("changed"); assertFalse(Arrays.equals(initial.capture().png(), changed.capture().png())); assertEquals(second, project.automation().snapshot().capture().buildId()); assertFalse(project.automation().snapshot().stale()); authorityRetained(); assertTrue(tasks.release(root, task).toCompletableFuture().get(7, TimeUnit.SECONDS).success()); assertTrue(project.automation().snapshot().manualAllowed()); assertTrue(ownedProcesses.stream().noneMatch(ProcessHandle::isAlive), "Release must stop the runtime before returning control"); assertTrue(Files.readString(source).contains("Color.rgb(80, 40, 20)")); } @Test void compileAndGuestFailuresKeepAuthorityForCorrectiveBuilds() throws Exception { String original = successfulBuild("original"); call(TaskTools.HeadlessAction.BOOT, original); advance("before-error"); Files.writeString(source, "fn frame( {"); assertFalse(diagnostics().isEmpty()); var failed = build("compile-error"); assertFalse(failed.buildResult().success()); assertNull(failed.buildId()); assertFalse(failed.buildResult().diagnostics().isEmpty()); assertFalse(project.automation().snapshot().diagnostics().isEmpty()); assertTrue(project.automation().snapshot().stale()); authorityRetained(); assertEquals(AutomationFailure.Code.BUILD_NOT_FOUND, assertThrows(AutomationException.class, () -> call(TaskTools.HeadlessAction.BOOT, original)).failure().code()); Files.writeString(source, code.replace("x = x + 1;", "x = x / (x - x);")); assertTrue(diagnostics().isEmpty()); call(TaskTools.HeadlessAction.BOOT, successfulBuild("guest-error")); var fault = advance("fault"); assertEquals(AutomationOutcome.Kind.GUEST_FAULT, fault.kind()); assertFalse(fault.diagnostics().isEmpty()); assertNotNull(fault.observation().nativeDetails().get("fault")); assertNotNull(call(TaskTools.HeadlessAction.FAULT, null).values().get("fault")); authorityRetained(); Files.writeString(source, code); assertTrue(diagnostics().isEmpty()); call(TaskTools.HeadlessAction.BOOT, successfulBuild("corrected")); assertEquals(AutomationOutcome.Kind.SUCCEEDED, advance("working-again").kind()); authorityRetained(); } @Test void unavailableRuntimeIsExplicitAndCanBeConfiguredWithinTheSameTask() throws Exception { String build = successfulBuild("build"); var setup = app.getBean(ProjectLocalStudioSetupStore.class); setup.save(project.projectReference(), ProjectLocalStudioSetup.defaults()); assertEquals(AutomationFailure.Code.RUNTIME_UNAVAILABLE, assertThrows(AutomationException.class, () -> call(TaskTools.HeadlessAction.BOOT, build)).failure().code()); authorityRetained(); setup.save(project.projectReference(), new ProjectLocalStudioSetup(System.getProperty("studio.test.runtimeInstall"), null)); call(TaskTools.HeadlessAction.BOOT, build); assertEquals(AutomationOutcome.Kind.SUCCEEDED, advance("configured").kind()); authorityRetained(); } }