LocalData/Tests/LocalDataTests/SyncIntegrationTests.swift

import Foundation
import Testing
@testable import LocalData

@Suite(.serialized)
struct SyncIntegrationTests {
    private let router: StorageRouter
    
    init() {
        let testBaseURL = FileManager.default.temporaryDirectory.appending(path: "SyncIntegrationTests-\(UUID().uuidString)")
        router = StorageRouter(
            keychain: MockKeychainHelper(),
            encryption: EncryptionHelper(keychain: MockKeychainHelper()),
            file: FileStorageHelper(configuration: FileStorageConfiguration(baseURL: testBaseURL)),
            defaults: UserDefaultsHelper(defaults: UserDefaults(suiteName: "SyncIntegrationTests-\(UUID().uuidString)")!)
        )
    }
    
    private struct SyncKey: StorageKey {
        typealias Value = String
        let name: String
        let domain: StorageDomain = .userDefaults(suite: nil)
        let security: SecurityPolicy = .none
        let serializer: Serializer<String> = .json
        let owner: String = "SyncTests"
        let description: String = "Sync key"
        let availability: PlatformAvailability = .all
        let syncPolicy: SyncPolicy = .automaticSmall
    }
    
    private struct SyncCatalog: StorageKeyCatalog {
        var allKeys: [AnyStorageKey] {
            [.key(SyncKey(name: "sync.test.key"))]
        }
    }

    @Test func updateFromSyncStoresDataLocally() async throws {
        // 1. Register catalog so router knows about the key
        try await router.registerCatalog(SyncCatalog())
        
        let keyName = "sync.test.key"
        let expectedValue = "Updated from Watch"
        let data = try JSONEncoder().encode(expectedValue)
        
        // 2. Simulate incoming sync
        try await router.updateFromSync(keyName: keyName, data: data)
        
        // 3. Verify it was stored in the local domain
        let retrieved: String? = try await router.get(SyncKey(name: keyName))
        #expect(retrieved == expectedValue)
    }
    
    @Test func updateFromSyncIgnoresUnregisteredKeys() async throws {
        let keyName = "unregistered.sync.key"
        let data = Data("some data".utf8)
        
        // This should not throw, just log/ignore
        try await router.updateFromSync(keyName: keyName, data: data)
    }
}