status

Tests/MediaAPITests.swift

@@ -0,0 +1,125 @@
+import Foundation
+import Testing
+@testable import Voice
+
+/// Minimal HTTP/1.1 stub built on BSD sockets that answers every request with a
+/// successful JSON object body (mirroring the real media server's
+/// `{"ok": true, ...}` shape). Used to prove MediaAPI no-response POSTs succeed
+/// against an object body instead of throwing decodeFailed.
+@MainActor
+final class MediaAPIStubServer {
+    private(set) var url: URL!
+    nonisolated(unsafe) private var serverFD: Int32 = -1
+    nonisolated(unsafe) private var acceptThread: Thread?
+    nonisolated(unsafe) private var running = false
+    nonisolated(unsafe) private var lastPath: String?
+
+    func start() throws {
+        let fd = socket(AF_INET, SOCK_STREAM, 0)
+        guard fd >= 0 else { throw MediaAPIError.decodeFailed }
+        var yes: Int32 = 1
+        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, socklen_t(MemoryLayout<Int32>.size))
+
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = in_port_t(0).bigEndian
+        addr.sin_addr = in_addr(s_addr: inet_addr("127.0.0.1"))
+        let bindResult = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                bind(fd, sa, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+        guard bindResult == 0 else { close(fd); throw MediaAPIError.decodeFailed }
+        guard listen(fd, 8) == 0 else { close(fd); throw MediaAPIError.decodeFailed }
+
+        var bound = sockaddr_in()
+        var len = socklen_t(MemoryLayout<sockaddr_in>.size)
+        withUnsafeMutablePointer(to: &bound) { ptr in
+            _ = ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                getsockname(fd, sa, &len)
+            }
+        }
+        let port = Int(UInt16(bigEndian: bound.sin_port))
+        serverFD = fd
+        running = true
+        url = URL(string: "http://127.0.0.1:\(port)")!
+
+        let thread = Thread { [weak self] in
+            self?.acceptLoop()
+        }
+        acceptThread = thread
+        thread.start()
+    }
+
+    func stop() {
+        running = false
+        if serverFD >= 0 { close(serverFD) }
+        serverFD = -1
+        acceptThread?.cancel()
+    }
+
+    var lastRequestPath: String? { lastPath }
+
+    nonisolated private func acceptLoop() {
+        while running {
+            var clientAddr = sockaddr_in()
+            var len = socklen_t(MemoryLayout<sockaddr_in>.size)
+            let clientFD = withUnsafeMutablePointer(to: &clientAddr) { ptr in
+                ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                    accept(serverFD, sa, &len)
+                }
+            }
+            guard clientFD >= 0 else { continue }
+            handleClient(clientFD)
+        }
+    }
+
+    nonisolated private func handleClient(_ clientFD: Int32) {
+        defer { close(clientFD) }
+        var buffer = [UInt8](repeating: 0, count: 4096)
+        let bytesRead = read(clientFD, &buffer, buffer.count)
+        guard bytesRead > 0 else { return }
+        guard let request = String(bytes: buffer[0..<bytesRead], encoding: .utf8) else { return }
+
+        var path = ""
+        if let firstLine = request.split(separator: "\r\n").first {
+            let parts = firstLine.split(separator: " ")
+            if parts.count >= 2 { path = String(parts[1]) }
+        }
+        lastPath = path
+
+        let body = #"{"ok": true, "room": "test", "desired": "stopped"}"#
+        let response = """
+        HTTP/1.1 200 OK\r
+        Content-Type: application/json\r
+        Content-Length: \(body.utf8.count)\r
+        Connection: close\r
+
+        \(body)
+        """
+        _ = response.withCString { cstr in
+            write(clientFD, cstr, response.utf8.count)
+        }
+    }
+}
+
+@MainActor
+struct MediaAPITests {
+    @Test("successful JSON object response does not throw decodeFailed")
+    func successfulObjectResponse() async throws {
+        let stub = MediaAPIStubServer()
+        try stub.start()
+        defer { stub.stop() }
+
+        // Bypass the https-only parse path: build the config directly.
+        let base = stub.url!
+        let config = ServerConfig(baseURL: base, livekitURL: base)
+        let api = MediaAPI(config: config)
+
+        try await api.control(room: "test", action: "pause")
+        try await api.report(room: "test", state: "paused", trackID: nil, position: 0, duration: nil)
+        try await api.play(room: "test", videoID: nil, title: nil, channel: nil, trackID: nil, startPaused: nil)
+
+        #expect(stub.lastRequestPath == "/media/api/play")
+    }
+}