@sriinnu/runic 2.0.0 → 2.11.1

package/Tests/RunicTests/CursorStatusProbeTests.swift

@@ -1,322 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct CursorStatusProbeTests {
-    // MARK: - Usage Summary Parsing
-
-    @Test
-    func `parses basic usage summary`() throws {
-        let json = """
-        {
-            "billingCycleStart": "2025-01-01T00:00:00.000Z",
-            "billingCycleEnd": "2025-02-01T00:00:00.000Z",
-            "membershipType": "pro",
-            "individualUsage": {
-                "plan": {
-                    "enabled": true,
-                    "used": 1500,
-                    "limit": 5000,
-                    "remaining": 3500,
-                    "totalPercentUsed": 30.0
-                },
-                "onDemand": {
-                    "enabled": true,
-                    "used": 500,
-                    "limit": 10000,
-                    "remaining": 9500
-                }
-            },
-            "teamUsage": {
-                "onDemand": {
-                    "enabled": true,
-                    "used": 2000,
-                    "limit": 50000,
-                    "remaining": 48000
-                }
-            }
-        }
-        """
-        let data = try #require(json.data(using: .utf8))
-        let summary = try JSONDecoder().decode(CursorUsageSummary.self, from: data)
-
-        #expect(summary.membershipType == "pro")
-        #expect(summary.individualUsage?.plan?.used == 1500)
-        #expect(summary.individualUsage?.plan?.limit == 5000)
-        #expect(summary.individualUsage?.plan?.totalPercentUsed == 30.0)
-        #expect(summary.individualUsage?.onDemand?.used == 500)
-        #expect(summary.teamUsage?.onDemand?.used == 2000)
-        #expect(summary.teamUsage?.onDemand?.limit == 50000)
-    }
-
-    @Test
-    func `parses minimal usage summary`() throws {
-        let json = """
-        {
-            "membershipType": "hobby",
-            "individualUsage": {
-                "plan": {
-                    "used": 0,
-                    "limit": 2000
-                }
-            }
-        }
-        """
-        let data = try #require(json.data(using: .utf8))
-        let summary = try JSONDecoder().decode(CursorUsageSummary.self, from: data)
-
-        #expect(summary.membershipType == "hobby")
-        #expect(summary.individualUsage?.plan?.used == 0)
-        #expect(summary.individualUsage?.plan?.limit == 2000)
-        #expect(summary.teamUsage == nil)
-    }
-
-    @Test
-    func `parses enterprise usage summary`() throws {
-        let json = """
-        {
-            "membershipType": "enterprise",
-            "isUnlimited": true,
-            "individualUsage": {
-                "plan": {
-                    "enabled": true,
-                    "used": 50000,
-                    "limit": 100000,
-                    "totalPercentUsed": 50.0
-                }
-            }
-        }
-        """
-        let data = try #require(json.data(using: .utf8))
-        let summary = try JSONDecoder().decode(CursorUsageSummary.self, from: data)
-
-        #expect(summary.membershipType == "enterprise")
-        #expect(summary.isUnlimited == true)
-        #expect(summary.individualUsage?.plan?.totalPercentUsed == 50.0)
-    }
-
-    // MARK: - User Info Parsing
-
-    @Test
-    func `parses user info`() throws {
-        let json = """
-        {
-            "email": "user@example.com",
-            "email_verified": true,
-            "name": "Test User",
-            "sub": "auth0|12345"
-        }
-        """
-        let data = try #require(json.data(using: .utf8))
-        let userInfo = try JSONDecoder().decode(CursorUserInfo.self, from: data)
-
-        #expect(userInfo.email == "user@example.com")
-        #expect(userInfo.emailVerified == true)
-        #expect(userInfo.name == "Test User")
-        #expect(userInfo.sub == "auth0|12345")
-    }
-
-    // MARK: - Snapshot Conversion
-
-    @Test
-    func `prefers plan ratio over percent field`() {
-        let snapshot = CursorStatusProbe()
-            .parseUsageSummary(
-                CursorUsageSummary(
-                    billingCycleStart: nil,
-                    billingCycleEnd: nil,
-                    membershipType: "enterprise",
-                    limitType: nil,
-                    isUnlimited: false,
-                    autoModelSelectedDisplayMessage: nil,
-                    namedModelSelectedDisplayMessage: nil,
-                    individualUsage: CursorIndividualUsage(
-                        plan: CursorPlanUsage(
-                            enabled: true,
-                            used: 4900,
-                            limit: 50000,
-                            remaining: nil,
-                            breakdown: nil,
-                            autoPercentUsed: nil,
-                            apiPercentUsed: nil,
-                            totalPercentUsed: 0.40625),
-                        onDemand: nil),
-                    teamUsage: nil),
-                userInfo: nil)
-
-        #expect(snapshot.planPercentUsed == 9.8)
-    }
-
-    @Test
-    func `uses percent field when limit missing`() {
-        let snapshot = CursorStatusProbe()
-            .parseUsageSummary(
-                CursorUsageSummary(
-                    billingCycleStart: nil,
-                    billingCycleEnd: nil,
-                    membershipType: "pro",
-                    limitType: nil,
-                    isUnlimited: false,
-                    autoModelSelectedDisplayMessage: nil,
-                    namedModelSelectedDisplayMessage: nil,
-                    individualUsage: CursorIndividualUsage(
-                        plan: CursorPlanUsage(
-                            enabled: true,
-                            used: 0,
-                            limit: nil,
-                            remaining: nil,
-                            breakdown: nil,
-                            autoPercentUsed: nil,
-                            apiPercentUsed: nil,
-                            totalPercentUsed: 0.5),
-                        onDemand: nil),
-                    teamUsage: nil),
-                userInfo: nil)
-
-        #expect(snapshot.planPercentUsed == 50.0)
-    }
-
-    @Test
-    func `converts snapshot to usage snapshot`() {
-        let snapshot = CursorStatusSnapshot(
-            planPercentUsed: 45.0,
-            planUsedUSD: 22.50,
-            planLimitUSD: 50.0,
-            onDemandUsedUSD: 5.0,
-            onDemandLimitUSD: 100.0,
-            teamOnDemandUsedUSD: 25.0,
-            teamOnDemandLimitUSD: 500.0,
-            billingCycleEnd: Date(timeIntervalSince1970: 1_738_368_000), // Feb 1, 2025
-            membershipType: "pro",
-            accountEmail: "user@example.com",
-            accountName: "Test User",
-            rawJSON: nil)
-
-        let usageSnapshot = snapshot.toUsageSnapshot()
-
-        #expect(usageSnapshot.primary.usedPercent == 45.0)
-        #expect(usageSnapshot.accountEmail(for: .cursor) == "user@example.com")
-        #expect(usageSnapshot.loginMethod(for: .cursor) == "Cursor Pro")
-        #expect(usageSnapshot.secondary != nil)
-        #expect(usageSnapshot.secondary?.usedPercent == 5.0)
-        #expect(usageSnapshot.providerCost?.used == 25.0)
-        #expect(usageSnapshot.providerCost?.limit == 500.0)
-        #expect(usageSnapshot.providerCost?.currencyCode == "USD")
-    }
-
-    @Test
-    func `uses individual on demand when no team usage`() {
-        let snapshot = CursorStatusSnapshot(
-            planPercentUsed: 10.0,
-            planUsedUSD: 5.0,
-            planLimitUSD: 50.0,
-            onDemandUsedUSD: 12.0,
-            onDemandLimitUSD: 60.0,
-            teamOnDemandUsedUSD: nil,
-            teamOnDemandLimitUSD: nil,
-            billingCycleEnd: nil,
-            membershipType: "pro",
-            accountEmail: nil,
-            accountName: nil,
-            rawJSON: nil)
-
-        let usageSnapshot = snapshot.toUsageSnapshot()
-
-        #expect(usageSnapshot.secondary?.usedPercent == 20.0)
-        #expect(usageSnapshot.providerCost?.used == 12.0)
-        #expect(usageSnapshot.providerCost?.limit == 60.0)
-    }
-
-    @Test
-    func `formats membership types`() {
-        let testCases: [(input: String, expected: String)] = [
-            ("pro", "Cursor Pro"),
-            ("hobby", "Cursor Hobby"),
-            ("enterprise", "Cursor Enterprise"),
-            ("team", "Cursor Team"),
-            ("custom", "Cursor Custom"),
-        ]
-
-        for testCase in testCases {
-            let snapshot = CursorStatusSnapshot(
-                planPercentUsed: 0,
-                planUsedUSD: 0,
-                planLimitUSD: 0,
-                onDemandUsedUSD: 0,
-                onDemandLimitUSD: nil,
-                teamOnDemandUsedUSD: nil,
-                teamOnDemandLimitUSD: nil,
-                billingCycleEnd: nil,
-                membershipType: testCase.input,
-                accountEmail: nil,
-                accountName: nil,
-                rawJSON: nil)
-
-            let usageSnapshot = snapshot.toUsageSnapshot()
-            #expect(usageSnapshot.loginMethod(for: .cursor) == testCase.expected)
-        }
-    }
-
-    @Test
-    func `handles nil on demand limit`() {
-        let snapshot = CursorStatusSnapshot(
-            planPercentUsed: 50.0,
-            planUsedUSD: 25.0,
-            planLimitUSD: 50.0,
-            onDemandUsedUSD: 10.0,
-            onDemandLimitUSD: nil,
-            teamOnDemandUsedUSD: nil,
-            teamOnDemandLimitUSD: nil,
-            billingCycleEnd: nil,
-            membershipType: "pro",
-            accountEmail: nil,
-            accountName: nil,
-            rawJSON: nil)
-
-        let usageSnapshot = snapshot.toUsageSnapshot()
-
-        // Should still have provider cost
-        #expect(usageSnapshot.providerCost != nil)
-        #expect(usageSnapshot.providerCost?.used == 10.0)
-        #expect(usageSnapshot.providerCost?.limit == 0.0)
-        // Secondary should be nil when no on-demand limit
-        #expect(usageSnapshot.secondary == nil)
-    }
-
-    // MARK: - Session Store Serialization
-
-    @Test
-    func `session store saves and loads cookies`() async {
-        let store = CursorSessionStore.shared
-
-        // Clear any existing cookies
-        await store.clearCookies()
-
-        // Create test cookies with Date properties
-        let cookieProps: [HTTPCookiePropertyKey: Any] = [
-            .name: "testCookie",
-            .value: "testValue",
-            .domain: "cursor.com",
-            .path: "/",
-            .expires: Date(timeIntervalSince1970: 1_800_000_000),
-            .secure: true,
-        ]
-
-        guard let cookie = HTTPCookie(properties: cookieProps) else {
-            Issue.record("Failed to create test cookie")
-            return
-        }
-
-        // Save cookies
-        await store.setCookies([cookie])
-
-        // Verify cookies are stored
-        let storedCookies = await store.getCookies()
-        #expect(storedCookies.count == 1)
-        #expect(storedCookies.first?.name == "testCookie")
-        #expect(storedCookies.first?.value == "testValue")
-
-        // Clean up
-        await store.clearCookies()
-    }
-}

package/Tests/RunicTests/FactoryStatusProbeTests.swift

@@ -1,67 +0,0 @@
-import Foundation
-import Testing
-@testable import RunicCore
-
-struct FactoryStatusSnapshotTests {
-    @Test
-    func `maps usage snapshot windows and login method`() {
-        let periodEnd = Date(timeIntervalSince1970: 1_738_368_000) // Feb 1, 2025
-        let snapshot = FactoryStatusSnapshot(
-            standardUserTokens: 50,
-            standardOrgTokens: 0,
-            standardAllowance: 100,
-            premiumUserTokens: 25,
-            premiumOrgTokens: 0,
-            premiumAllowance: 50,
-            periodStart: nil,
-            periodEnd: periodEnd,
-            planName: "Pro",
-            tier: "enterprise",
-            organizationName: "Acme",
-            accountEmail: "user@example.com",
-            userId: "user-1",
-            rawJSON: nil)
-
-        let usage = snapshot.toUsageSnapshot()
-
-        #expect(usage.primary.usedPercent == 50)
-        #expect(usage.primary.resetsAt == periodEnd)
-        #expect(usage.primary.resetDescription?.hasPrefix("Resets ") == true)
-        #expect(usage.secondary?.usedPercent == 50)
-        #expect(usage.loginMethod(for: .factory) == "Factory Enterprise - Pro")
-    }
-
-    @Test
-    func `treats large allowances as unlimited`() {
-        let snapshot = FactoryStatusSnapshot(
-            standardUserTokens: 50_000_000,
-            standardOrgTokens: 0,
-            standardAllowance: 2_000_000_000_000,
-            premiumUserTokens: 0,
-            premiumOrgTokens: 0,
-            premiumAllowance: 0,
-            periodStart: nil,
-            periodEnd: nil,
-            planName: nil,
-            tier: nil,
-            organizationName: nil,
-            accountEmail: nil,
-            userId: nil,
-            rawJSON: nil)
-
-        let usage = snapshot.toUsageSnapshot()
-
-        #expect(usage.primary.usedPercent == 50)
-    }
-}
-
-struct FactoryStatusProbeWorkOSTests {
-    @Test
-    func `detects missing refresh token payload`() {
-        let payload = Data("""
-        {"error":"invalid_request","error_description":"Missing refresh token."}
-        """.utf8)
-
-        #expect(FactoryStatusProbe.isMissingWorkOSRefreshToken(payload))
-    }
-}

package/Tests/RunicTests/GeminiAPITestHelpers.swift

@@ -1,94 +0,0 @@
-import Foundation
-
-enum GeminiAPITestHelpers {
-    static func dataLoader(
-        handler: @escaping @Sendable (URLRequest) throws -> (HTTPURLResponse, Data))
-        -> @Sendable (URLRequest) async throws -> (Data, URLResponse)
-    {
-        { request in
-            let (response, data) = try handler(request)
-            return (data, response)
-        }
-    }
-
-    static func response(url: String, status: Int, body: Data) -> (HTTPURLResponse, Data) {
-        let response = HTTPURLResponse(
-            url: URL(string: url)!,
-            statusCode: status,
-            httpVersion: nil,
-            headerFields: ["Content-Type": "application/json"])!
-        return (response, body)
-    }
-
-    static func jsonData(_ payload: [String: Any]) -> Data {
-        (try? JSONSerialization.data(withJSONObject: payload)) ?? Data()
-    }
-
-    static func sampleQuotaResponse() -> Data {
-        self.jsonData([
-            "buckets": [
-                [
-                    "modelId": "gemini-2.5-pro",
-                    "remainingFraction": 0.6,
-                    "resetTime": "2025-01-01T00:00:00Z",
-                ],
-                [
-                    "modelId": "gemini-2.5-flash",
-                    "remainingFraction": 0.9,
-                    "resetTime": "2025-01-01T00:00:00Z",
-                ],
-            ],
-        ])
-    }
-
-    static func sampleFlashQuotaResponse() -> Data {
-        self.jsonData([
-            "buckets": [
-                [
-                    "modelId": "gemini-2.5-flash",
-                    "remainingFraction": 0.9,
-                    "resetTime": "2025-01-01T00:00:00Z",
-                ],
-                [
-                    "modelId": "gemini-2.5-flash",
-                    "remainingFraction": 0.4,
-                    "resetTime": "2025-01-01T00:00:00Z",
-                ],
-            ],
-        ])
-    }
-
-    static func makeIDToken(email: String, hostedDomain: String? = nil) -> String {
-        var payload: [String: Any] = ["email": email]
-        if let hd = hostedDomain {
-            payload["hd"] = hd
-        }
-        let data = (try? JSONSerialization.data(withJSONObject: payload)) ?? Data()
-        var encoded = data.base64EncodedString()
-        encoded = encoded.replacingOccurrences(of: "+", with: "-")
-        encoded = encoded.replacingOccurrences(of: "/", with: "_")
-        encoded = encoded.replacingOccurrences(of: "=", with: "")
-        return "header.\(encoded).sig"
-    }
-
-    static func loadCodeAssistResponse(tierId: String) -> Data {
-        self.jsonData([
-            "currentTier": [
-                "id": tierId,
-                "name": tierId.replacingOccurrences(of: "-tier", with: ""),
-            ],
-        ])
-    }
-
-    static func loadCodeAssistFreeTierResponse() -> Data {
-        self.loadCodeAssistResponse(tierId: "free-tier")
-    }
-
-    static func loadCodeAssistStandardTierResponse() -> Data {
-        self.loadCodeAssistResponse(tierId: "standard-tier")
-    }
-
-    static func loadCodeAssistLegacyTierResponse() -> Data {
-        self.loadCodeAssistResponse(tierId: "legacy-tier")
-    }
-}

package/Tests/RunicTests/GeminiLoginAlertTests.swift

@@ -1,27 +0,0 @@
-import Testing
-@testable import Runic
-
-struct GeminiLoginAlertTests {
-    @Test
-    func `returns alert for missing binary`() {
-        let result = GeminiLoginRunner.Result(outcome: .missingBinary)
-        let info = StatusItemController.geminiLoginAlertInfo(for: result)
-        #expect(info?.title == "Gemini CLI not found")
-        #expect(info?.message == "Install the Gemini CLI (npm i -g @google/gemini-cli) and try again.")
-    }
-
-    @Test
-    func `returns alert for launch failure`() {
-        let result = GeminiLoginRunner.Result(outcome: .launchFailed("Boom"))
-        let info = StatusItemController.geminiLoginAlertInfo(for: result)
-        #expect(info?.title == "Could not open Terminal for Gemini")
-        #expect(info?.message == "Boom")
-    }
-
-    @Test
-    func `returns nil on success`() {
-        let result = GeminiLoginRunner.Result(outcome: .success)
-        let info = StatusItemController.geminiLoginAlertInfo(for: result)
-        #expect(info == nil)
-    }
-}