mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-11-22 08:17:28 +00:00
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>
454 lines
17 KiB
Swift
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
|
|
}
|
|
}
|