@sriinnu/runic 2.0.0 → 2.11.1

package/Tests/RunicTests/PathBuilderTests.swift

@@ -1,236 +0,0 @@
-import Foundation
-import RunicCore
-import Testing
-@testable import Runic
-
-struct PathBuilderTests {
-    @Test
-    func `merges login shell path when available`() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.rpc],
-            env: ["PATH": "/custom/bin:/usr/bin"],
-            loginPATH: ["/login/bin", "/login/alt"])
-        #expect(seeded == "/login/bin:/login/alt:/custom/bin:/usr/bin")
-    }
-
-    @Test
-    func `falls back to existing path when no login path`() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.tty],
-            env: ["PATH": "/custom/bin:/usr/bin"],
-            loginPATH: nil)
-        #expect(seeded == "/custom/bin:/usr/bin")
-    }
-
-    @Test
-    func `uses fallback when no path available`() {
-        let seeded = PathBuilder.effectivePATH(
-            purposes: [.tty],
-            env: [:],
-            loginPATH: nil)
-        #expect(seeded == "/usr/bin:/bin:/usr/sbin:/sbin")
-    }
-
-    @Test
-    func `resolves codex from env override`() {
-        let overridePath = "/custom/bin/codex"
-        let fm = MockFileManager(executables: [overridePath])
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["CODEX_CLI_PATH": overridePath],
-            loginPATH: nil,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == overridePath)
-    }
-
-    @Test
-    func `resolves codex from login path`() {
-        let fm = MockFileManager(executables: ["/login/bin/codex"])
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["PATH": "/env/bin"],
-            loginPATH: ["/login/bin"],
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/login/bin/codex")
-    }
-
-    @Test
-    func `resolves codex from env path`() {
-        let fm = MockFileManager(executables: ["/env/bin/codex"])
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["PATH": "/env/bin:/usr/bin"],
-            loginPATH: nil,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/env/bin/codex")
-    }
-
-    @Test
-    func `resolves codex from interactive shell`() {
-        let fm = MockFileManager(executables: ["/shell/bin/codex"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "codex")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/codex"
-        }
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/codex")
-    }
-
-    @Test
-    func `resolves claude from interactive shell`() {
-        let fm = MockFileManager(executables: ["/shell/bin/claude"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "claude")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/claude"
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/claude")
-    }
-
-    @Test
-    func `resolves gemini from interactive shell`() {
-        let fm = MockFileManager(executables: ["/shell/bin/gemini"])
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { tool, shell, timeout, fileManager in
-            #expect(tool == "gemini")
-            #expect(shell == "/bin/zsh")
-            #expect(timeout == 2.0)
-            _ = fileManager
-            return "/shell/bin/gemini"
-        }
-
-        let resolved = BinaryLocator.resolveGeminiBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/shell/bin/gemini")
-    }
-
-    @Test
-    func `resolves claude from login path`() {
-        let fm = MockFileManager(executables: ["/login/bin/claude"])
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["PATH": "/env/bin"],
-            loginPATH: ["/login/bin"],
-            fileManager: fm,
-            home: "/home/test")
-        #expect(resolved == "/login/bin/claude")
-    }
-
-    @Test
-    func `resolves claude from alias when other lookups fail`() {
-        let aliasPath = "/home/test/.claude/local/bin/claude"
-        let fm = MockFileManager(executables: [aliasPath])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
-            -> String? = { tool, shell, timeout, _, home in
-                aliasCalled = true
-                #expect(tool == "claude")
-                #expect(shell == "/bin/zsh")
-                #expect(timeout == 2.0)
-                #expect(home == "/home/test")
-                return aliasPath
-            }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            nil
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(aliasCalled)
-        #expect(resolved == aliasPath)
-    }
-
-    @Test
-    func `resolves codex from alias when other lookups fail`() {
-        let aliasPath = "/home/test/.codex/bin/codex"
-        let fm = MockFileManager(executables: [aliasPath])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String)
-            -> String? = { tool, shell, timeout, _, home in
-                aliasCalled = true
-                #expect(tool == "codex")
-                #expect(shell == "/bin/zsh")
-                #expect(timeout == 2.0)
-                #expect(home == "/home/test")
-                return aliasPath
-            }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            nil
-        }
-
-        let resolved = BinaryLocator.resolveCodexBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(aliasCalled)
-        #expect(resolved == aliasPath)
-    }
-
-    @Test
-    func `skips alias when command V resolves`() {
-        let path = "/shell/bin/claude"
-        let fm = MockFileManager(executables: [path])
-        var aliasCalled = false
-        let aliasResolver: (String, String?, TimeInterval, FileManager, String) -> String? = { _, _, _, _, _ in
-            aliasCalled = true
-            return "/alias/claude"
-        }
-        let commandV: (String, String?, TimeInterval, FileManager) -> String? = { _, _, _, _ in
-            path
-        }
-
-        let resolved = BinaryLocator.resolveClaudeBinary(
-            env: ["SHELL": "/bin/zsh"],
-            loginPATH: nil,
-            commandV: commandV,
-            aliasResolver: aliasResolver,
-            fileManager: fm,
-            home: "/home/test")
-
-        #expect(!aliasCalled)
-        #expect(resolved == path)
-    }
-}
-
-private final class MockFileManager: FileManager {
-    private let executables: Set<String>
-
-    init(executables: Set<String>) {
-        self.executables = executables
-    }
-
-    override func isExecutableFile(atPath path: String) -> Bool {
-        self.executables.contains(path)
-    }
-}

package/Tests/RunicTests/ProviderFetchPipelineTests.swift

@@ -1,159 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct ProviderFetchPipelineTests {
-    private struct SlowStrategy: ProviderFetchStrategy {
-        let id: String
-        let kind: ProviderFetchKind = .api
-        let shouldFallbackValue: Bool
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-            while true {
-                try await Task.sleep(for: .milliseconds(10))
-            }
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            self.shouldFallbackValue
-        }
-    }
-
-    private struct FailingStrategy: ProviderFetchStrategy {
-        let id: String = "provider.fetchPipeline.fail"
-        let kind: ProviderFetchKind = .api
-        let error: Error
-        let fallback: Bool
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-            throw self.error
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            self.fallback
-        }
-    }
-
-    private struct FastSuccessStrategy: ProviderFetchStrategy {
-        let id: String = "provider.fetchPipeline.success"
-        let kind: ProviderFetchKind = .api
-        let result: ProviderFetchResult
-
-        func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-            true
-        }
-
-        func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult {
-            self.result
-        }
-
-        func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-            false
-        }
-    }
-
-    private final class DummyClaudeFetcher: ClaudeUsageFetching, @unchecked Sendable {
-        func loadLatestUsage(model: String) async throws -> ClaudeUsageSnapshot {
-            throw URLError(.unsupportedURL)
-        }
-
-        func debugRawProbe(model: String) async -> String {
-            ""
-        }
-
-        func detectVersion() -> String? {
-            nil
-        }
-    }
-
-    private func makeContext() -> ProviderFetchContext {
-        ProviderFetchContext(
-            runtime: .app,
-            sourceMode: .auto,
-            includeCredits: false,
-            webTimeout: 60,
-            webDebugDumpHTML: false,
-            verbose: false,
-            env: [:],
-            settings: nil,
-            fetcher: UsageFetcher(environment: [:]),
-            claudeFetcher: DummyClaudeFetcher())
-    }
-
-    @Test
-    func `hangs are converted to strategy timeout`() async {
-        let pipeline = ProviderFetchPipeline(
-            resolveStrategies: { _ in [SlowStrategy(id: "provider.fetchPipeline.hang", shouldFallbackValue: false)] },
-            strategyTimeout: 0.05)
-        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
-
-        #expect(!outcome.attempts.isEmpty)
-        #expect(outcome.attempts.count == 1)
-        #expect(outcome.attempts[0].strategyID == "provider.fetchPipeline.hang")
-        #expect(outcome.attempts[0].wasAvailable == true)
-
-        guard case let .failure(error) = outcome.result else {
-            Issue.record("Expected fetch failure")
-            return
-        }
-        guard case let .strategyTimeout(provider, strategyID, timeoutSeconds) = error as? ProviderFetchError else {
-            Issue.record("Expected strategy timeout error")
-            return
-        }
-        #expect(provider == .kimi)
-        #expect(strategyID == "provider.fetchPipeline.hang")
-        #expect(timeoutSeconds == 0.05)
-    }
-
-    @Test
-    func `strategy fallback still honors order`() async {
-        let expected = Self.makeStubResult()
-        let pipeline = ProviderFetchPipeline(
-            resolveStrategies: { _ in [
-                FailingStrategy(error: URLError(.timedOut), fallback: true),
-                FastSuccessStrategy(result: expected),
-            ] },
-            strategyTimeout: 1)
-
-        let outcome = await pipeline.fetch(context: self.makeContext(), provider: .kimi)
-        let result = try? outcome.result.get()
-
-        #expect(result?.strategyID == expected.strategyID)
-        #expect(result?.strategyKind == expected.strategyKind)
-        #expect(result?.sourceLabel == expected.sourceLabel)
-        #expect(result?.usage.primary.resetDescription == expected.usage.primary.resetDescription)
-        #expect(outcome.attempts.count == 2)
-        #expect(outcome.attempts[0].wasAvailable)
-        #expect(outcome.attempts[0].errorDescription != nil)
-        #expect(outcome.attempts[1].wasAvailable)
-        #expect(outcome.attempts[1].errorDescription == nil)
-    }
-
-    private static func makeStubResult() -> ProviderFetchResult {
-        let usage = UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 1,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: "test"),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-        return ProviderFetchResult(
-            usage: usage,
-            credits: nil,
-            dashboard: nil,
-            sourceLabel: "test",
-            strategyID: "provider.fetchPipeline.success",
-            strategyKind: .api)
-    }
-}

package/Tests/RunicTests/ProviderIconResourcesTests.swift

@@ -1,37 +0,0 @@
-import AppKit
-import Foundation
-import Testing
-
-@MainActor
-struct ProviderIconResourcesTests {
-    @Test
-    func `provider icon SV gs exist`() throws {
-        let root = try Self.repoRoot()
-        let resources = root.appending(path: "Sources/Runic/Resources", directoryHint: .isDirectory)
-
-        let slugs = ["codex", "claude", "zai", "cursor", "gemini", "antigravity", "factory", "copilot"]
-        for slug in slugs {
-            let url = resources.appending(path: "ProviderIcon-\(slug).svg")
-            #expect(
-                FileManager.default.fileExists(atPath: url.path(percentEncoded: false)),
-                "Missing SVG for \(slug)")
-
-            let image = NSImage(contentsOf: url)
-            #expect(image != nil, "Could not load SVG as NSImage for \(slug)")
-        }
-    }
-
-    private static func repoRoot() throws -> URL {
-        var dir = URL(filePath: #filePath).deletingLastPathComponent()
-        for _ in 0..<12 {
-            let candidate = dir.appending(path: "Package.swift")
-            if FileManager.default.fileExists(atPath: candidate.path(percentEncoded: false)) {
-                return dir
-            }
-            dir.deleteLastPathComponent()
-        }
-        throw NSError(domain: "ProviderIconResourcesTests", code: 2, userInfo: [
-            NSLocalizedDescriptionKey: "Could not locate repo root (Package.swift) from \(#filePath)",
-        ])
-    }
-}

package/Tests/RunicTests/ProviderMetadataStatusLinkTests.swift

@@ -1,15 +0,0 @@
-import Testing
-@testable import RunicCore
-
-struct ProviderMetadataStatusLinkTests {
-    @Test
-    func `workspace status link matches product ID`() {
-        for (provider, meta) in ProviderDefaults.metadata {
-            guard let productID = meta.statusWorkspaceProductID else { continue }
-            let expected = "https://www.google.com/appsstatus/dashboard/products/\(productID)/history"
-            #expect(
-                meta.statusLinkURL == expected,
-                "Expected \(provider.rawValue) statusLinkURL to be \(expected)")
-        }
-    }
-}

package/Tests/RunicTests/ProviderRegistryTests.swift

@@ -1,29 +0,0 @@
-import RunicCore
-import XCTest
-
-final class ProviderRegistryTests: XCTestCase {
-    func test_descriptorRegistryIsCompleteAndDeterministic() {
-        let descriptors = ProviderDescriptorRegistry.all
-        let ids = descriptors.map(\.id)
-
-        XCTAssertFalse(descriptors.isEmpty, "ProviderDescriptorRegistry must not be empty.")
-        XCTAssertEqual(Set(ids).count, ids.count, "ProviderDescriptorRegistry contains duplicate IDs.")
-
-        let missing = Set(UsageProvider.allCases).subtracting(ids)
-        XCTAssertTrue(missing.isEmpty, "Missing descriptors for providers: \(missing).")
-
-        let secondPass = ProviderDescriptorRegistry.all.map(\.id)
-        XCTAssertEqual(ids, secondPass, "ProviderDescriptorRegistry order changed between reads.")
-    }
-
-    func test_providerUsageCoverageFlagsForQuotaModelProviders() {
-        let metadata = ProviderDefaults.metadata
-
-        XCTAssertTrue(
-            metadata[.gemini]?.usageCoverage.supportsModelBreakdown == true,
-            "Gemini should advertise model breakdown coverage from quota windows.")
-        XCTAssertTrue(
-            metadata[.antigravity]?.usageCoverage.supportsModelBreakdown == true,
-            "Antigravity should advertise model breakdown coverage from quota windows.")
-    }
-}