bitchat/bitchatTests/LocationNotesManagerTests.swift
jack 1905ea7cc0
Bound future timestamps on sync replies and in the gossip store (#1717)
Sync replies (RSR) skipped the packet timestamp check, and nothing
downstream bounded future timestamps: the gossip freshness checks,
archive restore and the archived-echo key only handled the past.

- BLEIngressPacketGuard: RSR packets may still be old, but not dated
  beyond now + skew (TransportConfig.bleMaxTimestampSkewMs, 120 s).
- ChatPublicConversationCoordinator.archivedEchoKey is total for any
  Date instead of using a trapping UInt64 conversion.
- GossipSyncManager.isPacketFresh rejects packets dated beyond the same
  skew, which gates every store, sync serving and archive restore;
  restore rewrites the archive when it drops entries.
- BLEAnnounceHandler tracks only verified announces for sync.
- LocationNotesManager clamps note created_at to now.
- LocationNotesManager clamps future note timestamps to the board's
  clock-skew allowance (not to now), so bridged copies of board posts
  still dedupe in UnifiedNotices.merge.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-09-23 19:47:14 +02:00

454 lines
17 KiB
Swift

import Testing
import Combine
import Foundation
@testable import bitchat
@MainActor
struct LocationNotesManagerTests {
@Test
func subscribeWithoutRelays_setsNoRelaysState() {
var subscribeCalled = false
let deps = LocationNotesDependencies(
relayLookup: { _, _ in [] },
subscribe: { _, _, _, _, _ in
subscribeCalled = true
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in try NostrIdentity.generate() },
now: { Date() }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
#expect(subscribeCalled == false)
#expect(manager.state == .noRelays)
#expect(manager.initialLoadComplete)
#expect(manager.errorMessage == String(localized: "location_notes.error.no_relays"))
}
@Test
func noRelays_resubscribesWhenDirectoryRefreshes() async throws {
var relays: [String] = []
var subscribeCount = 0
let directorySubject = PassthroughSubject<Void, Never>()
let deps = LocationNotesDependencies(
relayLookup: { _, _ in relays },
subscribe: { _, _, _, _, _ in
subscribeCount += 1
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in try NostrIdentity.generate() },
now: { Date() },
relayDirectoryUpdates: directorySubject.eraseToAnyPublisher()
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
#expect(manager.state == .noRelays)
#expect(subscribeCount == 0)
// Directory loads later (e.g. remote fetch finished after Tor came up).
relays = ["wss://relay.one"]
directorySubject.send(())
let deadline = Date().addingTimeInterval(1.0)
while manager.state == .noRelays && Date() < deadline {
try await Task.sleep(nanoseconds: 10_000_000)
}
#expect(subscribeCount == 1)
#expect(manager.state == .loading)
#expect(manager.errorMessage == nil)
}
@Test
func sendWithoutRelays_surfacesNoRelaysError() {
var sendCalled = false
let deps = LocationNotesDependencies(
relayLookup: { _, _ in [] },
subscribe: { _, _, _, _, _ in },
unsubscribe: { _ in },
sendEvent: { _, _ in sendCalled = true },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
manager.send(content: "hello", nickname: "tester")
#expect(sendCalled == false)
#expect(manager.state == .noRelays)
#expect(manager.errorMessage == String(localized: "location_notes.error.no_relays"))
}
@Test func subscribeUsesGeoRelaysAndAppendsNotes() throws {
var relaysCaptured: [String] = []
var storedHandler: ((NostrEvent) -> Void)?
var storedEOSE: (() -> Void)?
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { filter, id, relays, handler, eose in
#expect(filter.kinds == [1])
#expect(!id.isEmpty)
relaysCaptured = relays
storedHandler = handler
storedEOSE = eose
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
#expect(relaysCaptured == ["wss://relay.one"])
#expect(manager.state == .loading)
let identity = try NostrIdentity.generate()
let event = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: Date(),
kind: .textNote,
tags: [["g", "u4pruydq"]],
content: "hi"
)
let signed = try event.sign(with: identity.schnorrSigningKey())
storedHandler?(signed)
storedEOSE?()
#expect(manager.state == .ready)
#expect(manager.notes.count == 1)
#expect(manager.notes.first?.content == "hi")
}
@Test
func refreshAndCancel_manageSubscriptions() {
var subscribeIDs: [String] = []
var unsubscribedIDs: [String] = []
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, id, _, _, _ in
subscribeIDs.append(id)
},
unsubscribe: { id in
unsubscribedIDs.append(id)
},
sendEvent: { _, _ in },
deriveIdentity: { _ in try NostrIdentity.generate() },
now: { Date() }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
manager.refresh()
manager.cancel()
#expect(subscribeIDs.count == 2)
#expect(unsubscribedIDs.count == 2)
#expect(manager.state == .idle)
#expect(manager.errorMessage == nil)
}
@Test
func send_successCreatesLocalEchoAndClearsError() throws {
var sentEvents: [NostrEvent] = []
let identity = try NostrIdentity.generate()
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, _ in },
unsubscribe: { _ in },
sendEvent: { event, _ in
sentEvents.append(event)
},
deriveIdentity: { _ in identity },
now: { Date(timeIntervalSince1970: 123_456) }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
manager.send(content: " hello note ", nickname: "Builder")
#expect(sentEvents.count == 1)
#expect(manager.state == .ready)
#expect(manager.errorMessage == nil)
#expect(manager.notes.first?.content == "hello note")
#expect(manager.notes.first?.displayName.hasPrefix("Builder#") == true)
}
@Test
func send_failureFormatsErrorMessageAndClearErrorRemovesIt() {
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, _ in },
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
manager.send(content: "hello", nickname: "Builder")
#expect(manager.errorMessage?.isEmpty == false)
manager.clearError()
#expect(manager.errorMessage == nil)
}
@Test
func ingestDropsExpiredNotesAndKeepsUnexpiredOnes() throws {
var storedHandler: ((NostrEvent) -> Void)?
let now = Date(timeIntervalSince1970: 1_700_000_000)
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, handler, _ in
storedHandler = handler
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { now }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
let identity = try NostrIdentity.generate()
let expired = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: now.addingTimeInterval(-3600),
kind: .textNote,
tags: [["g", "u4pruydq"], ["expiration", String(Int(now.timeIntervalSince1970) - 60)]],
content: "gone"
)
storedHandler?(try expired.sign(with: identity.schnorrSigningKey()))
let live = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: now.addingTimeInterval(-3600),
kind: .textNote,
tags: [["g", "u4pruydq"], ["expiration", String(Int(now.timeIntervalSince1970) + 3600)]],
content: "still here"
)
storedHandler?(try live.sign(with: identity.schnorrSigningKey()))
#expect(manager.notes.count == 1)
#expect(manager.notes.first?.content == "still here")
#expect(manager.notes.first?.expiresAt == Date(timeIntervalSince1970: TimeInterval(Int(now.timeIntervalSince1970) + 3600)))
}
/// created_at is author-chosen: a note dated 2100 used to sort above
/// every real note forever and survive the newest-first memory cap.
@Test
func ingestClampsFutureDatedNotesToTheBoardSkew() throws {
var storedHandler: ((NostrEvent) -> Void)?
let start = Date(timeIntervalSince1970: 1_700_000_000)
var currentNow = start
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, handler, _ in
storedHandler = handler
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { currentNow }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
let identity = try NostrIdentity.generate()
let skew = TimeInterval(BoardStore.Limits.clockSkewMs) / 1000
// Within the board's skew allowance the author's timestamp is kept,
// so a bridged copy of a board post still dedupes against the post.
let slightlyAhead = start.addingTimeInterval(30 * 60)
let bridged = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: slightlyAhead,
kind: .textNote,
tags: [["g", "u4pruydq"]],
content: "bridged"
)
storedHandler?(try bridged.sign(with: identity.schnorrSigningKey()))
#expect(manager.notes.first(where: { $0.content == "bridged" })?.createdAt == slightlyAhead)
// Far-future timestamps are clamped to the edge of that allowance.
let futureDated = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: Date(timeIntervalSince1970: 4_102_444_800), // 2100-01-01
kind: .textNote,
tags: [["g", "u4pruydq"]],
content: "pinned"
)
storedHandler?(try futureDated.sign(with: identity.schnorrSigningKey()))
#expect(manager.notes.first(where: { $0.content == "pinned" })?.createdAt == start.addingTimeInterval(skew))
// Once local time passes that edge, newer notes sort above it.
currentNow = start.addingTimeInterval(skew + 120)
let later = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: start.addingTimeInterval(skew + 60),
kind: .textNote,
tags: [["g", "u4pruydq"]],
content: "later"
)
storedHandler?(try later.sign(with: identity.schnorrSigningKey()))
#expect(manager.notes.map(\.content) == ["later", "pinned", "bridged"])
}
@Test
func postDrop_sendsExpiringNoteToGeoRelays() throws {
var sentEvents: [NostrEvent] = []
let now = Date(timeIntervalSince1970: 1_700_000_000)
let identity = try NostrIdentity.generate()
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, _ in },
unsubscribe: { _ in },
sendEvent: { event, _ in sentEvents.append(event) },
deriveIdentity: { _ in identity },
now: { now }
)
let posted = LocationNotesManager.postDrop(
content: " the coffee here is great ",
nickname: "scout",
geohash: "u4pruydq",
dependencies: deps
)
#expect(posted)
#expect(sentEvents.count == 1)
let event = try #require(sentEvents.first)
#expect(event.kind == NostrProtocol.EventKind.textNote.rawValue)
#expect(event.content == "the coffee here is great")
#expect(event.tags.contains(["g", "u4pruydq"]))
let expiration = event.tags.first { $0.first == "expiration" }?.last
let expected = Int(now.addingTimeInterval(TransportConfig.locationDropExpirySeconds).timeIntervalSince1970)
#expect(expiration == String(expected))
}
@Test
func postDrop_failsWithoutRelays() {
let deps = LocationNotesDependencies(
relayLookup: { _, _ in [] },
subscribe: { _, _, _, _, _ in },
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
#expect(!LocationNotesManager.postDrop(content: "hi", nickname: "x", geohash: "u4pruydq", dependencies: deps))
}
@Test
func pruneExpiredNotes_dropsNotesWhoseExpiryPassed() throws {
var storedHandler: ((NostrEvent) -> Void)?
var currentNow = Date(timeIntervalSince1970: 1_700_000_000)
let deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, handler, _ in
storedHandler = handler
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { currentNow }
)
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
let identity = try NostrIdentity.generate()
let note = NostrEvent(
pubkey: identity.publicKeyHex,
createdAt: currentNow,
kind: .textNote,
tags: [["g", "u4pruydq"], ["expiration", String(Int(currentNow.timeIntervalSince1970) + 60)]],
content: "short lived"
)
storedHandler?(try note.sign(with: identity.schnorrSigningKey()))
#expect(manager.notes.count == 1)
currentNow = currentNow.addingTimeInterval(120)
manager.pruneExpiredNotes()
#expect(manager.notes.isEmpty)
}
@Test
func eoseWithoutConnectedRelays_showsConnectingInsteadOfEmpty() {
var storedEOSE: (() -> Void)?
var deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, eose in storedEOSE = eose },
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
deps.anyRelayConnected = { _ in false }
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
storedEOSE?()
#expect(manager.state == .connecting)
#expect(manager.initialLoadComplete)
}
@Test
func eoseWithConnectedRelayAndNoNotes_isReadyEmpty() {
var storedEOSE: (() -> Void)?
var deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, eose in storedEOSE = eose },
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
deps.anyRelayConnected = { _ in true }
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
storedEOSE?()
#expect(manager.state == .ready)
}
@Test
func connectingState_retriesOnceARelayComesUp() {
var storedEOSE: (() -> Void)?
var subscribeCount = 0
var relayUp = false
var deps = LocationNotesDependencies(
relayLookup: { _, _ in ["wss://relay.one"] },
subscribe: { _, _, _, _, eose in
subscribeCount += 1
storedEOSE = eose
},
unsubscribe: { _ in },
sendEvent: { _, _ in },
deriveIdentity: { _ in throw TestError.shouldNotDerive },
now: { Date() }
)
deps.anyRelayConnected = { _ in relayUp }
let manager = LocationNotesManager(geohash: "u4pruydq", dependencies: deps)
#expect(subscribeCount == 1)
storedEOSE?()
#expect(manager.state == .connecting)
// Relay still down: no retry.
manager.retryIfRelaysAvailable(relays: ["wss://relay.one"])
#expect(subscribeCount == 1)
// Relay up: re-subscribes for a fresh initial fetch.
relayUp = true
manager.retryIfRelaysAvailable(relays: ["wss://relay.one"])
#expect(subscribeCount == 2)
#expect(manager.state == .loading)
}
private enum TestError: Error {
case shouldNotDerive
}
}