crossmate

TimeLogTests.swift (10028B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("TimeLog union accumulation")
 struct TimeLogTests {
 
     /// Reference instant; offsets are seconds from here for readability.
     private let t0 = Date(timeIntervalSinceReferenceDate: 100_000)
     private func at(_ seconds: TimeInterval) -> Date { t0.addingTimeInterval(seconds) }
 
     /// A log holding a single device's sealed intervals, given as (start, end)
     /// second-offsets.
     private func sealed(_ device: String, _ spans: [(TimeInterval, TimeInterval)]) -> TimeLog {
         let intervals = spans.map { TimeLog.Interval(start: at($0.0), end: at($0.1)) }
         return TimeLog(devices: [device: .init(intervals: intervals)])
     }
 
     // MARK: - Solo, single device
 
     @Test("Open then seal accumulates the elapsed span")
     func openSealAccumulates() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         log.seal(deviceID: "alice-phone", at: at(120))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(200)
         )
         #expect(total == 120)
     }
 
     @Test("Reopening after a sealed session adds the second span")
     func reopenAdds() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         log.seal(deviceID: "alice-phone", at: at(60))
         log.open(deviceID: "alice-phone", at: at(300))
         log.seal(deviceID: "alice-phone", at: at(330))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(400)
         )
         #expect(total == 90)
     }
 
     @Test("A re-open while already open is idempotent — the first start wins")
     func reopenWhileOpenIdempotent() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         log.open(deviceID: "alice-phone", at: at(50)) // renewal, not a new session
         log.seal(deviceID: "alice-phone", at: at(120))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(200)
         )
         #expect(total == 120)
     }
 
     // MARK: - Multi-device, same author
 
     @Test("Disjoint sessions on two of one account's devices sum")
     func multiDeviceDisjointSums() {
         let phone = sealed("alice-phone", [(0, 100)])
         let pad = sealed("alice-pad", [(200, 250)])
         // Both slots live on the same author's record in practice; modelled as one
         // log with two device keys.
         let log = TimeLog(devices: phone.devices.merging(pad.devices) { a, _ in a })
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(300)
         )
         #expect(total == 150)
     }
 
     @Test("Overlapping sessions on two devices collapse to the union, not the sum")
     func multiDeviceOverlapDedups() {
         let log = TimeLog(devices: [
             "alice-phone": .init(intervals: [.init(start: at(0), end: at(100))]),
             "alice-pad": .init(intervals: [.init(start: at(60), end: at(160))]),
         ])
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(300)
         )
         // Union [0,160] = 160, not 100 + 100 = 200.
         #expect(total == 160)
     }
 
     // MARK: - Multiplayer
 
     @Test("Simultaneous co-solving is counted once")
     func multiplayerSimultaneousCountedOnce() {
         let alice = sealed("alice-phone", [(0, 600)])
         let bob = sealed("bob-phone", [(0, 600)])
         let total = TimeLog.accumulatedSeconds(
             forLogs: [alice, bob], localDeviceID: "carol-phone", asOf: at(1000)
         )
         #expect(total == 600)
     }
 
     @Test("A handoff between players sums the disjoint spans")
     func multiplayerHandoffSums() {
         let alice = sealed("alice-phone", [(0, 600)])
         let bob = sealed("bob-phone", [(1200, 1500)])
         let total = TimeLog.accumulatedSeconds(
             forLogs: [alice, bob], localDeviceID: "carol-phone", asOf: at(2000)
         )
         #expect(total == 900)
     }
 
     @Test("Partial overlap across players counts the union span")
     func multiplayerPartialOverlap() {
         let alice = sealed("alice-phone", [(0, 100)])
         let bob = sealed("bob-phone", [(80, 200)])
         let carol = sealed("carol-phone", [(300, 350)])
         let total = TimeLog.accumulatedSeconds(
             forLogs: [alice, bob, carol], localDeviceID: "alice-phone", asOf: at(400)
         )
         // Union [0,200] (=200) + [300,350] (=50) = 250.
         #expect(total == 250)
     }
 
     // MARK: - Live / in-progress sessions
 
     @Test("The local device's open session is trusted live to now")
     func localOpenExtrapolatesToNow() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(45)
         )
         #expect(total == 45)
     }
 
     @Test("A peer's open session extrapolates only to its last beat plus grace")
     func peerOpenBoundedByBeat() {
         var bob = TimeLog()
         bob.open(deviceID: "bob-phone", at: at(0))
         bob.beat(deviceID: "bob-phone", at: at(100)) // last heartbeat at 100
         // We (alice) read it far in the future; bob never sealed.
         let total = TimeLog.accumulatedSeconds(
             forLogs: [bob], localDeviceID: "alice-phone", asOf: at(10_000)
         )
         // Capped at beat(100) + grace(180) = 280.
         #expect(total == 100 + TimeLog.openGrace)
     }
 
     @Test("A never-sealed local session is capped at maxSessionCap")
     func localOpenCappedBySessionCap() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone",
             asOf: at(TimeLog.maxSessionCap + 10_000)
         )
         #expect(total == TimeLog.maxSessionCap)
     }
 
     @Test("A heartbeat with no open session is a no-op (no bare slot)")
     func beatWithoutOpenIsNoOp() {
         var log = TimeLog()
         log.beat(deviceID: "alice-phone", at: at(0))
         #expect(log.devices.isEmpty)
         // After sealing, a later beat must not resurrect an open session.
         log.open(deviceID: "alice-phone", at: at(10))
         log.seal(deviceID: "alice-phone", at: at(20))
         log.beat(deviceID: "alice-phone", at: at(30))
         #expect(log.devices["alice-phone"]?.openStart == nil)
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(100)
         )
         #expect(total == 10)
     }
 
     @Test("A crashed session is banked bounded on the next launch's first open")
     func staleSessionReconciledOnReopen() {
         var log = TimeLog()
         // Sitting one: opened at 0, last heartbeat at 100, then force-quit — never
         // sealed, so `openStart` persists.
         log.open(deviceID: "alice-phone", at: at(0))
         log.beat(deviceID: "alice-phone", at: at(100))
         // A long time later, the first open since launch reconciles it.
         log.open(deviceID: "alice-phone", at: at(200_000), reconcileStale: true)
         log.seal(deviceID: "alice-phone", at: at(200_060))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(300_000)
         )
         // Crashed sitting banks bounded at beat(100) + grace, NOT the dead gap to
         // 200_000; plus the fresh 60s sitting.
         #expect(total == 100 + TimeLog.openGrace + 60)
     }
 
     @Test("A resume (not reconciled) keeps one continuous session, no split")
     func resumeKeepsContinuousSession() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         // An in-run `.active` re-fire (e.g. Control Center) — reconcileStale stays
         // false, so the sitting is not split.
         log.open(deviceID: "alice-phone", at: at(600))
         log.seal(deviceID: "alice-phone", at: at(900))
         let total = TimeLog.accumulatedSeconds(
             forLogs: [log], localDeviceID: "alice-phone", asOf: at(1000)
         )
         #expect(total == 900)
     }
 
     // MARK: - Merge discipline
 
     @Test("Merging an inbound copy preserves the local device's own open slot")
     func mergePreservesLocalSlot() {
         // Local state: my phone has a live open session.
         var local = TimeLog()
         local.open(deviceID: "alice-phone", at: at(500))
         // Inbound sibling copy: a stale view of my phone (closed) plus my pad's work.
         let inbound = TimeLog(devices: [
             "alice-phone": .init(intervals: [.init(start: at(0), end: at(50))]),
             "alice-pad": .init(intervals: [.init(start: at(100), end: at(200))]),
         ])
         local.merge(inbound: inbound, preservingDevice: "alice-phone")
         // My phone's live open session is kept; the pad slot is adopted; the stale
         // phone history from the sibling is discarded in favour of my own slot.
         #expect(local.devices["alice-phone"]?.openStart == at(500))
         #expect(local.devices["alice-pad"]?.intervals.count == 1)
     }
 
     // MARK: - Codec tolerance
 
     @Test("Decoding nil or empty data yields an empty log")
     func decodeToleratesEmpty() {
         #expect(TimeLog.decode(nil).devices.isEmpty)
         #expect(TimeLog.decode(Data()).devices.isEmpty)
     }
 
     @Test("Encode then decode round-trips")
     func codecRoundTrips() {
         var log = TimeLog()
         log.open(deviceID: "alice-phone", at: at(0))
         log.seal(deviceID: "alice-phone", at: at(120))
         let restored = TimeLog.decode(TimeLog.encode(log))
         #expect(restored == log)
     }
 
     @Test("An empty game has a zero clock")
     func emptyIsZero() {
         #expect(TimeLog.accumulatedSeconds(forLogs: [], localDeviceID: "x") == 0)
         #expect(TimeLog.accumulatedSeconds(forLogs: [TimeLog()], localDeviceID: "x") == 0)
     }
 }