бейдж упоминаний в чат-листе, прямая навигация по @mention, тап на аватарку → профиль, RequestChats на UIKit

RosettaTests/SlidingWindowTests.swift

@@ -0,0 +1,315 @@
+import XCTest
+@testable import Rosetta
+
+/// Tests for MessageRepository sliding window: soft cache limits, bidirectional pagination,
+/// and batch re-decryption. Ensures cache doesn't grow unbounded during scroll and that
+/// pagination trim removes messages from the correct edge.
+@MainActor
+final class SlidingWindowTests: XCTestCase {
+    private var ctx: DBTestContext!
+    private let opponent = "02peer_sliding_window_test"
+
+    override func setUpWithError() throws {
+        ctx = DBTestContext()
+    }
+
+    override func tearDownWithError() throws {
+        ctx.teardown()
+        ctx = nil
+    }
+
+    // MARK: - Helpers
+
+    /// Inserts `count` incoming messages with sequential timestamps into DB + cache.
+    private func insertMessages(count: Int, startTimestamp: Int64 = 1000) async throws {
+        try await ctx.bootstrap()
+
+        var events: [FixtureEvent] = []
+        for i in 0..<count {
+            events.append(.incoming(
+                opponent: opponent,
+                messageId: "msg-\(String(format: "%04d", i))",
+                timestamp: startTimestamp + Int64(i),
+                text: "Message \(i)"
+            ))
+        }
+        try await ctx.runScenario(FixtureScenario(name: "bulk insert", events: events))
+    }
+
+    // MARK: - maxCacheSize Sanity
+
+    /// Verify that maxCacheSize is 200 (Telegram parity).
+    func testMaxCacheSizeIs200() {
+        XCTAssertEqual(MessageRepository.maxCacheSize, 200)
+    }
+
+    /// Verify that pageSize is 50 (Android parity).
+    func testPageSizeIs50() {
+        XCTAssertEqual(MessageRepository.pageSize, 50)
+    }
+
+    // MARK: - Initial Load
+
+    /// Initial cache load uses pageSize (50), not maxCacheSize (200).
+    /// After async initial load optimization, messages(for:) returns [] on cache miss
+    /// and triggers background decryption. Wait for Combine emission.
+    func testInitialLoadUsesPageSize() async throws {
+        try await insertMessages(count: 100)
+
+        // Clear cache, force reload
+        MessageRepository.shared.reset()
+        try await ctx.bootstrap()
+
+        // Trigger async initial load
+        let _ = MessageRepository.shared.messages(for: opponent)
+
+        // Wait for background decrypt to complete and update cache
+        for _ in 0..<20 {
+            try? await Task.sleep(for: .milliseconds(50))
+            let cached = MessageRepository.shared.messages(for: opponent)
+            if !cached.isEmpty {
+                XCTAssertEqual(cached.count, MessageRepository.pageSize,
+                    "Initial load must use pageSize (\(MessageRepository.pageSize)), got \(cached.count)")
+                return
+            }
+        }
+        XCTFail("Async initial load did not complete within 1 second")
+    }
+
+    // MARK: - loadOlderMessages Soft Trim
+
+    /// When cache exceeds 3× maxCacheSize via loadOlderMessages,
+    /// newest messages are trimmed to 2× maxCacheSize.
+    func testLoadOlderTrimsCacheWhenExceeding3xMax() async throws {
+        // Insert enough messages to trigger soft trim
+        // We need > 3 * 200 = 600 messages in cache
+        let totalMessages = 700
+        try await insertMessages(count: totalMessages)
+
+        // Reset and reload latest 200
+        MessageRepository.shared.reloadLatest(for: opponent)
+        let initial = MessageRepository.shared.messages(for: opponent)
+        XCTAssertEqual(initial.count, MessageRepository.maxCacheSize)
+
+        // Paginate up multiple times to grow cache beyond 3× maxCacheSize
+        var loadCount = 0
+        while loadCount < 15 {
+            guard let earliest = MessageRepository.shared.messages(for: opponent).first else { break }
+            let older = MessageRepository.shared.loadOlderMessages(
+                for: opponent,
+                beforeTimestamp: earliest.timestamp,
+                beforeMessageId: earliest.id,
+                limit: MessageRepository.pageSize
+            )
+            if older.isEmpty { break }
+            loadCount += 1
+        }
+
+        let finalCache = MessageRepository.shared.messages(for: opponent)
+        let hardLimit = MessageRepository.maxCacheSize * 3
+
+        XCTAssertLessThanOrEqual(finalCache.count, hardLimit,
+            "Cache must not exceed 3× maxCacheSize (\(hardLimit)), got \(finalCache.count)")
+    }
+
+    /// loadOlderMessages does NOT trim when cache is within 3× maxCacheSize.
+    func testLoadOlderDoesNotTrimBelowThreshold() async throws {
+        try await insertMessages(count: 300)
+
+        // Load initial 200
+        MessageRepository.shared.reloadLatest(for: opponent)
+
+        // One pagination = +50, total ~250 (below 600 threshold)
+        guard let earliest = MessageRepository.shared.messages(for: opponent).first else {
+            XCTFail("No messages")
+            return
+        }
+        let older = MessageRepository.shared.loadOlderMessages(
+            for: opponent,
+            beforeTimestamp: earliest.timestamp,
+            beforeMessageId: earliest.id,
+            limit: MessageRepository.pageSize
+        )
+
+        let cached = MessageRepository.shared.messages(for: opponent)
+        // 200 + 50 = 250 (no dedup issues since IDs are unique)
+        // Some may be deduped, but should be > 200
+        XCTAssertGreaterThan(cached.count, MessageRepository.maxCacheSize,
+            "Cache should grow beyond maxCacheSize during pagination")
+        XCTAssertLessThanOrEqual(cached.count, MessageRepository.maxCacheSize * 3,
+            "Cache should stay below soft limit")
+    }
+
+    // MARK: - loadNewerMessages Soft Trim
+
+    /// When cache exceeds 3× maxCacheSize via loadNewerMessages,
+    /// oldest messages are trimmed to 2× maxCacheSize.
+    func testLoadNewerTrimsCacheWhenExceeding3xMax() async throws {
+        let totalMessages = 700
+        try await insertMessages(count: totalMessages)
+
+        // Load oldest 200 (simulate user scrolled all the way up)
+        // We'll manually load from the beginning
+        MessageRepository.shared.reloadLatest(for: opponent)
+
+        // Paginate up to load oldest messages first
+        for _ in 0..<12 {
+            guard let earliest = MessageRepository.shared.messages(for: opponent).first else { break }
+            let older = MessageRepository.shared.loadOlderMessages(
+                for: opponent,
+                beforeTimestamp: earliest.timestamp,
+                beforeMessageId: earliest.id,
+                limit: MessageRepository.pageSize
+            )
+            if older.isEmpty { break }
+        }
+
+        // Now paginate DOWN (loadNewerMessages) to grow cache from the other direction
+        for _ in 0..<15 {
+            guard let latest = MessageRepository.shared.messages(for: opponent).last else { break }
+            let newer = MessageRepository.shared.loadNewerMessages(
+                for: opponent,
+                afterTimestamp: latest.timestamp,
+                afterMessageId: latest.id,
+                limit: MessageRepository.pageSize
+            )
+            if newer.isEmpty { break }
+        }
+
+        let finalCache = MessageRepository.shared.messages(for: opponent)
+        let hardLimit = MessageRepository.maxCacheSize * 3
+
+        XCTAssertLessThanOrEqual(finalCache.count, hardLimit,
+            "Cache must not exceed 3× maxCacheSize (\(hardLimit)) after bidirectional pagination, got \(finalCache.count)")
+    }
+
+    // MARK: - reloadLatest Resets Cache
+
+    /// reloadLatest must reset cache to exactly maxCacheSize.
+    func testReloadLatestResetsCacheSize() async throws {
+        try await insertMessages(count: 300)
+
+        // reloadLatest loads maxCacheSize (200) messages
+        MessageRepository.shared.reloadLatest(for: opponent)
+        let initial = MessageRepository.shared.messages(for: opponent)
+        XCTAssertEqual(initial.count, MessageRepository.maxCacheSize,
+            "reloadLatest must load exactly maxCacheSize messages")
+
+        // Paginate up to grow cache beyond maxCacheSize
+        for _ in 0..<3 {
+            guard let earliest = MessageRepository.shared.messages(for: opponent).first else { break }
+            let _ = MessageRepository.shared.loadOlderMessages(
+                for: opponent,
+                beforeTimestamp: earliest.timestamp,
+                beforeMessageId: earliest.id,
+                limit: MessageRepository.pageSize
+            )
+        }
+
+        let beforeReload = MessageRepository.shared.messages(for: opponent).count
+        XCTAssertGreaterThan(beforeReload, MessageRepository.maxCacheSize,
+            "Cache should have grown via pagination, got \(beforeReload)")
+
+        // Jump to bottom = reloadLatest resets cache
+        MessageRepository.shared.reloadLatest(for: opponent)
+
+        let afterReload = MessageRepository.shared.messages(for: opponent).count
+        XCTAssertEqual(afterReload, MessageRepository.maxCacheSize,
+            "reloadLatest must reset cache to maxCacheSize (\(MessageRepository.maxCacheSize)), got \(afterReload)")
+    }
+
+    // MARK: - Message Order Preserved
+
+    /// Messages must stay sorted by timestamp ASC after pagination trim.
+    func testMessageOrderPreservedAfterTrim() async throws {
+        try await insertMessages(count: 700)
+
+        MessageRepository.shared.reloadLatest(for: opponent)
+
+        // Paginate up to trigger trim
+        for _ in 0..<15 {
+            guard let earliest = MessageRepository.shared.messages(for: opponent).first else { break }
+            let older = MessageRepository.shared.loadOlderMessages(
+                for: opponent,
+                beforeTimestamp: earliest.timestamp,
+                beforeMessageId: earliest.id,
+                limit: MessageRepository.pageSize
+            )
+            if older.isEmpty { break }
+        }
+
+        let cached = MessageRepository.shared.messages(for: opponent)
+        // Verify ascending timestamp order
+        for i in 1..<cached.count {
+            XCTAssertGreaterThanOrEqual(cached[i].timestamp, cached[i - 1].timestamp,
+                "Messages must be sorted by timestamp ASC after trim. " +
+                "Index \(i): \(cached[i].timestamp) < \(cached[i - 1].timestamp)")
+        }
+    }
+
+    // MARK: - No Duplicate Messages After Pagination
+
+    /// Pagination must not create duplicate message IDs in cache.
+    func testNoDuplicatesAfterPagination() async throws {
+        try await insertMessages(count: 400)
+
+        MessageRepository.shared.reloadLatest(for: opponent)
+
+        // Paginate up
+        for _ in 0..<5 {
+            guard let earliest = MessageRepository.shared.messages(for: opponent).first else { break }
+            let _ = MessageRepository.shared.loadOlderMessages(
+                for: opponent,
+                beforeTimestamp: earliest.timestamp,
+                beforeMessageId: earliest.id,
+                limit: MessageRepository.pageSize
+            )
+        }
+
+        let cached = MessageRepository.shared.messages(for: opponent)
+        let ids = cached.map(\.id)
+        let uniqueIds = Set(ids)
+        XCTAssertEqual(ids.count, uniqueIds.count,
+            "Cache must not contain duplicate message IDs. \(ids.count) total, \(uniqueIds.count) unique")
+    }
+
+    // MARK: - In-Memory Patch (Delivery Status)
+
+    /// Delivery status update patches cache in-memory without full refresh.
+    func testDeliveryStatusPatchesInMemory() async throws {
+        try await ctx.bootstrap()
+        try await ctx.runScenario(FixtureScenario(name: "patch test", events: [
+            .outgoing(opponent: opponent, messageId: "patch-1", timestamp: 5000, text: "hello"),
+        ]))
+
+        let before = MessageRepository.shared.messages(for: opponent)
+        XCTAssertEqual(before.first?.deliveryStatus, .waiting)
+
+        // Patch delivery status
+        MessageRepository.shared.updateDeliveryStatus(messageId: "patch-1", status: .delivered)
+
+        let after = MessageRepository.shared.messages(for: opponent)
+        XCTAssertEqual(after.first?.deliveryStatus, .delivered,
+            "Delivery status must be patched in-memory without full cache refresh")
+    }
+
+    // MARK: - In-Memory Patch (Read Status)
+
+    /// markOutgoingAsRead patches cache in-memory.
+    func testMarkOutgoingReadPatchesInMemory() async throws {
+        try await ctx.bootstrap()
+        try await ctx.runScenario(FixtureScenario(name: "read patch", events: [
+            .outgoing(opponent: opponent, messageId: "read-1", timestamp: 6000, text: "hello"),
+            .markDelivered(opponent: opponent, messageId: "read-1"),
+        ]))
+
+        let before = MessageRepository.shared.messages(for: opponent)
+        XCTAssertFalse(before.first?.isRead ?? true)
+
+        MessageRepository.shared.markOutgoingAsRead(opponentKey: opponent, myPublicKey: ctx.account)
+
+        let after = MessageRepository.shared.messages(for: opponent)
+        XCTAssertTrue(after.first?.isRead ?? false,
+            "Read status must be patched in-memory")
+    }
+}