rzen
53bc71f7fb
Phase 2 swaps every consumer: Liveness and its ancestor walk are gone, replaced by ItemContainer — a UUID set plus the container side it lives on, presence the whole test, one selection boundary instead of the old liveness law. Deletion stages by place: board cards move to the trash at a store-minted head rank, trash-side delete is permanent behind its confirmation, Delete Immediately skips the trash from anywhere, lane delete captures the subtree and removes the folder. Restore has no method at all — moveCards resolves members in either container, so drag-out and cut-paste are the ordinary moves 13 calls them, registering ordinary Move steps. The delete inverse moves the card back to its captured lane and rank; redo replays the captured trash rank, a value the gesture actually wrote; lane undo recreates the subtree byte-faithfully in session. Purges register nothing — where 13's trash section contradicts its own Rules on that, Rules wins, filed for ruling. Staleness collapsed to present-or-absent: a container is a path, so a foreign restore fails the delete step's expectation structurally. Legacy tombstones migrate on the loose-file tail hook, cards oldest-first so minting above top reproduces the retired newest-first column, lanes returning live, one folded loss row naming both directions. Put Back, restoreByDrag, receiveRestoredCards, TrashEntry, and the kind machinery are deleted; the trash column renders the container correctly with its full face rework left to phase 3. Claude-Session: https://claude.ai/code/session_01SR4XGjmBE16ZUYWpfFHXwY
568 lines
26 KiB
Swift
568 lines
26 KiB
Swift
import AppKit
|
|
import Foundation
|
|
import Testing
|
|
@testable import Kanban
|
|
|
|
/// The drag session's **value** halves — the pasteboard payload, the locality model, and the
|
|
/// committed overlay's hand-off condition (DRAG-REORDER.md; 04-interactions.md ▸ Drag and drop).
|
|
///
|
|
/// The session object itself, the drop delegates and the gestures are not unit-testable — they are
|
|
/// deliberately thin over these three, plus `DropSlotMath`'s arithmetic, which is why the split falls
|
|
/// where it does.
|
|
|
|
// MARK: - The payload
|
|
|
|
@Suite("DragPayload")
|
|
struct DragPayloadTests {
|
|
|
|
private static func payload(kind: DragKind = .cards, container: ItemContainer = .board) -> DragPayload {
|
|
DragPayload(
|
|
boardRoot: URL(fileURLWithPath: "/Boards/Work.kanban", isDirectory: true),
|
|
kind: kind,
|
|
container: container,
|
|
items: [
|
|
DragPayload.Item(id: "aaa", folder: "/Boards/Work.kanban/lane/aaa", title: "First"),
|
|
DragPayload.Item(id: "bbb", folder: "/Boards/Work.kanban/lane/bbb", title: nil)
|
|
]
|
|
)
|
|
}
|
|
|
|
@Test("A payload round-trips through its JSON representation unchanged")
|
|
func roundTrip() throws {
|
|
for kind in [DragKind.cards, .lanes] {
|
|
for container in [ItemContainer.board, .trash] {
|
|
let original = Self.payload(kind: kind, container: container)
|
|
let data = try #require(original.encoded())
|
|
#expect(DragPayload(data: data) == original)
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test("Garbage decodes to nothing rather than to an empty drag")
|
|
func garbageDecodesToNil() {
|
|
#expect(DragPayload(data: Data("not json".utf8)) == nil)
|
|
#expect(DragPayload(data: Data()) == nil)
|
|
}
|
|
|
|
@Test("The ids, folders and root are read back off the strings, in flatten order")
|
|
func derivedValues() {
|
|
let payload = Self.payload()
|
|
#expect(payload.ids == [ItemID(rawValue: "aaa"), ItemID(rawValue: "bbb")])
|
|
#expect(payload.folders.map(\.path) == [
|
|
"/Boards/Work.kanban/lane/aaa",
|
|
"/Boards/Work.kanban/lane/bbb"
|
|
])
|
|
#expect(payload.rootURL.path == "/Boards/Work.kanban")
|
|
}
|
|
|
|
@Test("The plain-text representation is the dragged titles, one per line")
|
|
func plainText() {
|
|
// The stray-drop-into-a-text-editor fallback. An untitled item renders as the board renders
|
|
// it — "Untitled" is a rendering, never a value (03-board-ui.md § Card face).
|
|
#expect(Self.payload().plainText == "First\nUntitled")
|
|
}
|
|
|
|
@Test("The container survives the round trip, because it is what makes a trash drag a trash drag")
|
|
func containerSurvives() throws {
|
|
let data = try #require(Self.payload(container: .trash).encoded())
|
|
#expect(DragPayload(data: data)?.container == .trash)
|
|
}
|
|
}
|
|
|
|
// MARK: - Locality
|
|
|
|
@Suite("DragLocality")
|
|
struct DragLocalityTests {
|
|
|
|
// Instance members, not `static`: every case below names them bare, and a static member is not
|
|
// reachable unqualified from an instance method. Swift Testing builds a fresh instance per test,
|
|
// so these are as constant either way.
|
|
private let here = URL(fileURLWithPath: "/Boards/Work.kanban", isDirectory: true)
|
|
private let there = URL(fileURLWithPath: "/Boards/Home.kanban", isDirectory: true)
|
|
|
|
private let none: NSEvent.ModifierFlags = []
|
|
private let option: NSEvent.ModifierFlags = [.option]
|
|
private let command: NSEvent.ModifierFlags = [.command]
|
|
|
|
@Test("Roots compare by their standardized path, so the same board is the same board")
|
|
func rootComparison() {
|
|
#expect(DragLocality.isSameBoard(here, here))
|
|
#expect(DragLocality.isSameBoard(here, URL(fileURLWithPath: "/Boards/./Work.kanban/")))
|
|
#expect(DragLocality.isSameBoard(here, URL(fileURLWithPath: "/Boards/Other/../Work.kanban")))
|
|
#expect(!DragLocality.isSameBoard(here, there))
|
|
}
|
|
|
|
/// The Finder volume model: within a board a drag rearranges, between boards it transfers.
|
|
@Test("Locality picks the default — within is a move, across is a copy")
|
|
func theDefault() {
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: true, modifiers: none) == .move)
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: false, modifiers: none) == .copy)
|
|
#expect(DragLocality.operation(kind: .lanes, container: .board, isWithinBoard: false, modifiers: none) == .copy)
|
|
}
|
|
|
|
@Test("⌥ forces copy and ⌘ forces move, each a no-op where it is already the default")
|
|
func modifiersOverride() {
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: true, modifiers: option) == .copy)
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: false, modifiers: command) == .move)
|
|
// The no-ops.
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: true, modifiers: command) == .move)
|
|
#expect(DragLocality.operation(kind: .cards, container: .board, isWithinBoard: false, modifiers: option) == .copy)
|
|
}
|
|
|
|
@Test("⌘ wins over ⌥ when both are held")
|
|
func commandWinsOverOption() {
|
|
// Finder's own reduction, and the same precedence `ClickModifier.current` applies to clicks.
|
|
#expect(DragLocality.operation(
|
|
kind: .cards, container: .board, isWithinBoard: false, modifiers: [.option, .command]) == .move)
|
|
}
|
|
|
|
/// The first carve-out: "Lane drags never copy *within their board*. ⌥ is simply ignored there:
|
|
/// the drag stays a clean reorder and the badge never shows copy."
|
|
@Test("A within-board lane drag ignores ⌥ entirely")
|
|
func laneDragsNeverCopyWithinTheirBoard() {
|
|
for modifiers in [none, option, command, [.option, .command] as NSEvent.ModifierFlags] {
|
|
#expect(
|
|
DragLocality.operation(kind: .lanes, container: .board, isWithinBoard: true, modifiers: modifiers) == .move,
|
|
"a within-board lane drag is a reorder whatever is held"
|
|
)
|
|
}
|
|
// Across boards the lane obeys the ordinary grammar again.
|
|
#expect(DragLocality.operation(kind: .lanes, container: .board, isWithinBoard: false, modifiers: option) == .copy)
|
|
#expect(DragLocality.operation(kind: .lanes, container: .board, isWithinBoard: false, modifiers: command) == .move)
|
|
}
|
|
|
|
/// The second: a trash row's drag is copy-out grammar (04-interactions.md ▸ The trash). Within its
|
|
/// own board the default is the restore — a move, no badge; across boards the default is the live
|
|
/// copy that leaves the tombstone standing. ⌘ forces the true restore-move either way, and ⌥ the
|
|
/// live copy either way.
|
|
@Test("A trash row drags as a restore at home and as a copy-out abroad")
|
|
func trashDragDefaults() {
|
|
#expect(DragLocality.operation(kind: .cards, container: .trash, isWithinBoard: true, modifiers: none) == .move)
|
|
#expect(DragLocality.operation(kind: .cards, container: .trash, isWithinBoard: false, modifiers: none) == .copy)
|
|
#expect(DragLocality.operation(
|
|
kind: .cards, container: .trash, isWithinBoard: false, modifiers: command) == .move)
|
|
#expect(DragLocality.operation(kind: .cards, container: .trash, isWithinBoard: true, modifiers: option) == .copy)
|
|
}
|
|
}
|
|
|
|
// MARK: - Dropping on the trash
|
|
|
|
/// **The delete gesture's gate** (04-interactions.md ▸ The trash, settled 2026-07-28: "dropping a
|
|
/// live card on the shown trash deletes it").
|
|
///
|
|
/// One pure function decides it, and it is asked twice — once at hover for the shadow and once at
|
|
/// release for the write — so every clause below is a claim about both.
|
|
@Suite("TrashDrop")
|
|
struct TrashDropTests {
|
|
|
|
/// The accepted session, with one clause at a time knocked out by the cases.
|
|
private func accepts(
|
|
kind: DragKind? = .cards,
|
|
container: ItemContainer = .board,
|
|
isWithinBoard: Bool = true,
|
|
operation: TransferOperation = .move,
|
|
isTrashShown: Bool = true,
|
|
acceptsMutations: Bool = true
|
|
) -> Bool {
|
|
TrashDrop.accepts(
|
|
kind: kind,
|
|
container: container,
|
|
isWithinBoard: isWithinBoard,
|
|
operation: operation,
|
|
isTrashShown: isTrashShown,
|
|
acceptsMutations: acceptsMutations
|
|
)
|
|
}
|
|
|
|
/// "The shadow always takes the topmost position — which the sort makes honest, not arbitrary:
|
|
/// the trash orders by `deleted` newest-first, so a fresh tombstone genuinely lands on top."
|
|
@Test("The landing is the topmost row, always")
|
|
func theTopmostRow() {
|
|
#expect(TrashDrop.landingIndex == 0)
|
|
}
|
|
|
|
@Test("A live, same-board, unmodified card drag is the one session the trash takes")
|
|
func theOneItTakes() {
|
|
#expect(accepts())
|
|
// ⌘ forces move, which is already the default here, so it changes nothing.
|
|
#expect(accepts(operation: .move))
|
|
}
|
|
|
|
/// "Lanes are not deliverable this way (a lane drag proposes only lane slots)."
|
|
@Test("A lane drag never proposes into the trash")
|
|
func lanesAreNotDeliverable() {
|
|
#expect(!accepts(kind: .lanes))
|
|
// And no session at all is no proposal either — the column is inert between drags.
|
|
#expect(!accepts(kind: nil))
|
|
}
|
|
|
|
/// A trash card's drag is the restore; dropped back where it came from it writes nothing, so it
|
|
/// never proposes.
|
|
@Test("A trash card dropped back on the trash is refused")
|
|
func theTrashContainerIsRefused() {
|
|
#expect(!accepts(container: .trash))
|
|
#expect(!accepts(container: .trash, isWithinBoard: false))
|
|
}
|
|
|
|
/// "No move or paste ever targets the trash": a foreign card delivered into this board's trash
|
|
/// would be a transfer-and-delete compound, which the design names nowhere.
|
|
@Test("A foreign board's card is refused")
|
|
func crossBoardIsRefused() {
|
|
#expect(!accepts(isWithinBoard: false))
|
|
// Not even with ⌘, which forces the move a cross-board drag would otherwise only copy.
|
|
#expect(!accepts(isWithinBoard: false, operation: .move))
|
|
}
|
|
|
|
/// Copying into the trash is not a thing — and the alternative would be tombstoning an original
|
|
/// the copy grammar had just promised to leave exactly where it was.
|
|
@Test("⌥ is refused rather than reinterpreted")
|
|
func optionCopyIsRefused() {
|
|
#expect(!accepts(operation: .copy))
|
|
}
|
|
|
|
/// "The trash stays undroppable-into while hidden, like every gesture."
|
|
@Test("Hidden, the trash is invisible to the gesture")
|
|
func hiddenIsInert() {
|
|
#expect(!accepts(isTrashShown: false))
|
|
}
|
|
|
|
@Test("The mutating-gesture rule applies, like every other write the pointer can start")
|
|
func theLockAndTheEditorRefuse() {
|
|
#expect(!accepts(acceptsMutations: false))
|
|
}
|
|
}
|
|
|
|
// MARK: - The committed-overlay hold
|
|
|
|
@Suite("CommittedHold")
|
|
struct CommittedHoldTests {
|
|
|
|
private static let here = URL(fileURLWithPath: "/Boards/Work.kanban", isDirectory: true)
|
|
private static let there = URL(fileURLWithPath: "/Boards/Home.kanban", isDirectory: true)
|
|
|
|
private static let hold = CommittedHold(boardRoot: here, generation: 7)
|
|
|
|
@Test("The hold stands until the destination board applies a *newer* snapshot")
|
|
func retiredByTheNextSnapshot() {
|
|
// The generation at the commit is the one already on screen — it is the pre-drop arrangement,
|
|
// and retiring on it would drop the overlay before the write has round-tripped.
|
|
#expect(!Self.hold.isRetired(byRoot: Self.here, generation: 7))
|
|
#expect(Self.hold.isRetired(byRoot: Self.here, generation: 8))
|
|
// *Any* snapshot hands off, not just the app-mediated echo: a foreign one that lands first
|
|
// re-grounds everything anyway.
|
|
#expect(Self.hold.isRetired(byRoot: Self.here, generation: 99))
|
|
}
|
|
|
|
@Test("A reload on another board says nothing about this one")
|
|
func otherBoardsDoNotRetireIt() {
|
|
#expect(!Self.hold.isRetired(byRoot: Self.there, generation: 99))
|
|
}
|
|
|
|
@Test("The board is matched by identity, not by string")
|
|
func rootMatchingUsesTheLocalityComparison() {
|
|
#expect(Self.hold.isRetired(byRoot: URL(fileURLWithPath: "/Boards/./Work.kanban/"), generation: 8))
|
|
}
|
|
|
|
@Test("A stale generation never retires it")
|
|
func staleGenerations() {
|
|
#expect(!Self.hold.isRetired(byRoot: Self.here, generation: 0))
|
|
#expect(!Self.hold.isRetired(byRoot: Self.here, generation: 6))
|
|
}
|
|
|
|
/// The figure 03-board-ui.md fixes for a hold with no echo coming: long enough for a write plus a
|
|
/// watcher round trip, short enough that a refused write does not leave the board drawing an
|
|
/// arrangement it never got.
|
|
@Test("The deadline is the design's own figure")
|
|
func theTimeoutFigure() {
|
|
#expect(CommittedHold.timeout == .milliseconds(1500))
|
|
}
|
|
}
|
|
|
|
// MARK: - The committed-overlay hold, in the session
|
|
|
|
/// **What the session renders between the release and the echo** (DRAG-REORDER.md § The
|
|
/// committed-overlay hold): the write is in flight and the snapshot has not moved, so the session
|
|
/// keeps drawing the arrangement it was showing — the shadows at their landing slots, the originals
|
|
/// lifted out — until the destination store applies its next snapshot, or the deadline says none is
|
|
/// coming. The claims here are the pure state the board's surfaces read (`laneProposal`,
|
|
/// `trashProposal`, `hiddenMembers`), so the whole ruling is checkable without a view.
|
|
///
|
|
/// A **real store over a real temp board**, like the write suites: `commit` names the destination
|
|
/// store, and the session's own re-grounding reads that store's transient state, so a stub would be
|
|
/// standing in for exactly the thing under test. Nothing here writes.
|
|
@MainActor
|
|
@Suite("The committed hold")
|
|
struct DropSettleTests {
|
|
|
|
private static let lane1 = ItemID(rawValue: Ident.lane1)
|
|
private static let card1 = ItemID(rawValue: Ident.card1)
|
|
private static let card2 = ItemID(rawValue: Ident.card2)
|
|
|
|
/// Two cards in the first lane — enough for a run of two, and for one of them to vanish
|
|
/// mid-flight while the other still lands.
|
|
private func makeBoard() throws -> WriterFixture {
|
|
let fixture = try WriterFixture()
|
|
try fixture.item("", Item.board)
|
|
try fixture.item(Ident.lane1, Item.rich(order: "1024", title: "Todo"))
|
|
try fixture.item("\(Ident.lane1)/\(Ident.card1)", Item.rich(order: "1024", title: "First"))
|
|
try fixture.item("\(Ident.lane1)/\(Ident.card2)", Item.rich(order: "2048", title: "Second"))
|
|
try fixture.item(Ident.lane2, Item.rich(order: "2048", title: "Doing"))
|
|
return fixture
|
|
}
|
|
|
|
/// A session mid-drag: `members` picked up out of `lane1`, proposing into it at `index`.
|
|
///
|
|
/// The titles ride along only so the fixtures read as the cards they name — nothing in the
|
|
/// session reads them.
|
|
private func proposing(
|
|
_ store: BoardStore,
|
|
members: [(id: ItemID, title: String?)] = [(card1, "First")],
|
|
at index: Int = 2
|
|
) -> DragSession {
|
|
let session = DragSession()
|
|
pickUp(session, from: store, members: members)
|
|
session.propose(DropTarget(boardRoot: store.rootURL, container: .lane(Self.lane1), index: index))
|
|
return session
|
|
}
|
|
|
|
/// The pickup half, on a session that may already have had a life — the second drag in
|
|
/// `aRetiredHoldsTimeoutIsCancelled` is the whole reason it is separable.
|
|
private func pickUp(
|
|
_ session: DragSession,
|
|
from store: BoardStore,
|
|
members: [(id: ItemID, title: String?)] = [(card1, "First")]
|
|
) {
|
|
session.beginCards(
|
|
members.map(\.id),
|
|
folders: members.map {
|
|
store.rootURL
|
|
.appendingPathComponent(Ident.lane1, isDirectory: true)
|
|
.appendingPathComponent($0.id.rawValue, isDirectory: true)
|
|
},
|
|
heights: members.map { _ in 44 },
|
|
container: .board,
|
|
source: store
|
|
)
|
|
}
|
|
|
|
/// Polls for `condition`, because the timeout's discard is a `Task` on this very actor: the test
|
|
/// has to yield for it to run at all. Bounded, so a discard that never comes fails rather than
|
|
/// hangs.
|
|
private func settles(_ condition: () -> Bool) async -> Bool {
|
|
for _ in 0..<200 {
|
|
if condition() { return true }
|
|
try? await Task.sleep(for: .milliseconds(5))
|
|
}
|
|
return condition()
|
|
}
|
|
|
|
// MARK: In flight
|
|
|
|
@Test("While the drag is in flight the shadow run opens at the proposal and the originals are lifted out")
|
|
func inFlightDrawsShadows() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
|
|
#expect(!session.isSettled)
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == 2)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1])
|
|
}
|
|
|
|
// MARK: The hold
|
|
|
|
/// "The session flips from proposing to committed and keeps rendering the arrangement it was
|
|
/// showing": the write is on its way but the snapshot has not moved, so nothing about the
|
|
/// release may change what is on screen — the shadows stay at their landing slot and the
|
|
/// originals stay lifted out until the echo reload brings the real faces.
|
|
@Test("A committed hold keeps the shadows at their landing slot and the originals lifted out")
|
|
func theHoldKeepsTheArrangement() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
|
|
session.commit(into: store)
|
|
|
|
#expect(session.isSettled)
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == 2)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1])
|
|
}
|
|
|
|
@Test("A settled release is past retargeting: a late callback cannot move or withdraw it")
|
|
func settledProposalsAreFinal() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
session.commit(into: store)
|
|
|
|
session.propose(nil)
|
|
session.propose(DropTarget(boardRoot: store.rootURL, container: .lane(Self.lane1), index: 0))
|
|
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == 2)
|
|
}
|
|
|
|
// MARK: The trash's landing
|
|
|
|
/// A session proposing into the trash column rather than into a lane — the delete gesture
|
|
/// (04-interactions.md ▸ The trash).
|
|
private func proposingIntoTheTrash(_ store: BoardStore, members: [(id: ItemID, title: String?)] = [(card1, "First")]) -> DragSession {
|
|
let session = DragSession()
|
|
pickUp(session, from: store, members: members)
|
|
session.propose(DropTarget(
|
|
boardRoot: store.rootURL,
|
|
container: .trash,
|
|
index: TrashDrop.landingIndex
|
|
))
|
|
return session
|
|
}
|
|
|
|
@Test("The trash's shadow opens at the topmost row, and no lane draws one")
|
|
func trashInFlightDrawsTheTopRow() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposingIntoTheTrash(store)
|
|
|
|
#expect(session.trashProposal(onBoardRooted: store.rootURL) == 0)
|
|
// The proposal names one container and one only: the lane the cards came out of draws
|
|
// nothing, and neither does the strip.
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == nil)
|
|
#expect(session.stripProposal(onBoardRooted: store.rootURL) == nil)
|
|
// And they are lifted out of the lane, as ever.
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1])
|
|
}
|
|
|
|
/// The delete's own hold: the write takes the cards off the live side, and the shadow rows keep
|
|
/// the space they landed in until the echo brings the real tombstones.
|
|
@Test("A committed trash drop keeps its shadow rows on top and the originals lifted")
|
|
func trashHoldKeepsTheRows() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposingIntoTheTrash(store, members: [(Self.card1, "First"), (Self.card2, "Second")])
|
|
|
|
session.commit(into: store)
|
|
|
|
#expect(session.trashProposal(onBoardRooted: store.rootURL) == 0)
|
|
#expect(session.shadowCount == 2)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1, Self.card2])
|
|
}
|
|
|
|
@Test("A lane session never proposes into the trash")
|
|
func laneSessionsHaveNoTrashLanding() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = DragSession()
|
|
session.beginLanes(
|
|
[Self.lane1],
|
|
folders: [store.rootURL.appendingPathComponent(Ident.lane1, isDirectory: true)],
|
|
units: [1],
|
|
source: store
|
|
)
|
|
session.propose(DropTarget(boardRoot: store.rootURL, container: .trash, index: 0))
|
|
|
|
#expect(session.trashProposal(onBoardRooted: store.rootURL) == nil)
|
|
}
|
|
|
|
// MARK: The hand-off
|
|
|
|
@Test("The hand-off clears the hold and the overlay with it — the snapshot is the authority again")
|
|
func handOffClearsEverything() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
session.commit(into: store)
|
|
|
|
session.handOff(root: store.rootURL, generation: store.snapshotGeneration + 1)
|
|
|
|
#expect(!session.isSettled)
|
|
#expect(!session.isActive)
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == nil)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty)
|
|
}
|
|
|
|
@Test("Ending the session outright ends the hold with it")
|
|
func endClearsTheHold() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
session.commit(into: store)
|
|
|
|
session.end()
|
|
|
|
#expect(!session.isSettled)
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == nil)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty)
|
|
#expect(store.transient.dragMembers.ids.isEmpty)
|
|
}
|
|
|
|
// MARK: The timeout — the failed write's path
|
|
|
|
/// "A failed write discards the proposal and the board animates back to snapshot order"
|
|
/// (03-board-ui.md § Motion). A write refused outright produces no reload at all, so the deadline
|
|
/// is the only thing standing between the board and an arrangement it never got.
|
|
@Test("A hold with no echo coming times out, and the board is left with its snapshot order")
|
|
func theTimeoutDiscardsTheHold() async throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
// The seam: the real figure is `CommittedHold.timeout`, and waiting it out would be 1.5 s of
|
|
// wall clock in the suite for a claim about the discard rather than about the clock.
|
|
session.holdTimeout = .milliseconds(20)
|
|
|
|
session.commit(into: store)
|
|
#expect(session.isSettled)
|
|
|
|
#expect(await settles { !session.isSettled }, "the deadline must dissolve an overlay with no hand-off coming")
|
|
#expect(!session.isActive)
|
|
#expect(session.laneProposal(onBoardRooted: store.rootURL, laneID: Self.lane1) == nil)
|
|
#expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty)
|
|
#expect(store.transient.dragMembers.ids.isEmpty)
|
|
}
|
|
|
|
/// The discard's own body, called directly — the half of the timeout that is a decision rather
|
|
/// than a wait, and the guard that makes the wait harmless.
|
|
@Test("The discard ends the hold it was armed for, and no other")
|
|
func theDiscardEndsOnlyItsOwnHold() throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
session.commit(into: store)
|
|
let hold = try #require(session.hold)
|
|
|
|
session.expire(CommittedHold(boardRoot: store.rootURL, generation: 999))
|
|
#expect(session.isSettled, "a hold this session is not holding is not this session's to end")
|
|
|
|
session.expire(hold)
|
|
#expect(!session.isSettled)
|
|
#expect(!session.isActive)
|
|
}
|
|
|
|
@Test("A retired hold's deadline never reaches the next drag")
|
|
func aRetiredHoldsTimeoutIsCancelled() async throws {
|
|
let fixture = try makeBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
let session = proposing(store)
|
|
session.holdTimeout = .milliseconds(20)
|
|
session.commit(into: store)
|
|
|
|
// The echo lands well inside the deadline, and the user starts another drag immediately —
|
|
// the lifecycle trap the watchdog was written for, at the hold's end of the session.
|
|
session.handOff(root: store.rootURL, generation: store.snapshotGeneration + 1)
|
|
pickUp(session, from: store, members: [(Self.card2, "Second")])
|
|
|
|
try? await Task.sleep(for: .milliseconds(80))
|
|
#expect(session.isActive, "the retired hold's deadline must not end the drag that followed it")
|
|
#expect(session.hold == nil)
|
|
}
|
|
}
|