wehub-resource-sync
309 lines
11 KiB
Swift
309 lines
11 KiB
Swift
import CodexBarCore
|
|
import Foundation
|
|
import Testing
|
|
|
|
@Suite(.serialized)
|
|
struct OpenCodeUsageFetcherErrorTests {
|
|
private func makeSession() -> URLSession {
|
|
let config = URLSessionConfiguration.ephemeral
|
|
config.protocolClasses = [OpenCodeStubURLProtocol.self]
|
|
return URLSession(configuration: config)
|
|
}
|
|
|
|
@Test
|
|
func `extracts api error from uppercase HTML title`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
let body = "<html><head><TITLE>403 Forbidden</TITLE></head><body>denied</body></html>"
|
|
return Self.makeResponse(url: url, body: body, statusCode: 500, contentType: "text/html")
|
|
}
|
|
|
|
do {
|
|
_ = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
Issue.record("Expected OpenCodeUsageError.apiError")
|
|
} catch let error as OpenCodeUsageError {
|
|
switch error {
|
|
case let .apiError(message):
|
|
#expect(message.contains("HTTP 500"))
|
|
#expect(message.contains("403 Forbidden"))
|
|
default:
|
|
Issue.record("Expected apiError, got: \(error)")
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
func `extracts api error from detail field`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
let body = #"{"detail":"Workspace missing"}"#
|
|
return Self.makeResponse(url: url, body: body, statusCode: 500, contentType: "application/json")
|
|
}
|
|
|
|
do {
|
|
_ = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
Issue.record("Expected OpenCodeUsageError.apiError")
|
|
} catch let error as OpenCodeUsageError {
|
|
switch error {
|
|
case let .apiError(message):
|
|
#expect(message.contains("HTTP 500"))
|
|
#expect(message.contains("Workspace missing"))
|
|
default:
|
|
Issue.record("Expected apiError, got: \(error)")
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
func `subscription get null skips post and returns graceful error`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
var methods: [String] = []
|
|
var urls: [URL] = []
|
|
var queries: [String] = []
|
|
var contentTypes: [String] = []
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
methods.append(request.httpMethod ?? "GET")
|
|
urls.append(url)
|
|
queries.append(url.query ?? "")
|
|
contentTypes.append(request.value(forHTTPHeaderField: "Content-Type") ?? "")
|
|
|
|
if request.httpMethod?.uppercased() == "GET" {
|
|
return Self.makeResponse(url: url, body: "null", statusCode: 200, contentType: "application/json")
|
|
}
|
|
|
|
let body = #"{"status":500,"unhandled":true,"message":"HTTPError"}"#
|
|
return Self.makeResponse(url: url, body: body, statusCode: 500, contentType: "application/json")
|
|
}
|
|
|
|
do {
|
|
_ = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
Issue.record("Expected OpenCodeUsageError.apiError")
|
|
} catch let error as OpenCodeUsageError {
|
|
switch error {
|
|
case let .apiError(message):
|
|
#expect(message.contains("No subscription usage data"))
|
|
#expect(message.contains("wrk_TEST123"))
|
|
default:
|
|
Issue.record("Expected apiError, got: \(error)")
|
|
}
|
|
}
|
|
|
|
#expect(methods == ["GET"])
|
|
#expect(queries[0].contains("id="))
|
|
#expect(queries[0].contains("wrk_TEST123"))
|
|
#expect(urls[0].path == "/_server")
|
|
#expect(contentTypes[0].isEmpty)
|
|
}
|
|
|
|
@Test
|
|
func `subscription get payload does not fallback to post`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
var methods: [String] = []
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
methods.append(request.httpMethod ?? "GET")
|
|
|
|
let body = """
|
|
{
|
|
"rollingUsage": { "usagePercent": 17, "resetInSec": 600 },
|
|
"weeklyUsage": { "usagePercent": 75, "resetInSec": 7200 }
|
|
}
|
|
"""
|
|
return Self.makeResponse(url: url, body: body, statusCode: 200, contentType: "application/json")
|
|
}
|
|
|
|
let snapshot = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
|
|
#expect(snapshot.rollingUsagePercent == 17)
|
|
#expect(snapshot.weeklyUsagePercent == 75)
|
|
#expect(methods == ["GET"])
|
|
}
|
|
|
|
@Test
|
|
func `workspace get public actor error is treated as invalid credentials without post retry`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
var methods: [String] = []
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
methods.append(request.httpMethod ?? "GET")
|
|
let body = [
|
|
#";0x00000263;((self.$R=self.$R||{})["server-fn:test"]=[],"#,
|
|
#"($R=>$R[0]=Object.assign(new Error("actor of type \"public\" is not associated with an account"),"#,
|
|
#"{stack:"Error: actor of type \"public\" is not associated with an account"}))"#,
|
|
#"($R["server-fn:test"]))"#,
|
|
].joined()
|
|
return Self.makeResponse(
|
|
url: url,
|
|
body: body,
|
|
statusCode: 200,
|
|
contentType: "text/javascript")
|
|
}
|
|
|
|
do {
|
|
_ = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
session: self.makeSession())
|
|
Issue.record("Expected OpenCodeUsageError.invalidCredentials")
|
|
} catch let error as OpenCodeUsageError {
|
|
switch error {
|
|
case .invalidCredentials:
|
|
break
|
|
default:
|
|
Issue.record("Expected invalidCredentials, got: \(error)")
|
|
}
|
|
}
|
|
|
|
#expect(methods == ["GET"])
|
|
}
|
|
|
|
@Test
|
|
func `subscription get missing fields falls back to post`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
var methods: [String] = []
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
methods.append(request.httpMethod ?? "GET")
|
|
|
|
if request.httpMethod?.uppercased() == "GET" {
|
|
return Self.makeResponse(
|
|
url: url,
|
|
body: #"{"ok":true}"#,
|
|
statusCode: 200,
|
|
contentType: "application/json")
|
|
}
|
|
|
|
let body = """
|
|
{
|
|
"rollingUsage": { "usagePercent": 22, "resetInSec": 300 },
|
|
"weeklyUsage": { "usagePercent": 44, "resetInSec": 3600 }
|
|
}
|
|
"""
|
|
return Self.makeResponse(
|
|
url: url,
|
|
body: body,
|
|
statusCode: 200,
|
|
contentType: "application/json")
|
|
}
|
|
|
|
let snapshot = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
|
|
#expect(snapshot.rollingUsagePercent == 22)
|
|
#expect(snapshot.weeklyUsagePercent == 44)
|
|
#expect(methods == ["GET", "POST"])
|
|
}
|
|
|
|
@Test
|
|
func `fetcher sends only auth cookie to opencode host`() async throws {
|
|
defer {
|
|
OpenCodeStubURLProtocol.handler = nil
|
|
}
|
|
|
|
var observedCookie: String?
|
|
OpenCodeStubURLProtocol.handler = { request in
|
|
guard let url = request.url else { throw URLError(.badURL) }
|
|
observedCookie = request.value(forHTTPHeaderField: "Cookie")
|
|
|
|
let body = """
|
|
{
|
|
"rollingUsage": { "usagePercent": 17, "resetInSec": 600 },
|
|
"weeklyUsage": { "usagePercent": 75, "resetInSec": 7200 }
|
|
}
|
|
"""
|
|
return Self.makeResponse(url: url, body: body, statusCode: 200, contentType: "application/json")
|
|
}
|
|
|
|
_ = try await OpenCodeUsageFetcher.fetchUsage(
|
|
cookieHeader: "provider=google; auth=test",
|
|
timeout: 2,
|
|
workspaceIDOverride: "wrk_TEST123",
|
|
session: self.makeSession())
|
|
|
|
#expect(observedCookie == "auth=test")
|
|
}
|
|
|
|
private static func makeResponse(
|
|
url: URL,
|
|
body: String,
|
|
statusCode: Int,
|
|
contentType: String) -> (HTTPURLResponse, Data)
|
|
{
|
|
let response = HTTPURLResponse(
|
|
url: url,
|
|
statusCode: statusCode,
|
|
httpVersion: "HTTP/1.1",
|
|
headerFields: ["Content-Type": contentType])!
|
|
return (response, Data(body.utf8))
|
|
}
|
|
}
|
|
|
|
final class OpenCodeStubURLProtocol: URLProtocol {
|
|
nonisolated(unsafe) static var handler: ((URLRequest) throws -> (HTTPURLResponse, Data))?
|
|
|
|
override static func canInit(with request: URLRequest) -> Bool {
|
|
request.url?.host == "opencode.ai"
|
|
}
|
|
|
|
override static func canonicalRequest(for request: URLRequest) -> URLRequest {
|
|
request
|
|
}
|
|
|
|
override func startLoading() {
|
|
guard let handler = Self.handler else {
|
|
self.client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
|
|
return
|
|
}
|
|
do {
|
|
let (response, data) = try handler(self.request)
|
|
self.client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
|
|
self.client?.urlProtocol(self, didLoad: data)
|
|
self.client?.urlProtocolDidFinishLoading(self)
|
|
} catch {
|
|
self.client?.urlProtocol(self, didFailWithError: error)
|
|
}
|
|
}
|
|
|
|
override func stopLoading() {}
|
|
}
|