crossmate

SessionPushPlannerTests.swift (16156B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("Session push planner")
 struct SessionPushPlannerTests {
     /// One journal entry. `seq` orders entries within a cell; `kind` and
     /// `batch` drive the gesture tallies.
     private func entry(
         _ letter: String,
         at timestamp: Date,
         seq: Int64,
         row: Int = 0,
         col: Int = 0,
         kind: JournalKind = .input,
         batch: UUID? = nil,
         cellAuthorID: String = "author"
     ) -> JournalValue {
         JournalValue(
             seq: seq,
             timestamp: timestamp,
             position: GridPosition(row: row, col: col),
             state: JournalCellState(letter: letter, mark: .none, cellAuthorID: cellAuthorID),
             actingAuthorID: "author",
             kind: kind,
             targetSeq: nil,
             batchID: batch,
             prevSeqAtCell: nil,
             direction: nil
         )
     }
 
     private func recipient(
         _ address: String?,
         readThrough: Date?,
         notifiedThrough: Date? = nil
     ) -> PushRecipient {
         PushRecipient(
             authorID: "peer",
             readThrough: readThrough,
             notifiedThrough: notifiedThrough,
             pushAddress: address
         )
     }
 
     @Test("A caught-up recipient is dropped — a session end is no longer a presence ping")
     func caughtUpRecipientDropped() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [
             entry("X", at: edit, seq: 1, col: 0),
             entry("", at: edit, seq: 2, col: 1)
         ]
         let seenEverything = recipient("addr-1", readThrough: edit.addingTimeInterval(60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [seenEverything],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         // Nothing the recipient hasn't seen, so no push goes out at all — the
         // begin push that used to carry presence is gone.
         #expect(addressees.isEmpty)
     }
 
     @Test("A behind recipient gets net fills/clears and a badge-marking payload")
     func behindRecipientCounts() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [
             // (0,0): empty → "X" after the cutoff = one fill.
             entry("X", at: edit, seq: 2, col: 0),
             // (0,1): "Y" seen before the cutoff, then emptied after = one clear.
             entry("Y", at: edit.addingTimeInterval(-120), seq: 1, col: 1),
             entry("", at: edit, seq: 3, col: 1)
         ]
         let behind = recipient("addr-2", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.count == 1)
         #expect(addressees[0].payload
             == PushPayload(event: .pause(fills: 1, clears: 1, checks: 0, reveals: 0), playerName: "Alice"))
         #expect(addressees[0].payload?.marksUnread == true)
         #expect(addressees[0].body
             == "Alice filled 1 letter and cleared 1 letter in the puzzle 'Tuesday'")
     }
 
     @Test("A move already notified isn't re-counted, even if the recipient never read it")
     func notifiedThroughWindowsOutPriorMoves() {
         // The bounce case: the recipient stayed backgrounded (readThrough stuck far
         // in the past), but we already paused to them once covering `edit`. The
         // second pause must not re-report that fill — it tallies to zero, so the
         // recipient is dropped entirely rather than getting a duplicate summary.
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [entry("X", at: edit, seq: 1, col: 0)]
         let staleReadAt = edit.addingTimeInterval(-3_600)
 
         // First pause (never notified): the fill is news to the recipient.
         let firstPause = SessionPushPlanner.sessionEndAddressees(
             recipients: [recipient("addr", readThrough: staleReadAt)],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
         #expect(firstPause[0].payload
             == PushPayload(event: .pause(fills: 1, clears: 0, checks: 0, reveals: 0), playerName: "Alice"))
 
         // Second pause after a bounce with no new move: readThrough is still stale,
         // but the watermark already covers `edit`, so nothing is re-reported.
         let secondPause = SessionPushPlanner.sessionEndAddressees(
             recipients: [recipient("addr", readThrough: staleReadAt, notifiedThrough: edit)],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
         #expect(secondPause.isEmpty)
     }
 
     @Test("A present-but-backgrounded recipient still gets a summary (lease ≠ watermark)")
     func presenceLeaseDoesNotSuppressSummary() {
         // Regression for the "moves via banner, no push" bug. The recipient held
         // a *presence lease* dated into the future (they were "present"), then
         // backgrounded before our edit. Their read *watermark* (`readThrough`)
         // is what the planner sees, and it sits before the edit — so the fill is
         // still news and must be summarised. The forward-dated lease is no
         // longer an input here, which is the whole point of the split.
         let edit = Date(timeIntervalSince1970: 10_000)
         let entries = [entry("X", at: edit, seq: 1, col: 0)]
         // Watermark from when they last actually looked, well before the edit.
         let watermarkBeforeEdit = edit.addingTimeInterval(-600)
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [recipient("addr", readThrough: watermarkBeforeEdit)],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.count == 1)
         #expect(addressees[0].payload
             == PushPayload(event: .pause(fills: 1, clears: 0, checks: 0, reveals: 0), playerName: "Alice"))
         #expect(addressees[0].body == "Alice filled 1 letter in the puzzle 'Tuesday'")
     }
 
     @Test("A check-only session reaches no one — checks aren't letter changes")
     func checkOnlySessionDropped() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let batch = UUID()
         // Two letters typed before the cutoff, then one check gesture marks both.
         // The mark change re-stamps each cell but leaves the letters intact, so
         // there is no unseen letter change to report.
         let entries = [
             entry("A", at: edit.addingTimeInterval(-120), seq: 1, col: 0),
             entry("B", at: edit.addingTimeInterval(-120), seq: 2, col: 1),
             entry("A", at: edit, seq: 3, col: 0, kind: .check, batch: batch),
             entry("B", at: edit, seq: 4, col: 1, kind: .check, batch: batch)
         ]
         let behind = recipient("addr-check", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.isEmpty)
     }
 
     @Test("Checking a peer's letter is never a fill, so a peer-check session reaches no one")
     func checkingPeerLetterIsNotAFill() {
         // Regression: a peer filled these cells; in *this* author's journal they
         // appear only as check entries that carry the peer's letter but preserve
         // the peer's `cellAuthorID`. The whole-grid check of an already-filled
         // puzzle must not read as a wall of phantom fills — with no genuine
         // letter change, no push goes out.
         let edit = Date(timeIntervalSince1970: 1_000)
         let batch = UUID()
         let entries = [
             entry("P", at: edit, seq: 1, col: 0, kind: .check, batch: batch, cellAuthorID: "peer"),
             entry("Q", at: edit, seq: 2, col: 1, kind: .check, batch: batch, cellAuthorID: "peer")
         ]
         let behind = recipient("addr-peercheck", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.isEmpty)
     }
 
     @Test("Filling then checking one's own cell still counts as a fill")
     func checkingOwnFillStillCounts() {
         // The flip side of the peer-check fix: a cell this author filled in the
         // window and then checked (inking a pencil entry) keeps `cellAuthorID`
         // as theirs, so it must not be dropped from the fill count.
         let edit = Date(timeIntervalSince1970: 1_000)
         let batch = UUID()
         let entries = [
             entry("A", at: edit, seq: 1, col: 0),
             entry("A", at: edit.addingTimeInterval(1), seq: 2, col: 0, kind: .check, batch: batch)
         ]
         let behind = recipient("addr-owncheck", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees[0].payload
             == PushPayload(event: .pause(fills: 1, clears: 0, checks: 1, reveals: 0), playerName: "Alice"))
         #expect(addressees[0].body
             == "Alice filled 1 letter and ran 1 check in the puzzle 'Tuesday'")
     }
 
     @Test("A reveal is attributed to reveals, never counted as a fill")
     func revealGestureCounted() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let batch = UUID()
         let entries = [
             entry("Z", at: edit, seq: 1, col: 0, kind: .reveal, batch: batch),
             entry("Q", at: edit, seq: 2, col: 1, kind: .reveal, batch: batch)
         ]
         let behind = recipient("addr-reveal", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees[0].payload
             == PushPayload(event: .pause(fills: 0, clears: 0, checks: 0, reveals: 1), playerName: "Alice"))
         #expect(addressees[0].body == "Alice ran 1 reveal in the puzzle 'Tuesday'")
     }
 
     @Test("All four tallies combine into one sentence")
     func mixedGestures() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let before = edit.addingTimeInterval(-120)
         let checkBatch = UUID()
         let revealBatch = UUID()
         let entries = [
             // fill
             entry("A", at: edit, seq: 10, col: 0),
             // clear (seen filled before the cutoff)
             entry("B", at: before, seq: 1, col: 1),
             entry("", at: edit, seq: 11, col: 1),
             // check (seen filled before the cutoff)
             entry("C", at: before, seq: 2, col: 2),
             entry("C", at: edit, seq: 12, col: 2, kind: .check, batch: checkBatch),
             // reveal
             entry("D", at: edit, seq: 13, col: 3, kind: .reveal, batch: revealBatch)
         ]
         let behind = recipient("addr-mixed", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees[0].payload
             == PushPayload(event: .pause(fills: 1, clears: 1, checks: 1, reveals: 1), playerName: "Alice"))
         #expect(addressees[0].body
             == "Alice filled 1 letter, cleared 1 letter and ran 1 check and 1 reveal in the puzzle 'Tuesday'")
     }
 
     @Test("A cell typed then deleted within the window nets to nothing, so no push goes out")
     func netPerCellIgnoresTypeThenDelete() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [
             entry("A", at: edit, seq: 1, col: 0),
             entry("", at: edit.addingTimeInterval(1), seq: 2, col: 0)
         ]
         let behind = recipient("addr-noop", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.isEmpty)
     }
 
     @Test("Diagnostics ride each recipient's payload, stamped with that recipient's readThrough")
     func diagnosticsStampedPerRecipient() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [entry("X", at: edit, seq: 1, col: 0)]
         let aReadAt = edit.addingTimeInterval(-60)
         let recipientA = recipient("addr-a", readThrough: aReadAt)
         let recipientB = recipient("addr-b", readThrough: nil)
         let base = PushPayload.Diagnostics(
             gridWidth: 15,
             gridHeight: 15,
             mergedCells: 200
         )
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [recipientA, recipientB],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday",
             diagnostics: base
         )
 
         let byAddress = Dictionary(uniqueKeysWithValues: addressees.map { ($0.address, $0) })
         let diagnosticsA = byAddress["addr-a"]?.payload?.diagnostics
         #expect(diagnosticsA?.recipientReadAt == aReadAt)
         #expect(diagnosticsA?.gridWidth == 15)
         #expect(diagnosticsA?.mergedCells == 200)
         // A recipient with no cursor keeps recipientReadAt nil — itself
         // diagnostic, since the count then covered the whole history.
         let diagnosticsB = byAddress["addr-b"]?.payload?.diagnostics
         #expect(diagnosticsB?.recipientReadAt == nil)
         #expect(diagnosticsB?.gridWidth == 15)
     }
 
     @Test("Recipients without a push capability are dropped")
     func unaddressableDropped() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [recipient(nil, readThrough: nil)],
             journalEntries: [entry("X", at: edit, seq: 1, col: 0)],
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         #expect(addressees.isEmpty)
     }
 
     @Test("Only the behind recipient is addressed; the caught-up one is dropped")
     func behindAddressedCaughtUpDropped() {
         let edit = Date(timeIntervalSince1970: 1_000)
         let entries = [entry("X", at: edit, seq: 1, col: 0)]
         let caughtUp = recipient("addr-caught-up", readThrough: edit.addingTimeInterval(60))
         let behind = recipient("addr-behind", readThrough: edit.addingTimeInterval(-60))
 
         let addressees = SessionPushPlanner.sessionEndAddressees(
             recipients: [caughtUp, behind],
             journalEntries: entries,
             selfAuthorID: "author",
             playerName: "Alice",
             puzzleTitle: "Tuesday"
         )
 
         let byAddress = Dictionary(uniqueKeysWithValues: addressees.map { ($0.address, $0) })
         #expect(addressees.count == 1)
         #expect(byAddress["addr-caught-up"] == nil)
         #expect(byAddress["addr-behind"]?.payload?.marksUnread == true)
     }
 }