import Foundationimport Testing@testable import CodexBar@testable import CodexBarCore @Suite(.serialized)@MainActorstruct CodexManagedOpenAIWebTests {    @Test    func `managed codex open A I web uses active managed identity and cache scope`() {        KeychainCacheStore.setTestStoreForTesting(true)        defer { KeychainCacheStore.setTestStoreForTesting(false) }         let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-managed")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/managed-codex-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        settings._test_activeManagedCodexAccount = managedAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer { settings._test_activeManagedCodexAccount = nil }         let otherAccountID = UUID()        CookieHeaderCache.store(            provider: .codex,            scope: .managedAccount(otherAccountID),            cookieHeader: "auth=other-account",            sourceLabel: "Chrome")        CookieHeaderCache.store(            provider: .codex,            cookieHeader: "auth=provider-global",            sourceLabel: "Safari")        defer {            CookieHeaderCache.clear(provider: .codex, scope: .managedAccount(otherAccountID))            CookieHeaderCache.clear(provider: .codex)        }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(store.codexAccountEmailForOpenAIDashboard() == "managed@example.com")        #expect(store.codexCookieCacheScopeForOpenAIWeb() == .managedAccount(managedAccount.id))        #expect(CookieHeaderCache.load(provider: .codex, scope: store.codexCookieCacheScopeForOpenAIWeb()) == nil)    }     @Test    func `managed codex open A I web targets runtime auth backed email for selected account`() throws {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-managed-runtime-email")        let managedHome = FileManager.default.temporaryDirectory            .appendingPathComponent(UUID().uuidString, isDirectory: true)        defer { try? FileManager.default.removeItem(at: managedHome) }        try Self.writeCodexAuthFile(            homeURL: managedHome,            email: "renamed@example.com",            plan: "pro",            accountId: "acct-managed")         let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "legacy@example.com",            managedHomePath: managedHome.path,            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        settings._test_activeManagedCodexAccount = managedAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer { settings._test_activeManagedCodexAccount = nil }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(store.codexAccountEmailForOpenAIDashboard() == "renamed@example.com")        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)        #expect(store.currentCodexOpenAIWebRefreshGuard().accountKey == "renamed@example.com")        #expect(store.currentCodexOpenAIWebRefreshGuard().identity == .providerAccount(id: "acct-managed"))    }     @Test    func `live system codex open A I web uses live identity and no managed cache scope`() {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/managed-codex-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveAccount = ObservedSystemCodexAccount(            email: "system@example.com",            codexHomePath: "/tmp/live-codex-home",            observedAt: Date())        settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveAccount        settings.codexActiveSource = .liveSystem        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let store = UsageStore(            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)    }     @Test    func `live system codex open A I web does not reuse stale managed snapshot email after source switch`() {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-stale-managed-snapshot")        let isolatedHome = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-openai-web-empty-\(UUID().uuidString)", isDirectory: true)        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/managed-codex-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)         settings._test_activeManagedCodexAccount = managedAccount        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]        settings.codexActiveSource = .liveSystem        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_codexReconciliationEnvironment = nil            try? FileManager.default.removeItem(at: isolatedHome)        }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)        store._setSnapshotForTesting(            UsageSnapshot(                primary: nil,                secondary: nil,                updatedAt: Date(),                identity: ProviderIdentitySnapshot(                    providerID: .codex,                    accountEmail: managedAccount.email,                    accountOrganization: nil,                    loginMethod: nil)),            provider: .codex)         #expect(store.codexAccountEmailForOpenAIDashboard() == nil)        #expect(store.codexAccountEmailForOpenAIDashboard() != managedAccount.email)        #expect(store.codexCookieCacheScopeForOpenAIWeb() == nil)    }     @Test    func `live system codex open A I web reuses last known live email without allowing any account`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-last-known-email")        let isolatedHome = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-openai-web-last-known-\(UUID().uuidString)", isDirectory: true)        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)        let liveAccount = ObservedSystemCodexAccount(            email: "live@example.com",            codexHomePath: "/tmp/live-codex-home",            observedAt: Date())        settings._test_liveSystemCodexAccount = liveAccount        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]        settings.codexActiveSource = .liveSystem         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)         settings._test_liveSystemCodexAccount = nil        defer {            settings._test_liveSystemCodexAccount = nil            settings._test_codexReconciliationEnvironment = nil            try? FileManager.default.removeItem(at: isolatedHome)        }         store.openAIDashboard = OpenAIDashboardSnapshot(            signedInEmail: "managed@example.com",            codeReviewRemainingPercent: 100,            creditEvents: [],            dailyBreakdown: [],            usageBreakdown: [],            creditsPurchaseURL: nil,            updatedAt: Date())        store.lastOpenAIDashboardCookieImportEmail = "managed-import@example.com"         var observedTargetEmail: String?        var observedAllowAnyAccount: Bool?        store._test_openAIDashboardCookieImportOverride = { targetEmail, allowAnyAccount, _, _, _ in            observedTargetEmail = targetEmail            observedAllowAnyAccount = allowAnyAccount            return OpenAIDashboardBrowserCookieImporter.ImportResult(                sourceLabel: "test",                cookieCount: 1,                signedInEmail: targetEmail,                matchesCodexEmail: true)        }        defer { store._test_openAIDashboardCookieImportOverride = nil }         let targetEmail = store.codexAccountEmailForOpenAIDashboard()        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: targetEmail, force: true)         #expect(targetEmail == liveAccount.email)        #expect(targetEmail != "managed@example.com")        #expect(targetEmail != "managed-import@example.com")        #expect(imported == liveAccount.email)        #expect(observedTargetEmail == liveAccount.email)        #expect(observedAllowAnyAccount == false)    }     @Test    func `successful dashboard apply preserves cached open A I web view for same account`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-preserve-cache-on-success")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/managed-codex-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        settings._test_activeManagedCodexAccount = managedAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer { settings._test_activeManagedCodexAccount = nil }         OpenAIDashboardWebsiteDataStore.clearCacheForTesting()        let cache = OpenAIDashboardWebViewCache.shared        cache.clearAllForTesting()        defer {            cache.clearAllForTesting()            OpenAIDashboardWebsiteDataStore.clearCacheForTesting()        }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)        let websiteDataStore = OpenAIDashboardWebsiteDataStore.store(forAccountEmail: managedAccount.email)        cache.cacheEntryForTesting(websiteDataStore: websiteDataStore)         #expect(cache.hasCachedEntry(for: websiteDataStore))         await store.applyOpenAIDashboard(            OpenAIDashboardSnapshot(                signedInEmail: managedAccount.email,                codeReviewRemainingPercent: 90,                creditEvents: [],                dailyBreakdown: [],                usageBreakdown: [],                creditsPurchaseURL: nil,                creditsRemaining: 10,                accountPlan: "Pro",                updatedAt: Date()),            targetEmail: managedAccount.email)         #expect(cache.hasCachedEntry(for: websiteDataStore))        #expect(cache.entryCount == 1)    }     @Test    func `dashboard refresh does not target stale last known live email`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-refresh-strict-target")        let isolatedHome = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-openai-web-refresh-strict-\(UUID().uuidString)", isDirectory: true)        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)        let liveAccount = ObservedSystemCodexAccount(            email: "old@example.com",            codexHomePath: "/tmp/live-codex-home",            observedAt: Date())        settings._test_liveSystemCodexAccount = liveAccount        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]        settings.codexActiveSource = .liveSystem         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)         #expect(store.codexAccountEmailForOpenAIDashboard() == liveAccount.email)         settings._test_liveSystemCodexAccount = nil        defer {            settings._test_liveSystemCodexAccount = nil            settings._test_codexReconciliationEnvironment = nil            try? FileManager.default.removeItem(at: isolatedHome)        }         var observedTargetEmail: String?        store._test_openAIDashboardLoaderOverride = { accountEmail, _, _, _ in            observedTargetEmail = accountEmail            return OpenAIDashboardSnapshot(                signedInEmail: "new@example.com",                codeReviewRemainingPercent: 88,                creditEvents: [],                dailyBreakdown: [],                usageBreakdown: [],                creditsPurchaseURL: nil,                primaryLimit: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),                secondaryLimit: nil,                creditsRemaining: 22,                accountPlan: "Pro",                updatedAt: Date())        }        defer { store._test_openAIDashboardLoaderOverride = nil }         let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()        #expect(expectedGuard.accountKey == nil)         await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)         #expect(observedTargetEmail == nil)        #expect(store.openAIDashboard == nil)        #expect(store.openAIDashboardRequiresLogin == true)        #expect(store.lastOpenAIDashboardError?.contains("could not be verified") == true)        #expect(store.lastKnownLiveSystemCodexEmail == "old@example.com")    }     @Test    func `dashboard refresh targets usage discovered live email before reconciliation catches up`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-usage-discovered-target")        let isolatedHome = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-openai-web-usage-discovered-\(UUID().uuidString)", isDirectory: true)        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]        settings.codexActiveSource = .liveSystem        defer {            settings._test_codexReconciliationEnvironment = nil            try? FileManager.default.removeItem(at: isolatedHome)        }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)        store._setSnapshotForTesting(            UsageSnapshot(                primary: nil,                secondary: nil,                updatedAt: Date(),                identity: ProviderIdentitySnapshot(                    providerID: .codex,                    accountEmail: "usage@example.com",                    accountOrganization: nil,                    loginMethod: nil)),            provider: .codex)        store.lastSourceLabels[.codex] = "codex-cli"         var observedTargetEmail: String?        store._test_openAIDashboardLoaderOverride = { accountEmail, _, _, _ in            observedTargetEmail = accountEmail            return OpenAIDashboardSnapshot(                signedInEmail: "usage@example.com",                codeReviewRemainingPercent: 88,                creditEvents: [],                dailyBreakdown: [],                usageBreakdown: [],                creditsPurchaseURL: nil,                primaryLimit: RateWindow(usedPercent: 12, windowMinutes: 300, resetsAt: nil, resetDescription: nil),                secondaryLimit: nil,                creditsRemaining: 22,                accountPlan: "Pro",                updatedAt: Date())        }        defer { store._test_openAIDashboardLoaderOverride = nil }         let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()        #expect(expectedGuard.accountKey == nil)         await store.refreshOpenAIDashboardIfNeeded(force: true, expectedGuard: expectedGuard)         #expect(observedTargetEmail == "usage@example.com")        #expect(store.openAIDashboard?.signedInEmail == "usage@example.com")    }     @Test    func `usage discovered live email still surfaces open A I web login guidance during reconciliation lag`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-live-system-usage-discovered-failure")        let isolatedHome = FileManager.default.temporaryDirectory            .appendingPathComponent("codex-openai-web-usage-discovered-failure-\(UUID().uuidString)", isDirectory: true)        try? FileManager.default.createDirectory(at: isolatedHome, withIntermediateDirectories: true)        settings._test_codexReconciliationEnvironment = ["CODEX_HOME": isolatedHome.path]        settings.codexActiveSource = .liveSystem        defer {            settings._test_codexReconciliationEnvironment = nil            try? FileManager.default.removeItem(at: isolatedHome)        }         let store = UsageStore(            fetcher: UsageFetcher(environment: [:]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)        store._setSnapshotForTesting(            UsageSnapshot(                primary: nil,                secondary: nil,                updatedAt: Date(),                identity: ProviderIdentitySnapshot(                    providerID: .codex,                    accountEmail: "usage@example.com",                    accountOrganization: nil,                    loginMethod: nil)),            provider: .codex)        store.lastSourceLabels[.codex] = "codex-cli"         let expectedGuard = store.currentCodexOpenAIWebRefreshGuard()        #expect(expectedGuard.accountKey == nil)         await store.applyOpenAIDashboardLoginRequiredFailure(            expectedGuard: expectedGuard,            routingTargetEmail: "usage@example.com")         #expect(store.openAIDashboardRequiresLogin == true)        #expect(store.lastOpenAIDashboardError?.contains("requires a signed-in chatgpt.com session") == true)    }     @Test    func `open A I web import uses managed account target when live account differs`() async {        let settings = self.makeSettingsStore(suite: "CodexManagedOpenAIWebTests-targeting-active-vs-live")        let managedAccount = ManagedCodexAccount(            id: UUID(),            email: "managed@example.com",            managedHomePath: "/tmp/managed-codex-home",            createdAt: 1,            updatedAt: 1,            lastAuthenticatedAt: 1)        let liveAccount = ObservedSystemCodexAccount(            email: "system@example.com",            codexHomePath: "/tmp/live-codex-home",            observedAt: Date())        let expectedScope = CookieHeaderCache.Scope.managedAccount(managedAccount.id)        let expectedEmail = managedAccount.email        var observedTargetEmail: String?        var observedScope: CookieHeaderCache.Scope?        var observedCookieSource: ProviderCookieSource?        var observedAllowAnyAccount = false         settings._test_activeManagedCodexAccount = managedAccount        settings._test_liveSystemCodexAccount = liveAccount        settings.codexActiveSource = .managedAccount(id: managedAccount.id)        defer {            settings._test_activeManagedCodexAccount = nil            settings._test_liveSystemCodexAccount = nil        }         let snapshot = UsageSnapshot(            primary: nil,            secondary: nil,            updatedAt: Date(),            identity: ProviderIdentitySnapshot(                providerID: .codex,                accountEmail: liveAccount.email,                accountOrganization: nil,                loginMethod: nil))         let store = UsageStore(            fetcher: UsageFetcher(environment: ["CODEX_HOME": liveAccount.codexHomePath]),            browserDetection: BrowserDetection(cacheTTL: 0),            settings: settings,            startupBehavior: .testing)        store._setSnapshotForTesting(snapshot, provider: .codex)        store._test_openAIDashboardCookieImportOverride = { targetEmail, allowAnyAccount, cookieSource, scope, _ in            observedTargetEmail = targetEmail            observedScope = scope            observedCookieSource = cookieSource            observedAllowAnyAccount = allowAnyAccount            return OpenAIDashboardBrowserCookieImporter.ImportResult(                sourceLabel: "test",                cookieCount: 1,                signedInEmail: targetEmail,                matchesCodexEmail: targetEmail == expectedEmail)        }        defer { store._test_openAIDashboardCookieImportOverride = nil }         let importerTarget = store.codexAccountEmailForOpenAIDashboard()        let imported = await store.importOpenAIDashboardCookiesIfNeeded(targetEmail: importerTarget, force: true)         #expect(importerTarget == expectedEmail)        #expect(importerTarget != liveAccount.email)        #expect(imported == expectedEmail)        #expect(observedTargetEmail == expectedEmail)

Lines 1–500 of 881. Load more