import Foundation import ParcelConfig import ParcelCore import Testing @testable import ParcelEngine @MainActor struct WorkspaceTransactionTests { @Test(arguments: [ "login", "highlight", "width", "motion", "mouse", "swap", "stack", "hover", "accessibility", "privacy", "shortcuts", ]) func configurationOnlyEditDoesNotScheduleLayout(field: String) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) let passes = harness.engine.layoutPassCount let scheduled = harness.scheduler.scheduledCount let writes = harness.world.allWrites.count let state = harness.engine.snapshot.state var config = harness.engine.configuration switch field { case "login": config.general.launchAtLogin.toggle() case "highlight": config.motion.highlight = .glow case "width": config.motion.highlightWidth = 5 case "motion": config.motion.enabled.toggle() case "mouse": config.mouse.enabled.toggle() case "swap": config.mouse.swapModifiers = .control case "stack": config.mouse.stackModifiers = .shift case "hover": config.hoverBar.enabled.toggle() case "accessibility": config.accessibility.announceLayoutChanges.toggle() case "privacy": config.focusModes.noPeekLevel = 0.3 case "shortcuts": config.keybindings.removeAll() default: Issue.record("Unknown configuration fixture") } try harness.engine.applyConfiguration(config) #expect(harness.engine.configuration == config) #expect(harness.engine.snapshot.state == state) #expect(harness.engine.layoutPassCount == passes) #expect(harness.scheduler.scheduledCount == scheduled) #expect(harness.world.allWrites.count == writes) #expect(harness.engine.isIdle) await harness.engine.stop() } @Test func idleMouseCancellationDoesNotScheduleLayout() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) let before = harness.engine.snapshot let passes = harness.engine.layoutPassCount let scheduled = harness.scheduler.scheduledCount let writes = harness.world.allWrites.count harness.engine.cancelMouseGesture() #expect(harness.engine.snapshot == before) #expect(harness.engine.layoutPassCount == passes) #expect(harness.scheduler.scheduledCount == scheduled) #expect(harness.world.allWrites.count == writes) #expect(harness.engine.isIdle) await harness.engine.stop() } @Test(arguments: [false, true]) func acceptsEngineClampedReadback(grid: Bool) async throws { let harness = try EngineHarness() harness.world.behaviors[engineApp] = grid ? FakeEngineWorld.Behavior(widthMultiple: 7) : FakeEngineWorld.Behavior(minimumSize: Size(width: 1300, height: 900)) try await harness.start() try harness.add([1, 2]) #expect(!harness.engine.frameAdjustments.isEmpty) for _ in 0..<8 where harness.scheduler.pendingCount > 0 { try harness.scheduler.runNext() } try #require(harness.engine.isIdle, "Clamped read-back confirmation must finish before awaiting settlement") let scheduled = harness.scheduler.scheduledCount try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) #expect(harness.scheduler.scheduledCount == scheduled) await harness.engine.stop() } @Test func waitsForWriteReceiptWithoutPolling() async throws { let harness = try EngineHarness() try await harness.start() harness.world.deferWrites = true try harness.add([1]) let scheduled = harness.scheduler.scheduledCount let wait = Task { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } while harness.engine.workspaceWaiters.isEmpty { await Task.yield() } #expect(harness.scheduler.scheduledCount == scheduled + 1) try harness.world.completeNextWrite() try await wait.value #expect(harness.engine.workspaceWaiters.isEmpty) #expect(harness.scheduler.pendingCount == 0) await harness.engine.stop() } @Test func reportsSpecificFailedWindow() async throws { let harness = try EngineHarness() try await harness.start() harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: true) try harness.add([1]) await #expect(throws: EngineWorkspaceFailure.unsettled([WindowID(rawValue: 1)])) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } await harness.engine.stop() } @Test(arguments: ["timeout", "cancel", "stop", "space", "automaticTilingOff"]) func pendingWaitTerminates(reason: String) async throws { let harness = try EngineHarness() try await harness.start() harness.world.deferWrites = true try harness.add([1]) let wait = Task { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace, timeout: .seconds(1)) } while harness.engine.workspaceWaiters.isEmpty { await Task.yield() } switch reason { case "timeout": try harness.scheduler.advance(by: 1) case "cancel": wait.cancel() case "stop": await harness.engine.stop() case "space": harness.engine.send(.activeSpaceChanged(display: engineDisplay, space: SpaceID(rawValue: 10))) try harness.scheduler.runReady() case "automaticTilingOff": harness.engine.setAutomaticTilingEnabled(false) default: Issue.record("Unknown wait fixture") } do { try await wait.value Issue.record("The pending wait should fail") } catch { switch reason { case "timeout": #expect(error as? EngineWorkspaceFailure == .unsettled([WindowID(rawValue: 1)])) case "cancel": #expect(error is CancellationError) case "stop": #expect(error as? EngineError == .stopped) case "space": #expect(error as? EngineWorkspaceFailure == .workspaceUnavailable) case "automaticTilingOff": #expect(error as? EngineWorkspaceFailure == .automaticTilingDisabled) default: break } } #expect(harness.engine.workspaceWaiters.isEmpty) await harness.engine.stop() } @Test func unchangedTourRollbackDoesNotWriteOrWaitForReadback() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let writes = harness.world.allWrites.count harness.engine.setWaitingForTour(false) #expect(!harness.engine.workspaceNeedsFrameRestoration(point)) try await harness.engine.restoreWorkspace(point) #expect(harness.engine.workspaceWaiters.isEmpty) #expect(harness.world.allWrites.count == writes) try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) await harness.engine.stop() } @Test func unchangedRollbackPreservesOtherDisplayReadback() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let other = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: other) try harness.finishMotion() let readbacks = harness.engine.snapshot.readbackFrames let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) try await harness.engine.restoreWorkspace(point) #expect(harness.engine.snapshot.readbackFrames == readbacks) try await harness.engine.awaitWorkspaceSettled(in: other) await harness.engine.stop() } @Test(arguments: [false, true]) func unchangedFloatingSiblingCannotExemptAnUnknownOrMovedTiledWrite(moved: Bool) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1]) var floating = engineWindow(2) floating.isFloating = true harness.world.appear(floating) try harness.scheduler.runReady() try harness.finishMotion() harness.engine.setAutomaticTilingEnabled(false) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let tiled = WindowID(rawValue: 1) harness.engine.workspaceWriteAttempts[tiled, default: 0] += 1 harness.engine.snapshot.readbackFrames[tiled] = nil if moved { harness.engine.actualFrames[tiled] = initialEngineFrame } harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: false)) #expect(harness.engine.workspaceUnmovedApplications(point, among: [engineApp]).isEmpty) await #expect(throws: EngineWorkspaceFailure.unsettled([tiled])) { try await driveTour(harness) { try await harness.engine.restoreWorkspace(point) } } await harness.engine.stop() } @Test func queuedDiscoveryIsCapturedWithoutMovingWindows() async throws { let harness = try EngineHarness() try await harness.start() harness.engine.setWaitingForTour(true) harness.engine.send( .windowAppeared( ManagedWindow(id: WindowID(rawValue: 1), app: engineApp), workspace: engineWorkspace, frame: Rect(x: 70, y: 90, width: 400, height: 300))) try harness.engine.flushTourDiscovery() let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) #expect(harness.engine.snapshot.state.windows.count == 1) #expect(!harness.engine.workspaceNeedsFrameRestoration(point)) #expect(harness.world.allWrites.isEmpty) await harness.engine.stop() } @Test(arguments: [false, true]) func unchangedExplicitWriteNeedsRecoveryOnlyWhenReadbackIsUnknown(failsReadback: Bool) async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let original = harness.world.frames let layout = try #require(harness.engine.snapshot.state.workspaces[engineWorkspace]?.layout) harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: failsReadback) harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(layout), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames == original) #expect(harness.engine.workspaceNeedsFrameRestoration(point) == failsReadback) if failsReadback { await #expect(throws: EngineWorkspaceFailure.self) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } } else { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } await harness.engine.stop() } @Test func failedReadbackStillRequiresRestorationAfterDispatch() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1, 2]) try harness.finishMotion() harness.engine.setWaitingForTour(true) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.world.behaviors[engineApp] = FakeEngineWorld.Behavior(timesOut: true) harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.engine.workspaceNeedsFrameRestoration(point)) await harness.engine.stop() } @Test func knownUnresponsiveAppIsLeftAloneWhileHealthyWindowsSettle() async throws { let harness = try EngineHarness() try await harness.start() try harness.add([1]) try harness.add([2], app: secondEngineApp) try harness.finishMotion() let skipped = harness.world.frames[WindowID(rawValue: 1)] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: false)) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames[WindowID(rawValue: 1)] == skipped) let unmoved = harness.engine.workspaceUnmovedApplications(point, among: [engineApp]) #expect(unmoved == [engineApp]) try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace, excludingApplications: unmoved) await #expect(throws: EngineWorkspaceFailure.self) { try await driveTour(harness) { try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) } } harness.engine.receive(.appResponsivenessChanged(engineApp, isResponsive: true)) try harness.scheduler.runReady() try harness.finishMotion() try await harness.engine.awaitWorkspaceSettled(in: engineWorkspace) await harness.engine.stop() } @Test func manualTidyDoesNotReleaseAnotherDisplayBeforeSuccess() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let other = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: other) try harness.finishMotion() harness.engine.setWaitingForTour(true) let before = harness.world.frames[WindowID(rawValue: 3)] let writes = harness.world.allWrites.count harness.engine.setWaitingForTour(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.world.frames[WindowID(rawValue: 3)] == before) #expect(!harness.world.allWrites.dropFirst(writes).contains { $0.window == WindowID(rawValue: 3) }) await harness.engine.stop() } @Test func restorePreservesOtherDisplayAndNewWindows() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let otherKey = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3, 4], app: secondEngineApp, workspace: otherKey) let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) let original = harness.engine.snapshot.state.workspaces[engineWorkspace] harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) harness.engine.send(.workspaceCommandIssued(.setLayout(.side), workspace: otherKey)) try harness.scheduler.runReady() try harness.add([5]) harness.world.disappear(WindowID(rawValue: 2)) try harness.scheduler.runReady() let other = harness.engine.snapshot.state.workspaces[otherKey] try await restore(point, using: harness) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace]?.layout == original?.layout) #expect( Set(harness.engine.snapshot.state.workspaces[engineWorkspace]?.order ?? []) == [ WindowID(rawValue: 1), WindowID(rawValue: 5), ]) #expect(harness.engine.snapshot.state.workspaces[otherKey] == other) #expect(harness.world.frames == harness.engine.snapshot.state.frames) await harness.engine.stop() } @Test func restoringManualWorkspaceRestoresHandPlacedFramesWithoutMovingOtherDisplay() async throws { let harness = try EngineHarness(initialState: engineInitialState(twoDisplays: true)) try await harness.start() try harness.add([1, 2]) let otherKey = WorkspaceKey(display: secondEngineDisplay, space: SpaceID(rawValue: 2)) try harness.add([3], app: secondEngineApp, workspace: otherKey) harness.engine.setAutomaticTilingEnabled(false) let handPlaced = Rect(x: 80, y: 90, width: 380, height: 290) harness.world.userFrame(WindowID(rawValue: 1), frame: handPlaced) try harness.scheduler.runReady() let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setAutomaticTilingEnabled(true) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() let otherFrame = harness.world.frames[WindowID(rawValue: 3)] let writes = harness.world.allWrites.count try await restore(point, using: harness) #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.world.frames[WindowID(rawValue: 1)] == handPlaced) #expect(harness.world.frames[WindowID(rawValue: 3)] == otherFrame) #expect(!harness.world.allWrites.dropFirst(writes).contains { $0.window == WindowID(rawValue: 3) }) await harness.engine.stop() } @Test(arguments: [false, true]) func tourRollbackPreservesReadbackWhenHeldTargetsAreRecomputed(paused: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) try harness.finishMotion() if paused { harness.engine.setAutomaticTilingEnabled(false) harness.world.userFrame(WindowID(rawValue: 1), frame: Rect(x: 80, y: 90, width: 380, height: 290)) try harness.scheduler.runReady() } harness.engine.setWaitingForTour(true) let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) #expect(!point.isAutomaticTilingEnabled) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.finishMotion() #expect(harness.world.frames != original) try await restore(point, using: harness) harness.engine.setWaitingForTour(true) let writes = harness.world.allWrites.count harness.engine.send(.relayout) try harness.scheduler.runReady() #expect(harness.engine.isWaitingForTour) #expect(!harness.engine.isAutomaticTilingEnabled) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(harness.world.allWrites.count == writes) if paused { #expect(harness.engine.snapshot.state.frames != original) } } catch { await harness.engine.stop() throw error } await harness.engine.stop() } @Test(arguments: [false, true], [false, true]) func rollbackSupersedesManualLayoutTargets(paused: Bool, queued: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) if paused { harness.engine.setAutomaticTilingEnabled(false) } harness.engine.setWaitingForTour(true) let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.world.deferWrites = true harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) if !queued { try harness.scheduler.runReady() harness.engine.setAutomaticTilingEnabled(false) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() } let rollback = Task { try await harness.engine.restoreWorkspace(point) } if queued { try await rollback.value #expect(harness.engine.workspaceWaiters.isEmpty) } else { for _ in 0..<100 where harness.engine.workspaceWaiters.isEmpty { await Task.yield() } try #require(!harness.engine.workspaceWaiters.isEmpty) } #expect(harness.engine.manualCommandFrames.isEmpty) harness.world.deferWrites = false for _ in 0..<100 where harness.world.pendingWriteCount > 0 { try harness.world.completeNextWrite() try harness.scheduler.runReady() } try harness.finishMotion() try await rollback.value #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(!harness.engine.isAutomaticTilingEnabled) } catch { await harness.engine.stop() throw error } await harness.engine.stop() } @Test(arguments: [false, true]) func rollbackRewritesSavedFramesAfterAnInFlightLayoutWrite(paused: Bool) async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) if paused { harness.engine.setAutomaticTilingEnabled(false) } harness.engine.setWaitingForTour(true) let original = harness.world.frames let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.setWaitingForTour(false) harness.engine.setAutomaticTilingEnabled(true) harness.world.deferWrites = true harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) try harness.scheduler.runReady() try harness.scheduler.advance(by: 0.02) try #require(harness.world.pendingWriteCount > 0) #expect(harness.engine.actualFrames == original) let rollback = Task { try await harness.engine.restoreWorkspace(point) } for _ in 0..<100 where harness.engine.workspaceWaiters.isEmpty { await Task.yield() } try #require(!harness.engine.workspaceWaiters.isEmpty) harness.world.deferWrites = false try harness.world.completeNextWrite() try harness.scheduler.runReady() try harness.finishMotion() try await rollback.value #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(!harness.engine.isAutomaticTilingEnabled) } catch { await harness.engine.stop() throw error } await harness.engine.stop() } @Test func rollbackDrainsQueuedManualCommandsBeforeRestoringHandPlacements() async throws { let harness = try EngineHarness() try await harness.start() do { try harness.add([1, 2, 3]) harness.engine.setAutomaticTilingEnabled(false) harness.world.userFrame(WindowID(rawValue: 1), frame: Rect(x: 80, y: 90, width: 380, height: 290)) try harness.scheduler.runReady() let original = harness.world.frames let workspace = harness.engine.snapshot.state.workspaces[engineWorkspace] let point = try harness.engine.captureWorkspaceRestorePoint(in: engineWorkspace) harness.engine.send(.workspaceCommandIssued(.setLayout(.rows), workspace: engineWorkspace)) harness.engine.send(.workspaceCommandIssued(.setLayout(.side), workspace: engineWorkspace)) try await restore(point, using: harness) #expect(harness.engine.snapshot.state.workspaces[engineWorkspace] == workspace) #expect(harness.world.frames == original) #expect(harness.engine.actualFrames == original) #expect(harness.engine.manualCommandFrames.isEmpty) } catch { await harness.engine.stop() throw error } await harness.engine.stop() } private func restore(_ point: EngineWorkspaceRestorePoint, using harness: EngineHarness) async throws { var finished = false let task = Task { defer { finished = true } try await harness.engine.restoreWorkspace(point) } for _ in 0..<100 where !finished { await Task.yield() try harness.scheduler.advance(by: 0.5) } try await task.value } @Test func restorePointCannotCrossEnginesOrDisconnectedSpaces() async throws { let first = try EngineHarness() let second = try EngineHarness() try await first.start() try await second.start() let point = try first.engine.captureWorkspaceRestorePoint(in: engineWorkspace) await #expect(throws: EngineWorkspaceFailure.workspaceUnavailable) { try await second.engine.restoreWorkspace(point) } first.engine.send(.displaySetChanged([])) try first.scheduler.runReady() await #expect(throws: EngineWorkspaceFailure.workspaceUnavailable) { try await first.engine.restoreWorkspace(point) } await first.engine.stop() await second.engine.stop() } }