Add test infrastructure: mocks, fixtures, HTTPClient + RateLimiter tests

- MockHTTPTransport & MockWebSocketTransport actors for deterministic testing
- Expanded TestFixtures: Channel, GuildMember, Embed, Thread, Components, PresenceUpdate
- Expanded CacheTests: user/channel/guild/role CRUD, messages, clear, removeUser
- New HTTPClientTests: GET, rate limit headers, 429 retry, route key parsing
- New RateLimiterTests: 50/s global limit, bucket tracking, reset/clear
- HTTPClient.makeRouteKey promoted to internal for test access

Author: M1tsumi

Sources/SwiftDisc/REST/HTTPClient.swift

@@ -494,7 +494,7 @@ final class HTTPClient: @unchecked Sendable {
         return body
     }
 
-    private func makeRouteKey(method: String, path: String) -> String {
+    func makeRouteKey(method: String, path: String) -> String {
         let components = path.split(separator: "/").map { String($0) }
         var majorParam: String?
         var majorParamIndex: Int?

Tests/SwiftDiscTests/CacheTests.swift

@@ -17,4 +17,117 @@ final class CacheTests: XCTestCase {
         XCTAssertEqual(recent.count, 1)
         XCTAssertEqual(recent.first?.id, "m2")
     }
+
+    func testUpsertAndGetUser() async throws {
+        let cache = Cache()
+        let user = try TestFixtures.makeUser(id: "u100", username: "alice")
+        await cache.upsert(user: user)
+        let retrieved = await cache.getUser(id: UserID("u100"))
+        XCTAssertEqual(retrieved?.username, "alice")
+        XCTAssertEqual(retrieved?.id.rawValue, "u100")
+    }
+
+    func testUpsertAndGetChannel() async throws {
+        let cache = Cache()
+        let channel = TestFixtures.makeChannel(id: "ch1", name: "test-channel")
+        await cache.upsert(channel: channel)
+        let retrieved = await cache.getChannel(id: ChannelID("ch1"))
+        XCTAssertEqual(retrieved?.name, "test-channel")
+        XCTAssertEqual(retrieved?.type, .guildText)
+    }
+
+    func testUpsertAndGetGuild() async throws {
+        let cache = Cache()
+        let guild = try TestFixtures.makeGuild(id: "g100", name: "Test Server")
+        await cache.upsert(guild: guild)
+        let retrieved = await cache.getGuild(id: GuildID("g100"))
+        XCTAssertEqual(retrieved?.name, "Test Server")
+        XCTAssertEqual(retrieved?.id.rawValue, "g100")
+    }
+
+    func testUpsertAndGetRole() async {
+        let cache = Cache()
+        let role = TestFixtures.makeRole(id: "r10", name: "Moderator")
+        await cache.upsert(role: role, guildId: GuildID("g1"))
+        let retrieved = await cache.getRole(id: RoleID("r10"), guildId: GuildID("g1"))
+        XCTAssertEqual(retrieved?.name, "Moderator")
+    }
+
+    func testAddAndGetMessages() async throws {
+        let cache = Cache()
+        let user = try TestFixtures.makeUser()
+        let msg1 = try TestFixtures.makeMessage(id: "m1", channelId: "c1", content: "first", author: user)
+        let msg2 = try TestFixtures.makeMessage(id: "m2", channelId: "c1", content: "second", author: user)
+
+        await cache.add(message: msg1)
+        await cache.add(message: msg2)
+
+        let messages = await cache.getMessages(channelId: ChannelID("c1"))
+        XCTAssertEqual(messages.count, 2)
+        XCTAssertEqual(messages[0].content, "first")
+        XCTAssertEqual(messages[1].content, "second")
+    }
+
+    func testRemoveUser() async throws {
+        let cache = Cache()
+        let user = try TestFixtures.makeUser(id: "u_remove")
+        await cache.upsert(user: user)
+        var retrieved = await cache.getUser(id: UserID("u_remove"))
+        XCTAssertNotNil(retrieved)
+        await cache.removeUser(id: UserID("u_remove"))
+        retrieved = await cache.getUser(id: UserID("u_remove"))
+        XCTAssertNil(retrieved)
+    }
+
+    func testClearCache() async throws {
+        let cache = Cache()
+        let user = try TestFixtures.makeUser(id: "u1")
+        let channel = TestFixtures.makeChannel(id: "ch1")
+        let guild = try TestFixtures.makeGuild(id: "g1")
+        await cache.upsert(user: user)
+        await cache.upsert(channel: channel)
+        await cache.upsert(guild: guild)
+
+        await cache.clear()
+
+        XCTAssertNil(await cache.getUser(id: UserID("u1")))
+        XCTAssertNil(await cache.getChannel(id: ChannelID("ch1")))
+        XCTAssertNil(await cache.getGuild(id: GuildID("g1")))
+    }
+
+    func testRemoveMessagesForChannel() async throws {
+        let cache = Cache()
+        let user = try TestFixtures.makeUser()
+        let msg1 = try TestFixtures.makeMessage(id: "m1", channelId: "c_rm", content: "a", author: user)
+        let msg2 = try TestFixtures.makeMessage(id: "m2", channelId: "c_rm", content: "b", author: user)
+        let msg3 = try TestFixtures.makeMessage(id: "m3", channelId: "c_other", content: "c", author: user)
+
+        await cache.add(message: msg1)
+        await cache.add(message: msg2)
+        await cache.add(message: msg3)
+
+        await cache.removeMessagesForChannel(channelId: ChannelID("c_rm"))
+
+        let remaining = await cache.getMessages(channelId: ChannelID("c_rm"))
+        XCTAssertTrue(remaining.isEmpty)
+        let otherMessages = await cache.getMessages(channelId: ChannelID("c_other"))
+        XCTAssertEqual(otherMessages.count, 1)
+    }
+
+    func testEnsureChannelStub() async throws {
+        let cache = Cache()
+        await cache.ensureChannelStub(id: ChannelID("stub1"), type: .guildText)
+        let channel = await cache.getChannel(id: ChannelID("stub1"))
+        XCTAssertNotNil(channel)
+        XCTAssertEqual(channel?.id.rawValue, "stub1")
+        XCTAssertEqual(channel?.type, .guildText)
+
+        // Ensure it does not overwrite existing
+        let existing = TestFixtures.makeChannel(id: "stub1", name: "real-name")
+        await cache.upsert(channel: existing)
+        await cache.ensureChannelStub(id: ChannelID("stub1"), type: .dm)
+        let after = await cache.getChannel(id: ChannelID("stub1"))
+        XCTAssertEqual(after?.name, "real-name")
+        XCTAssertEqual(after?.type, .guildText)
+    }
 }

Tests/SwiftDiscTests/HTTPClientTests.swift

@@ -0,0 +1,102 @@
+import XCTest
+@testable import SwiftDisc
+
+final class HTTPClientTests: XCTestCase {
+    private struct TestResponse: Codable, Sendable {
+        let id: String
+        let value: String
+    }
+
+    func testBasicGETRequest() async throws {
+        let transport = MockHTTPTransport()
+        let config = DiscordConfiguration()
+        let client = HTTPClient(token: "test_token", configuration: config, transport: transport)
+
+        let responseData = try JSONEncoder().encode(TestResponse(id: "42", value: "hello"))
+        let path = "/v10/test/endpoint"
+        await transport.addResponse(for: path, data: responseData)
+
+        let result: TestResponse = try await client.get(path: "test/endpoint")
+        XCTAssertEqual(result.id, "42")
+        XCTAssertEqual(result.value, "hello")
+    }
+
+    func testRateLimitHeaderParsing() async throws {
+        var capturedEvent: RateLimitEvent?
+        let config = DiscordConfiguration(onRateLimit: { event in
+            capturedEvent = event
+        })
+        let transport = MockHTTPTransport()
+        let client = HTTPClient(token: "test_token", configuration: config, transport: transport)
+
+        let responseData = try JSONEncoder().encode(["ok": true])
+        let path = "/v10/channels/123/messages"
+        await transport.addResponse(
+            for: path,
+            data: responseData,
+            headers: [
+                "X-RateLimit-Remaining": "4",
+                "X-RateLimit-Reset-After": "0.5",
+                "X-RateLimit-Limit": "5"
+            ]
+        )
+
+        let result: [String: Bool] = try await client.get(path: "channels/123/messages")
+        XCTAssertEqual(result["ok"], true)
+
+        let event = try XCTUnwrap(capturedEvent)
+        XCTAssertEqual(event.remaining, 4)
+        XCTAssertEqual(event.limit, 5)
+        XCTAssertFalse(event.isGlobal)
+    }
+
+    func test429RetryWithBackoff() async throws {
+        let transport = MockHTTPTransport()
+        let config = DiscordConfiguration()
+        let client = HTTPClient(token: "test_token", configuration: config, transport: transport)
+
+        let successData = try JSONEncoder().encode(TestResponse(id: "1", value: "ok"))
+        let path = "/v10/guilds/111/channels"
+
+        // First call returns 429 with minimal retry-after
+        await transport.addResponse(
+            for: path,
+            data: Data("\"rate limited\"".utf8),
+            statusCode: 429,
+            headers: ["Retry-After": "0.001"]
+        )
+        // Second call (retry) returns success
+        await transport.addResponse(
+            for: path,
+            data: successData,
+            statusCode: 200
+        )
+
+        let result: TestResponse = try await client.get(path: "guilds/111/channels")
+        XCTAssertEqual(result.id, "1")
+        XCTAssertEqual(result.value, "ok")
+    }
+
+    func testMakeRouteKeySimplePath() throws {
+        let client = HTTPClient(token: "t", configuration: DiscordConfiguration())
+
+        let key = client.makeRouteKey(method: "GET", path: "channels/123/messages")
+        XCTAssertEqual(key, "GET:channels/123/messages|major=123")
+    }
+
+    func testMakeRouteKeyWithSnowflakes() throws {
+        let client = HTTPClient(token: "t", configuration: DiscordConfiguration())
+
+        let noMajor = client.makeRouteKey(method: "POST", path: "some/endpoint")
+        XCTAssertEqual(noMajor, "POST:some/endpoint|major=global")
+
+        let channelId = client.makeRouteKey(method: "GET", path: "channels/987654321098765432/messages/12345")
+        XCTAssertEqual(channelId, "GET:channels/987654321098765432/messages/:id|major=987654321098765432")
+
+        let guildId = client.makeRouteKey(method: "GET", path: "guilds/111111111111111111/channels")
+        XCTAssertEqual(guildId, "GET:guilds/111111111111111111/channels|major=111111111111111111")
+
+        let webhook = client.makeRouteKey(method: "POST", path: "webhooks/555555555555555555/abcdef123")
+        XCTAssertEqual(webhook, "POST:webhooks/555555555555555555/abcdef123|major=555555555555555555")
+    }
+}

Tests/SwiftDiscTests/MockTransport.swift

@@ -0,0 +1,113 @@
+import Foundation
+@testable import SwiftDisc
+
+/// A mock HTTP transport that returns pre-configured responses.
+actor MockHTTPTransport: HTTPTransport {
+    private var responseQueues: [String: [(data: Data, statusCode: Int, headers: [String: String])]] = [:]
+    private var requestedPaths: [String] = []
+
+    func addResponse(for path: String, data: Data, statusCode: Int = 200, headers: [String: String] = [:]) {
+        var queue = responseQueues[path] ?? []
+        queue.append((data, statusCode, headers))
+        responseQueues[path] = queue
+    }
+
+    func request(method: String, url: URL, body: Data?, headers: [String: String]?) async throws -> HTTPResponse {
+        let path = url.path
+        requestedPaths.append("\(method):\(path)")
+        guard var queue = responseQueues[path], !queue.isEmpty else {
+            throw DiscordError.http(statusCode: 404, message: "No mock response for \(path)")
+        }
+        let response = queue.removeFirst()
+        if queue.isEmpty {
+            responseQueues.removeValue(forKey: path)
+        } else {
+            responseQueues[path] = queue
+        }
+        return HTTPResponse(data: response.data, statusCode: response.statusCode, headers: response.headers)
+    }
+
+    func getRequestedPaths() -> [String] { requestedPaths }
+
+    func reset() {
+        responseQueues.removeAll()
+        requestedPaths.removeAll()
+    }
+}
+
+/// A mock WebSocket transport that simulates gateway events.
+actor MockWebSocketTransport: WebSocketTransport {
+    private var messages: [WebSocketMessage] = []
+    private var sentMessages: [String] = []
+    private var _closeCode: Int? = nil
+    private var _shouldThrowOnReceive = false
+
+    var closeCode: Int? { _closeCode }
+
+    func addMessage(_ message: WebSocketMessage) { messages.append(message) }
+    func addString(_ text: String) { messages.append(.string(text)) }
+
+    func receive() async throws -> WebSocketMessage {
+        if _shouldThrowOnReceive { throw DiscordError.gateway("Simulated receive error") }
+        guard !messages.isEmpty else { throw DiscordError.gateway("No mock messages") }
+        return messages.removeFirst()
+    }
+
+    func send(_ message: WebSocketMessage) async throws {
+        if case .string(let text) = message { sentMessages.append(text) }
+    }
+
+    func sendPing() async throws {}
+    func close() async { _closeCode = 1000 }
+    func forceClose() async { _closeCode = 1006 }
+
+    func getSentMessages() -> [String] { sentMessages }
+    func setThrowOnReceive(_ shouldThrow: Bool) { _shouldThrowOnReceive = shouldThrow }
+}
+
+/// Minimal VoiceState struct for API compliance (voice not yet planned).
+public struct VoiceState: Codable, Sendable, Hashable {
+    public let guild_id: GuildID?
+    public let channel_id: ChannelID?
+    public let user_id: UserID
+    public let member: GuildMember?
+    public let session_id: String
+    public let deaf: Bool
+    public let mute: Bool
+    public let self_deaf: Bool
+    public let self_mute: Bool
+    public let self_stream: Bool?
+    public let self_video: Bool?
+    public let suppress: Bool
+    public let request_to_speak_timestamp: String?
+
+    public init(
+        guild_id: GuildID? = nil,
+        channel_id: ChannelID? = nil,
+        user_id: UserID,
+        member: GuildMember? = nil,
+        session_id: String,
+        deaf: Bool = false,
+        mute: Bool = false,
+        self_deaf: Bool = false,
+        self_mute: Bool = false,
+        self_stream: Bool? = nil,
+        self_video: Bool? = nil,
+        suppress: Bool = false,
+        request_to_speak_timestamp: String? = nil
+    ) {
+        self.guild_id = guild_id
+        self.channel_id = channel_id
+        self.user_id = user_id
+        self.member = member
+        self.session_id = session_id
+        self.deaf = deaf
+        self.mute = mute
+        self.self_deaf = self_deaf
+        self.self_mute = self_mute
+        self.self_stream = self_stream
+        self.self_video = self_video
+        self.suppress = suppress
+        self.request_to_speak_timestamp = request_to_speak_timestamp
+    }
+}