@sriinnu/runic 2.0.0 → 2.11.2

package/Tests/RunicTests/ProviderSettingsDescriptorTests.swift

@@ -1,236 +0,0 @@
-import Foundation
-import RunicCore
-import SwiftUI
-import Testing
-@testable import Runic
-
-@MainActor
-struct ProviderSettingsDescriptorTests {
-    @Test
-    func `toggle I ds are unique across providers`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderSettingsDescriptorTests-unique"))
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-unique")
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        var statusByID: [String: String] = [:]
-        var lastRunAtByID: [String: Date] = [:]
-        var seenToggleIDs: Set<String> = []
-        var seenActionIDs: Set<String> = []
-
-        for provider in UsageProvider.allCases {
-            let context = ProviderSettingsContext(
-                provider: provider,
-                settings: settings,
-                store: store,
-                boolBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                stringBinding: { keyPath in
-                    Binding(
-                        get: { settings[keyPath: keyPath] },
-                        set: { settings[keyPath: keyPath] = $0 })
-                },
-                statusText: { id in statusByID[id] },
-                setStatusText: { id, text in
-                    if let text {
-                        statusByID[id] = text
-                    } else {
-                        statusByID.removeValue(forKey: id)
-                    }
-                },
-                lastAppActiveRunAt: { id in lastRunAtByID[id] },
-                setLastAppActiveRunAt: { id, date in
-                    if let date {
-                        lastRunAtByID[id] = date
-                    } else {
-                        lastRunAtByID.removeValue(forKey: id)
-                    }
-                },
-                requestConfirmation: { _ in })
-
-            let impl = try #require(ProviderCatalog.implementation(for: provider))
-            let toggles = impl.settingsToggles(context: context)
-            for toggle in toggles {
-                #expect(!seenToggleIDs.contains(toggle.id))
-                seenToggleIDs.insert(toggle.id)
-
-                for action in toggle.actions {
-                    #expect(!seenActionIDs.contains(action.id))
-                    seenActionIDs.insert(action.id)
-                }
-            }
-        }
-    }
-
-    @Test
-    func `codex does not expose open AI web toggle`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderSettingsDescriptorTests-codex"))
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-codex")
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let context = ProviderSettingsContext(
-            provider: .codex,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-
-        let toggles = CodexProviderImplementation().settingsToggles(context: context)
-        #expect(toggles.isEmpty)
-    }
-
-    @Test
-    func `claude does not expose settings toggles`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude"))
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude")
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let context = ProviderSettingsContext(
-            provider: .claude,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-        let toggles = ClaudeProviderImplementation().settingsToggles(context: context)
-        #expect(toggles.isEmpty)
-    }
-
-    @Test
-    func `claude web extras auto disables when leaving CLI`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderSettingsDescriptorTests-claude-invariant"))
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-claude-invariant")
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        settings.debugMenuEnabled = true
-        settings.claudeUsageDataSource = .cli
-        settings.claudeWebExtrasEnabled = true
-
-        settings.claudeUsageDataSource = .oauth
-        #expect(settings.claudeWebExtrasEnabled == false)
-    }
-
-    @Test
-    func `extra providers expose expected settings fields`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderSettingsDescriptorTests-extra-fields"))
-        defaults.removePersistentDomain(forName: "ProviderSettingsDescriptorTests-extra-fields")
-        let settings = SettingsStore(
-            userDefaults: defaults,
-            zaiTokenStore: NoopZaiTokenStore(),
-            minimaxTokenStore: NoopMiniMaxTokenStore(),
-            minimaxCookieHeaderStore: NoopMiniMaxCookieHeaderStore(),
-            minimaxGroupIDStore: NoopMiniMaxGroupIDStore(),
-            openRouterTokenStore: NoopOpenRouterTokenStore(),
-            groqTokenStore: NoopGroqTokenStore())
-        let store = UsageStore(fetcher: UsageFetcher(environment: [:]), settings: settings)
-
-        let expectedFields: [UsageProvider: Set<String>] = [
-            .kimi: ["kimi-api-token"],
-            .auggie: ["auggie-api-token"],
-            .openrouter: ["openrouter-api-token"],
-            .bedrock: ["bedrock-region", "bedrock-aws-profile", "bedrock-model-id"],
-        ]
-
-        for (provider, expected) in expectedFields {
-            guard let impl = ProviderCatalog.implementation(for: provider) else {
-                #expect(Bool(false), "Missing provider implementation for \(provider.rawValue).")
-                continue
-            }
-            let context = self.makeSettingsContext(provider: provider, settings: settings, store: store)
-            let visibleFields = impl.settingsFields(context: context).filter { $0.isVisible?() ?? true }
-            let fieldIDs = Set(visibleFields.map(\.id))
-            #expect(fieldIDs.isSuperset(of: expected))
-            #expect(!visibleFields.isEmpty)
-        }
-    }
-
-    @Test
-    func `all providers have app side implementation`() {
-        for provider in UsageProvider.allCases {
-            #expect(ProviderCatalog.implementation(for: provider) != nil)
-        }
-    }
-
-    private func makeSettingsContext(
-        provider: UsageProvider,
-        settings: SettingsStore,
-        store: UsageStore) -> ProviderSettingsContext
-    {
-        ProviderSettingsContext(
-            provider: provider,
-            settings: settings,
-            store: store,
-            boolBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            stringBinding: { keyPath in
-                Binding(
-                    get: { settings[keyPath: keyPath] },
-                    set: { settings[keyPath: keyPath] = $0 })
-            },
-            statusText: { _ in nil },
-            setStatusText: { _, _ in },
-            lastAppActiveRunAt: { _ in nil },
-            setLastAppActiveRunAt: { _, _ in },
-            requestConfirmation: { _ in })
-    }
-}

package/Tests/RunicTests/ProviderToggleStoreTests.swift

@@ -1,50 +0,0 @@
-import Foundation
-import Testing
-@testable import Runic
-
-@MainActor
-struct ProviderToggleStoreTests {
-    @Test
-    func `defaults match metadata`() throws {
-        let defaults = try #require(UserDefaults(suiteName: "ProviderToggleStoreTests-defaults"))
-        defaults.removePersistentDomain(forName: "ProviderToggleStoreTests-defaults")
-        let store = ProviderToggleStore(userDefaults: defaults)
-        let registry = ProviderRegistry.shared
-        let codexMeta = try #require(registry.metadata[.codex])
-        let claudeMeta = try #require(registry.metadata[.claude])
-
-        #expect(store.isEnabled(metadata: codexMeta))
-        #expect(!store.isEnabled(metadata: claudeMeta))
-    }
-
-    @Test
-    func `persists changes`() throws {
-        let suite = "ProviderToggleStoreTests-persist"
-        let defaultsA = try #require(UserDefaults(suiteName: suite))
-        defaultsA.removePersistentDomain(forName: suite)
-        let storeA = ProviderToggleStore(userDefaults: defaultsA)
-        let registry = ProviderRegistry.shared
-        let claudeMeta = try #require(registry.metadata[.claude])
-
-        storeA.setEnabled(true, metadata: claudeMeta)
-
-        let defaultsB = try #require(UserDefaults(suiteName: suite))
-        let storeB = ProviderToggleStore(userDefaults: defaultsB)
-        #expect(storeB.isEnabled(metadata: claudeMeta))
-    }
-
-    @Test
-    func `purges legacy keys`() throws {
-        let suite = "ProviderToggleStoreTests-purge"
-        let defaults = try #require(UserDefaults(suiteName: suite))
-        defaults.removePersistentDomain(forName: suite)
-        defaults.set(false, forKey: "showCodexUsage")
-        defaults.set(true, forKey: "showClaudeUsage")
-
-        let store = ProviderToggleStore(userDefaults: defaults)
-        store.purgeLegacyKeys()
-
-        #expect(defaults.object(forKey: "showCodexUsage") == nil)
-        #expect(defaults.object(forKey: "showClaudeUsage") == nil)
-    }
-}

package/Tests/RunicTests/RunicTests.swift

@@ -1,119 +0,0 @@
-import AppKit
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct RunicTests {
-    @Test
-    func `icon renderer produces template image`() {
-        let image = IconRenderer.makeIcon(
-            primaryRemaining: 50,
-            weeklyRemaining: 75,
-            creditsRemaining: 500,
-            stale: false,
-            style: .codex)
-        #expect(image.isTemplate)
-        #expect(image.size.width > 0)
-    }
-
-    @Test
-    func `icon renderer renders at pixel aligned size`() {
-        let image = IconRenderer.makeIcon(
-            primaryRemaining: 50,
-            weeklyRemaining: 75,
-            creditsRemaining: 500,
-            stale: false,
-            style: .claude)
-        let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
-        #expect(!bitmapReps.isEmpty)
-        #expect(bitmapReps.contains { rep in rep.pixelsWide > 0 && rep.pixelsHigh > 0 })
-    }
-
-    @Test
-    func `icon renderer caches static icons`() {
-        let first = IconRenderer.makeIcon(
-            primaryRemaining: 42,
-            weeklyRemaining: 17,
-            creditsRemaining: 250,
-            stale: false,
-            style: .codex)
-        let second = IconRenderer.makeIcon(
-            primaryRemaining: 42,
-            weeklyRemaining: 17,
-            creditsRemaining: 250,
-            stale: false,
-            style: .codex)
-        #expect(first === second)
-    }
-
-    @Test
-    func `icon renderer codex eyes punch through when unknown`() {
-        // Regression guard: icon should preserve transparent + opaque pixels.
-        let image = IconRenderer.makeIcon(
-            primaryRemaining: nil,
-            weeklyRemaining: 1,
-            creditsRemaining: nil,
-            stale: false,
-            style: .codex)
-
-        let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
-        let rep = bitmapReps.max { lhs, rhs in lhs.pixelsWide * lhs.pixelsHigh < rhs.pixelsWide * rhs.pixelsHigh }
-        #expect(rep != nil)
-        guard let rep else { return }
-
-        func alphaAt(px x: Int, _ y: Int) -> CGFloat {
-            (rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
-        }
-
-        let w = rep.pixelsWide
-        let h = rep.pixelsHigh
-        var transparentPixels = 0
-        for y in 0..<h {
-            for x in 0..<w {
-                if alphaAt(px: x, y) < 0.05 {
-                    transparentPixels += 1
-                }
-            }
-        }
-
-        #expect(w > 0 && h > 0)
-        #expect(transparentPixels > 0)
-    }
-
-    @Test
-    func `account info parses auth token`() throws {
-        let tmp = try FileManager.default.url(
-            for: .itemReplacementDirectory,
-            in: .userDomainMask,
-            appropriateFor: URL(fileURLWithPath: NSTemporaryDirectory()),
-            create: true)
-        defer { try? FileManager.default.removeItem(at: tmp) }
-
-        let token = Self.fakeJWT(email: "user@example.com", plan: "pro")
-        let auth = ["tokens": ["idToken": token]]
-        let data = try JSONSerialization.data(withJSONObject: auth)
-        let authURL = tmp.appendingPathComponent("auth.json")
-        try data.write(to: authURL)
-
-        let fetcher = UsageFetcher(environment: ["CODEX_HOME": tmp.path])
-        let account = fetcher.loadAccountInfo()
-        #expect(account.email == "user@example.com")
-        #expect(account.plan == "pro")
-    }
-
-    private static func fakeJWT(email: String, plan: String) -> String {
-        let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
-        let payload = (try? JSONSerialization.data(withJSONObject: [
-            "email": email,
-            "chatgpt_plan_type": plan,
-        ])) ?? Data()
-        func b64(_ data: Data) -> String {
-            data.base64EncodedString()
-                .replacingOccurrences(of: "=", with: "")
-                .replacingOccurrences(of: "+", with: "-")
-                .replacingOccurrences(of: "/", with: "_")
-        }
-        return "\(b64(header)).\(b64(payload))."
-    }
-}

package/Tests/RunicTests/SessionQuotaNotificationLogicTests.swift

@@ -1,35 +0,0 @@
-import Testing
-@testable import Runic
-
-struct SessionQuotaNotificationLogicTests {
-    @Test
-    func `does nothing without previous value`() {
-        let transition = SessionQuotaNotificationLogic.transition(previousRemaining: nil, currentRemaining: 0)
-        #expect(transition == .none)
-    }
-
-    @Test
-    func `detects depleted transition`() {
-        let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 12, currentRemaining: 0)
-        #expect(transition == .depleted)
-    }
-
-    @Test
-    func `detects restored transition`() {
-        let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 5)
-        #expect(transition == .restored)
-    }
-
-    @Test
-    func `ignores non transitions`() {
-        #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 0) == .none)
-        #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 10, currentRemaining: 10) == .none)
-        #expect(SessionQuotaNotificationLogic.transition(previousRemaining: 10, currentRemaining: 9) == .none)
-    }
-
-    @Test
-    func `treats tiny positive remaining as depleted`() {
-        let transition = SessionQuotaNotificationLogic.transition(previousRemaining: 0, currentRemaining: 0.00001)
-        #expect(transition == .none)
-    }
-}