Machine-coding round: build a generic networking layer in about 45 minutes. What do you build, and how do you test it without a server?

Predict first

What does the client print against a stubbed server?

import Foundation

protocol Endpoint { var path: String { get }; var method: String { get }; var query: [String: String] { get } }
extension Endpoint { var method: String { "GET" }; var query: [String: String] { [:] } }

enum APIError: Error, Equatable { case badStatus(Int), decoding, transport }

struct APIClient {
    let baseURL: URL
    let session: URLSession
    func send<T: Decodable>(_ endpoint: Endpoint, as type: T.Type = T.self) async throws -> T {
        var comps = URLComponents(url: baseURL.appendingPathComponent(endpoint.path), resolvingAgainstBaseURL: false)!
        if !endpoint.query.isEmpty { comps.queryItems = endpoint.query.sorted { $0.key < $1.key }.map { URLQueryItem(name: $0.key, value: $0.value) } }
        var req = URLRequest(url: comps.url!)
        req.httpMethod = endpoint.method
        let (data, response): (Data, URLResponse)
        do { (data, response) = try await session.data(for: req) } catch { throw APIError.transport }
        guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
            throw APIError.badStatus((response as? HTTPURLResponse)?.statusCode ?? -1)
        }
        do { return try JSONDecoder().decode(T.self, from: data) } catch { throw APIError.decoding }
    }
}

// Test seam: a URLProtocol that serves canned responses, so no network is needed.
final class Stub: URLProtocol, @unchecked Sendable {
    nonisolated(unsafe) static var responder: ((URLRequest) -> (Int, Data))!
    override class func canInit(with request: URLRequest) -> Bool { true }
    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
    override func startLoading() {
        let (code, body) = Stub.responder(request)
        let r = HTTPURLResponse(url: request.url!, statusCode: code, httpVersion: nil, headerFields: nil)!
        client?.urlProtocol(self, didReceive: r, cacheStoragePolicy: .notAllowed)
        client?.urlProtocol(self, didLoad: body)
        client?.urlProtocolDidFinishLoading(self)
    }
    override func stopLoading() {}
}
struct Movie: Decodable, Equatable { let id: Int; let title: String }
struct Movies: Endpoint { let page: Int; var path: String { "movies" }; var query: [String: String] { ["page": "\(page)"] } }

let cfg = URLSessionConfiguration.ephemeral
cfg.protocolClasses = [Stub.self]
let client = APIClient(baseURL: URL(string: "https://api.example.test")!, session: URLSession(configuration: cfg))

Stub.responder = { req in print("GET", req.url!.absoluteString); return (200, Data(#"[{"id":1,"title":"Alien"}]"#.utf8)) }
let movies = try await client.send(Movies(page: 2), as: [Movie].self)
print(movies.map(\.title))
Stub.responder = { _ in (404, Data()) }
do { _ = try await client.send(Movies(page: 1), as: [Movie].self) } catch { print("error:", error) }
Stub.responder = { _ in (200, Data("not json".utf8)) }
do { _ = try await client.send(Movies(page: 1), as: [Movie].self) } catch { print("error:", error) }

• GET https://api.example.test/movies?page=2 / ["Alien"] / error: badStatus(404) / error: decoding
• ["Alien"] / error: transport / error: decoding
• GET .../movies?page=2 / ["Alien"] / error: decoding / error: decoding