import Foundationimport Testing@testable import CodexBarCore struct CostUsageScannerClaudeFableTests {    @Test    func `claude fable 5 issue row gets priced`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        let fileURL = try env.writeClaudeProjectFile(            relativePath: "project-a/fable-5.jsonl",            contents: env.jsonl([                [                    "message": [                        "model": "claude-fable-5",                        "id": "msg_fable_5",                        "type": "message",                        "role": "assistant",                        "usage": [                            "input_tokens": 100,                            "cache_creation_input_tokens": 10,                            "cache_read_input_tokens": 20,                            "output_tokens": 5,                        ],                    ],                    "requestId": "req_fable_5",                    "type": "assistant",                    "timestamp": "2026-06-09T12:00:00.000Z",                    "sessionId": "session_fable_5",                ],            ]))         let parsed = CostUsageScanner.parseClaudeFile(            fileURL: fileURL,            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),            providerFilter: .all)         #expect(parsed.rows.count == 1)        #expect(parsed.rows[0].model == "claude-fable-5")        let expected = 0.001395        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)    }     @Test    func `claude transcript refusal remains priced without billing provenance`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        let fileURL = try env.writeClaudeProjectFile(            relativePath: "project-a/fable-5-refusal.jsonl",            contents: env.jsonl([                [                    "message": [                        "model": "claude-fable-5",                        "id": "msg_fable_5_refusal",                        "type": "message",                        "role": "assistant",                        "stop_reason": "refusal",                        "usage": [                            "input_tokens": 100,                            "cache_creation_input_tokens": 10,                            "cache_read_input_tokens": 20,                            "output_tokens": 0,                        ],                    ],                    "requestId": "req_fable_5_refusal",                    "type": "assistant",                    "timestamp": "2026-06-09T12:00:00.000Z",                    "sessionId": "session_fable_5_refusal",                ],            ]))         let parsed = CostUsageScanner.parseClaudeFile(            fileURL: fileURL,            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),            providerFilter: .all)         #expect(parsed.rows.count == 1)        #expect(parsed.rows[0].input == 100)        #expect(parsed.rows[0].cacheCreate == 10)        #expect(parsed.rows[0].cacheRead == 20)        #expect(parsed.rows[0].output == 0)        let expected = 0.001145        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)        #expect(parsed.rows[0].costPriced == true)    }     @Test    func `claude fable 5 prices one hour cache creation tokens`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        let fileURL = try env.writeClaudeProjectFile(            relativePath: "project-a/fable-5-cache-ttl.jsonl",            contents: env.jsonl([                [                    "message": [                        "model": "claude-fable-5",                        "id": "msg_fable_5_cache_ttl",                        "type": "message",                        "role": "assistant",                        "usage": [                            "input_tokens": 100,                            "cache_creation_input_tokens": 30,                            "cache_creation": [                                "ephemeral_5m_input_tokens": 10,                                "ephemeral_1h_input_tokens": 20,                            ],                            "cache_read_input_tokens": 20,                            "output_tokens": 5,                        ],                    ],                    "requestId": "req_fable_5_cache_ttl",                    "type": "assistant",                    "timestamp": "2026-06-09T12:00:00.000Z",                    "sessionId": "session_fable_5_cache_ttl",                ],            ]))         let parsed = CostUsageScanner.parseClaudeFile(            fileURL: fileURL,            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),            providerFilter: .all)         #expect(parsed.rows.count == 1)        #expect(parsed.rows[0].cacheCreate == 30)        #expect(parsed.rows[0].cacheCreate1h == 20)        let expected = 0.001795        #expect(abs((Double(parsed.rows[0].costNanos) / 1_000_000_000) - expected) < 0.000000001)    }     @Test    func `claude cached rows preserve one hour writes for deferred pricing`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        _ = try env.writeClaudeProjectFile(            relativePath: "project-a/custom-cache-ttl.jsonl",            contents: env.jsonl([                [                    "message": [                        "model": "claude-custom-cache-model",                        "id": "msg_custom_cache_ttl",                        "type": "message",                        "role": "assistant",                        "usage": [                            "input_tokens": 100,                            "cache_creation_input_tokens": 30,                            "cache_creation": [                                "ephemeral_5m_input_tokens": 10,                                "ephemeral_1h_input_tokens": 20,                            ],                            "cache_read_input_tokens": 20,                            "output_tokens": 5,                        ],                    ],                    "requestId": "req_custom_cache_ttl",                    "type": "assistant",                    "timestamp": "2026-06-09T12:00:00.000Z",                    "sessionId": "session_custom_cache_ttl",                ],            ]))         var options = CostUsageScanner.Options(            claudeProjectsRoots: [env.claudeProjectsRoot],            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 0         let unpriced = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day,            options: options)        #expect(unpriced.summary?.totalCostUSD == nil)         let cached = CostUsageCacheIO.load(provider: .claude, cacheRoot: env.cacheRoot)        #expect(cached.days["2026-06-09"]?["claude-custom-cache-model"]?[safe: 7] == 20)         try ModelsDevCache.save(            catalog: Self.anthropicModelsDevCatalog(model: "claude-custom-cache-model"),            fetchedAt: day,            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 3600         let repriced = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day.addingTimeInterval(1),            options: options)         let expected = 0.001795        #expect(abs((repriced.summary?.totalCostUSD ?? 0) - expected) < 0.000000001)    }     @Test    func `claude deferred pricing preserves request long context boundaries`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        _ = try env.writeClaudeProjectFile(            relativePath: "project-a/custom-threshold.jsonl",            contents: env.jsonl([                Self.claudeUsageEvent(                    model: "claude-custom-threshold-model",                    messageID: "msg_custom_threshold_1",                    requestID: "req_custom_threshold_1",                    inputTokens: 150_000),                Self.claudeUsageEvent(                    model: "claude-custom-threshold-model",                    messageID: "msg_custom_threshold_2",                    requestID: "req_custom_threshold_2",                    inputTokens: 150_000),            ]))         var options = CostUsageScanner.Options(            claudeProjectsRoots: [env.claudeProjectsRoot],            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 0         let unpriced = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day,            options: options)        #expect(unpriced.summary?.totalCostUSD == nil)         try ModelsDevCache.save(            catalog: Self.anthropicThresholdModelsDevCatalog(model: "claude-custom-threshold-model"),            fetchedAt: day,            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 3600         let repriced = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day.addingTimeInterval(1),            options: options)         #expect(abs((repriced.summary?.totalCostUSD ?? 0) - 3) < 0.000000001)    }     @Test    func `claude cached rows reprice after models dev catalog changes`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 6, day: 9)        let model = "claude-custom-repricing-model"        _ = try env.writeClaudeProjectFile(            relativePath: "project-a/custom-repricing.jsonl",            contents: env.jsonl([                Self.claudeUsageEvent(                    model: model,                    messageID: "msg_custom_repricing",                    requestID: "req_custom_repricing",                    inputTokens: 240_000),            ]))        try ModelsDevCache.save(            catalog: Self.anthropicThresholdModelsDevCatalog(model: model),            fetchedAt: day,            cacheRoot: env.cacheRoot)         var options = CostUsageScanner.Options(            claudeProjectsRoots: [env.claudeProjectsRoot],            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 0         let premium = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day,            options: options)        #expect(abs((premium.summary?.totalCostUSD ?? 0) - 4.8) < 0.000000001)         try ModelsDevCache.save(            catalog: Self.anthropicModelsDevCatalog(model: model),            fetchedAt: day.addingTimeInterval(1),            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 3600         let repriced = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day.addingTimeInterval(2),            options: options)         #expect(abs((repriced.summary?.totalCostUSD ?? 0) - 2.4) < 0.000000001)    }     @Test    func `claude cached historical rows keep original tariff`() throws {        let env = try CostUsageTestEnvironment()        defer { env.cleanup() }         let day = try env.makeLocalNoon(year: 2026, month: 3, day: 12)        _ = try env.writeClaudeProjectFile(            relativePath: "project-a/sonnet-46-historical.jsonl",            contents: env.jsonl([                [                    "message": [                        "model": "claude-sonnet-4-6",                        "id": "msg_sonnet_46_historical",                        "type": "message",                        "role": "assistant",                        "usage": [                            "input_tokens": 240_000,                            "cache_creation_input_tokens": 0,                            "cache_read_input_tokens": 0,                            "output_tokens": 0,                        ],                    ],                    "requestId": "req_sonnet_46_historical",                    "type": "assistant",                    "timestamp": "2026-03-12T12:00:00.000Z",                    "sessionId": "session_sonnet_46_historical",                ],            ]))         var options = CostUsageScanner.Options(            claudeProjectsRoots: [env.claudeProjectsRoot],            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 0         let initial = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day,            options: options)        #expect(abs((initial.summary?.totalCostUSD ?? 0) - 1.44) < 0.000000001)         try ModelsDevCache.save(            catalog: Self.anthropicSonnet46StandardCatalog(),            fetchedAt: day,            cacheRoot: env.cacheRoot)        options.refreshMinIntervalSeconds = 3600         let cached = CostUsageScanner.loadDailyReport(            provider: .claude,            since: day,            until: day,            now: day.addingTimeInterval(1),            options: options)         #expect(abs((cached.summary?.totalCostUSD ?? 0) - 1.44) < 0.000000001)    }     private static func anthropicModelsDevCatalog(model: String) throws -> ModelsDevCatalog {        let json = """        {          "anthropic": {            "id": "anthropic",            "models": {              "\(model)": {                "id": "\(model)",                "cost": {                  "input": 10,                  "output": 50,                  "cache_read": 1,                  "cache_write": 12.5                }              }            }          }        }        """        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))    }     private static func anthropicThresholdModelsDevCatalog(model: String) throws -> ModelsDevCatalog {        let json = """        {          "anthropic": {            "id": "anthropic",            "models": {              "\(model)": {                "id": "\(model)",                "cost": {                  "input": 10,                  "output": 50,                  "cache_read": 1,                  "cache_write": 12.5,                  "context_over_200k": {                    "input": 20,                    "output": 75,                    "cache_read": 2,                    "cache_write": 25                  }                }              }            }          }        }        """        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))    }     private static func anthropicSonnet46StandardCatalog() throws -> ModelsDevCatalog {        let json = """        {          "anthropic": {            "id": "anthropic",            "models": {              "claude-sonnet-4-6": {                "id": "claude-sonnet-4-6",                "cost": {                  "input": 3,                  "output": 15,                  "cache_read": 0.3,                  "cache_write": 3.75                }              }            }          }        }        """        return try JSONDecoder().decode(ModelsDevCatalog.self, from: Data(json.utf8))    }     private static func claudeUsageEvent(        model: String,        messageID: String,        requestID: String,        inputTokens: Int) -> [String: Any]    {        [            "message": [                "model": model,                "id": messageID,                "type": "message",                "role": "assistant",                "usage": [                    "input_tokens": inputTokens,                    "cache_creation_input_tokens": 0,                    "cache_read_input_tokens": 0,                    "output_tokens": 0,                ],            ],            "requestId": requestID,            "type": "assistant",            "timestamp": "2026-06-09T12:00:00.000Z",            "sessionId": "session_\(requestID)",        ]    }}