@sriinnu/runic 1.0.0

package/Tests/RunicTests/CursorStatusProbeTests.swift

@@ -0,0 +1,323 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct CursorStatusProbeTests {
+    // MARK: - Usage Summary Parsing
+
+    @Test
+    func parsesBasicUsageSummary() 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 = 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 parsesMinimalUsageSummary() throws {
+        let json = """
+        {
+            "membershipType": "hobby",
+            "individualUsage": {
+                "plan": {
+                    "used": 0,
+                    "limit": 2000
+                }
+            }
+        }
+        """
+        let data = 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 parsesEnterpriseUsageSummary() throws {
+        let json = """
+        {
+            "membershipType": "enterprise",
+            "isUnlimited": true,
+            "individualUsage": {
+                "plan": {
+                    "enabled": true,
+                    "used": 50000,
+                    "limit": 100000,
+                    "totalPercentUsed": 50.0
+                }
+            }
+        }
+        """
+        let data = 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 parsesUserInfo() throws {
+        let json = """
+        {
+            "email": "user@example.com",
+            "email_verified": true,
+            "name": "Test User",
+            "sub": "auth0|12345"
+        }
+        """
+        let data = 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 prefersPlanRatioOverPercentField() {
+        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 usesPercentFieldWhenLimitMissing() {
+        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 convertsSnapshotToUsageSnapshot() {
+        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 usesIndividualOnDemandWhenNoTeamUsage() {
+        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 formatsMembershipTypes() {
+        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 handlesNilOnDemandLimit() {
+        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 sessionStoreSavesAndLoadsCookies() async throws {
+        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

@@ -0,0 +1,69 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct FactoryStatusSnapshotTests {
+    @Test
+    func mapsUsageSnapshotWindowsAndLoginMethod() {
+        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 treatsLargeAllowancesAsUnlimited() {
+        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)
+    }
+}
+
+@Suite
+struct FactoryStatusProbeWorkOSTests {
+    @Test
+    func detectsMissingRefreshTokenPayload() {
+        let payload = Data("""
+        {"error":"invalid_request","error_description":"Missing refresh token."}
+        """.utf8)
+
+        #expect(FactoryStatusProbe.isMissingWorkOSRefreshToken(payload))
+    }
+}

package/Tests/RunicTests/GeminiAPITestHelpers.swift

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,28 @@
+import Testing
+@testable import Runic
+
+@Suite
+struct GeminiLoginAlertTests {
+    @Test
+    func returnsAlertForMissingBinary() {
+        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 returnsAlertForLaunchFailure() {
+        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 returnsNilOnSuccess() {
+        let result = GeminiLoginRunner.Result(outcome: .success)
+        let info = StatusItemController.geminiLoginAlertInfo(for: result)
+        #expect(info == nil)
+    }
+}