import Foundationimport Testing@testable import CodexBar@testable import CodexBarCore @Suite(.serialized)@MainActorstruct CodexManagedRoutingTests {    @Test    func `provider registry injects managed home when active source is managed account`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-registry")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/codex-managed-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        settings._test_activeManagedCodexAccount = managedAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil        }         let codexEnv = ProviderRegistry.makeEnvironment(            base: ["PATH": "/usr/bin"],            provider: .codex,            settings: settings,            tokenOverride: nil)        let claudeEnv = ProviderRegistry.makeEnvironment(            base: ["PATH": "/usr/bin"],            provider: .claude,            settings: settings,            tokenOverride: nil)         #expect(codexEnv["CODEX_HOME"] == managedAccount.managedHomePath)        #expect(claudeEnv["CODEX_HOME"] == nil)    }     @Test    func `provider registry scopes codex environment with source override without persisting selection`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-source-override-env")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/codex-managed-override-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let storeURL = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-managed-override-\(UUID().uuidString).json")        let store = FileManagedCodexAccountStore(fileURL: storeURL)        try store.storeAccounts(ManagedCodexAccountSet(            version: FileManagedCodexAccountStore.currentVersion,            accounts: [managedAccount]))        settings._test_managedCodexAccountStoreURL = storeURL        settings.codexActiveSource = .liveSystem        defer {            settings._test_managedCodexAccountStoreURL = nil            try? FileManager.default.removeItem(at: storeURL)        }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": "/Users/example/.codex"],            provider: .codex,            settings: settings,            tokenOverride: nil,            codexActiveSourceOverride: .managedAccount(id: managedAccount.id))         #expect(env["CODEX_HOME"] == managedAccount.managedHomePath)        #expect(settings.codexActiveSource == .liveSystem)    }     @Test    func `provider registry builds codex snapshot with source override without persisting selection`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-source-override-snapshot")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/codex-managed-override-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let storeURL = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-managed-snapshot-override-\(UUID().uuidString).json")        let store = FileManagedCodexAccountStore(fileURL: storeURL)        try store.storeAccounts(ManagedCodexAccountSet(            version: FileManagedCodexAccountStore.currentVersion,            accounts: [managedAccount]))        settings._test_managedCodexAccountStoreURL = storeURL        settings.codexActiveSource = .liveSystem        defer {            settings._test_managedCodexAccountStoreURL = nil            try? FileManager.default.removeItem(at: storeURL)        }         let snapshot = ProviderRegistry.makeSettingsSnapshot(            settings: settings,            tokenOverride: nil,            codexActiveSourceOverride: .managedAccount(id: UUID()))         #expect(snapshot.codex?.managedAccountTargetUnavailable == true)        #expect(settings.codexActiveSource == .liveSystem)    }     @Test    func `provider registry preserves ambient live system home when active source is live system`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-live-system-routing")        let managedHomePath = "/tmp/managed-remote-home"        let liveHomePath = "/tmp/system-remote-home"        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: managedHomePath,            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveSystemAccount = ObservedSystemCodexAccount(            email: "system@example.com",            codexHomePath: liveHomePath,            observedAt: Date())         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveSystemAccount        settings.codexActiveSource = .liveSystem        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": liveHomePath],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(env["CODEX_HOME"] == liveHomePath)        #expect(env["CODEX_HOME"] != managedHomePath)    }     @Test    func `provider registry keeps managed home when live account differs`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-active-vs-live")        let managedHomePath = "/tmp/managed-remote-home"        let liveHomePath = "/tmp/system-remote-home"        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: managedHomePath,            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveSystemAccount = ObservedSystemCodexAccount(            email: "system@example.com",            codexHomePath: liveHomePath,            observedAt: Date())         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveSystemAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": liveHomePath],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(env["CODEX_HOME"] == managedHomePath)        #expect(env["CODEX_HOME"] != liveHomePath)    }     @Test    func `provider registry prefers live system routing when managed and live share email`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-prefers-live")        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(            UUID().uuidString,            isDirectory: true)        let liveHomePath = "/tmp/system-remote-home"        defer { try? FileManager.default.removeItem(at: managedHome) }         let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "person@example.com",            managedHomePath: managedHome.path,            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveSystemAccount = ObservedSystemCodexAccount(            email: "PERSON@example.com",            codexHomePath: liveHomePath,            observedAt: Date())         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveSystemAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": liveHomePath],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(settings.codexResolvedActiveSource == .liveSystem)        #expect(env["CODEX_HOME"] == liveHomePath)        #expect(env["CODEX_HOME"] != managedHome.path)    }     @Test    func `provider registry keeps managed routing when same email rows differ by identity strength`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-split-by-identity")        let managedHome = FileManager.default.temporaryDirectory.appendingPathComponent(            UUID().uuidString,            isDirectory: true)        let liveHomePath = "/tmp/system-remote-home"        defer { try? FileManager.default.removeItem(at: managedHome) }         try self.writeCodexAuthFile(            homeURL: managedHome,            email: "person@example.com",            plan: "pro",            accountId: "account-managed")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "person@example.com",            managedHomePath: managedHome.path,            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveSystemAccount = ObservedSystemCodexAccount(            email: "PERSON@example.com",            codexHomePath: liveHomePath,            observedAt: Date(),            identity: .emailOnly(normalizedEmail: "person@example.com"))         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveSystemAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": liveHomePath],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(settings.codexResolvedActiveSource == .managedAccount(id: managedAccount.id))        #expect(env["CODEX_HOME"] == managedHome.path)        #expect(env["CODEX_HOME"] != liveHomePath)    }     @Test    func `persisted managed source corrects to live system when selected row collapses with live account`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-same-email-persist-correction")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "person@example.com",            managedHomePath: "/tmp/managed-remote-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveSystemAccount = ObservedSystemCodexAccount(            email: "PERSON@example.com",            codexHomePath: "/tmp/system-remote-home",            observedAt: Date())         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveSystemAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let corrected = settings.persistResolvedCodexActiveSourceCorrectionIfNeeded()         #expect(corrected)        #expect(settings.codexActiveSource == .liveSystem)    }     @Test    func `codex provider refresh persists live correction for stale managed source`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-provider-refresh-persists-correction")        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(            UUID().uuidString,            isDirectory: true)        defer { try? FileManager.default.removeItem(at: ambientHome) }         try? self.writeCodexAuthFile(homeURL: ambientHome, email: "live@example.com", plan: "pro")        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(            email: "live@example.com",            codexHomePath: ambientHome.path,            observedAt: Date())        settings.codexActiveSource = .managedAccount(id: UUID())        defer { settings._test_liveSystemCodexAccount = nil }         let store = UsageStore(            fetcher: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(settings.codexActiveSource != .liveSystem)         await store.refreshProvider(.codex, allowDisabled: true)         #expect(settings.codexActiveSource == .liveSystem)    }     @Test    func `full refresh persists live correction for stale managed source`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-full-refresh-persists-correction")        let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent(            UUID().uuidString,            isDirectory: true)        defer { try? FileManager.default.removeItem(at: ambientHome) }         try? self.writeCodexAuthFile(homeURL: ambientHome, email: "live@example.com", plan: "pro")        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(            email: "live@example.com",            codexHomePath: ambientHome.path,            observedAt: Date())        settings.codexActiveSource = .managedAccount(id: UUID())        defer { settings._test_liveSystemCodexAccount = nil }         let store = UsageStore(            fetcher: UsageFetcher(environment: ["CODEX_HOME": ambientHome.path]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(settings.codexActiveSource != .liveSystem)         await store.refresh()         #expect(settings.codexActiveSource == .liveSystem)    }     @Test    func `provider registry fails closed when managed account store is unreadable`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-store")        settings._test_unreadableManagedCodexAccountStore = true        settings.codexActiveSource = .managedAccount(id: UUID())        defer { settings._test_unreadableManagedCodexAccountStore = false }         let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": "/Users/example/.codex"],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(env["CODEX_HOME"] != nil)        #expect(env["CODEX_HOME"] != "/Users/example/.codex")        #expect(env["CODEX_HOME"]?.isEmpty == false)    }     @Test    func `provider registry bootstraps live system source instead of inferring managed fallback`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-legacy-source")        settings._test_unreadableManagedCodexAccountStore = true        defer { settings._test_unreadableManagedCodexAccountStore = false }         let ambientHome = "/Users/example/.codex"        let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": ambientHome],            provider: .codex,            settings: settings,            tokenOverride: nil)        let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)         #expect(env["CODEX_HOME"] == ambientHome)        #expect(settings.providerConfig(for: .codex)?.codexActiveSource == nil)        #expect(snapshot.managedAccountStoreUnreadable == false)        #expect(snapshot.managedAccountTargetUnavailable == false)    }     @Test    func `provider registry fails closed when selected managed source is missing from readable store`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-source")        let storedAccount = ManagedCodexAccount(            id: UUID(),            email: "stored@example.com",            managedHomePath: "/tmp/stored-managed-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let storeURL = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-managed-routing-\(UUID().uuidString).json")        let store = FileManagedCodexAccountStore(fileURL: storeURL)        try store.storeAccounts(ManagedCodexAccountSet(            version: FileManagedCodexAccountStore.currentVersion,            accounts: [storedAccount]))        settings._test_managedCodexAccountStoreURL = storeURL        settings.codexActiveSource = .managedAccount(id: UUID())        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": "/Users/example/.codex"]        defer {            settings._test_codexReconciliationEnvironment = nil            settings._test_managedCodexAccountStoreURL = nil            try? FileManager.default.removeItem(at: storeURL)        }         let ambientHome = "/Users/example/.codex"        let expectedFailClosedPath = ManagedCodexHomeFactory.defaultRootURL()            .appendingPathComponent("managed-store-unreadable", isDirectory: true)            .path        let env = ProviderRegistry.makeEnvironment(            base: ["CODEX_HOME": ambientHome],            provider: .codex,            settings: settings,            tokenOverride: nil)         #expect(env["CODEX_HOME"] == expectedFailClosedPath)        #expect(env["CODEX_HOME"] != ambientHome)        #expect(env["CODEX_HOME"] != storedAccount.managedHomePath)    }     @Test    func `codex settings snapshot marks missing selected managed source as unavailable`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-snapshot")        let storedAccount = ManagedCodexAccount(            id: UUID(),            email: "stored@example.com",            managedHomePath: "/tmp/stored-managed-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let storeURL = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-managed-snapshot-\(UUID().uuidString).json")        let store = FileManagedCodexAccountStore(fileURL: storeURL)        try store.storeAccounts(ManagedCodexAccountSet(            version: FileManagedCodexAccountStore.currentVersion,            accounts: [storedAccount]))        settings._test_managedCodexAccountStoreURL = storeURL        settings.codexActiveSource = .managedAccount(id: UUID())        defer {            settings._test_managedCodexAccountStoreURL = nil            try? FileManager.default.removeItem(at: storeURL)        }         let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)         #expect(snapshot.managedAccountStoreUnreadable == false)        #expect(snapshot.managedAccountTargetUnavailable == true)    }     @Test    func `codex settings snapshot ignores unreadable added account store when live system is active`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-live-system-snapshot")        settings._test_unreadableManagedCodexAccountStore = true        settings.codexActiveSource = .liveSystem        defer { settings._test_unreadableManagedCodexAccountStore = false }         let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)         #expect(snapshot.managedAccountStoreUnreadable == false)        #expect(snapshot.managedAccountTargetUnavailable == false)    }     @Test    func `codex settings snapshot keeps unreadable managed store fail closed when live account is present`() {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-unreadable-store-live-present")        settings._test_unreadableManagedCodexAccountStore = true        settings.codexActiveSource = .managedAccount(id: UUID())        settings._test_liveSystemCodexAccount = ObservedSystemCodexAccount(            email: "live@example.com",            codexHomePath: "/Users/example/.codex",            observedAt: Date(),            identity: .providerAccount(id: "acct-live"))        defer {            settings._test_unreadableManagedCodexAccountStore = false            settings._test_liveSystemCodexAccount = nil        }         let snapshot = settings.codexSettingsSnapshot(tokenOverride: nil)         #expect(snapshot.managedAccountStoreUnreadable == true)        #expect(snapshot.managedAccountTargetUnavailable == false)    }     @Test    func `codex settings snapshot keeps missing managed target fail closed when live account is present`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedRoutingTests-missing-managed-live-present")        let storedAccount = ManagedCodexAccount(            id: UUID(),            email: "stored@example.com",            managedHomePath: "/tmp/stored-managed-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let storeURL = FileManager.default.temporaryDirectory

Lines 1–500 of 851. Load more