Move to swift-testing (#135)

### Motivation

We want to refactor some internals of this library. For this we need
tests. The existing tests are written with XCTest. Given that the total
number of test is relatively small, let's take the chance and move to
swift-testing before we add further tests.

### Changes

- Move all tests from XCTest to swift-testing
- This is a mechanical change

### Result

All tests use the test framework of the future.
This commit is contained in:
Fabian Fett authored and GitHub committed 2026-08-13 10:59:18 +02:00
1 parent 37b3778072
commit 7d65507593
3 files changed
+168 -166

No files matched your search

@@ -12,15 +12,16 @@
//
//===----------------------------------------------------------------------===//
import Foundation
import HTTPTypesFoundation
import XCTest
import Testing
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
final class HTTPTypesFoundationTests: XCTestCase {
func testRequestToFoundation() throws {
@Suite struct HTTPTypesFoundationTests {
@Test func requestToFoundation() throws {
let request = HTTPRequest(
method: .get,
scheme: "https",
@@ -35,43 +36,43 @@ final class HTTPTypesFoundationTests: XCTestCase {
]
)
let urlRequest = try XCTUnwrap(URLRequest(httpRequest: request))
XCTAssertEqual(urlRequest.url, URL(string: "https://www.example.com/")!)
XCTAssertEqual(urlRequest.value(forHTTPHeaderField: "aCcEpT"), "*/*")
XCTAssertEqual(urlRequest.value(forHTTPHeaderField: "Accept-Encoding"), "gzip, br")
XCTAssertEqual(urlRequest.value(forHTTPHeaderField: "cookie"), "a=b; c=d")
let urlRequest = try #require(URLRequest(httpRequest: request))
#expect(urlRequest.url == URL(string: "https://www.example.com/")!)
#expect(urlRequest.value(forHTTPHeaderField: "aCcEpT") == "*/*")
#expect(urlRequest.value(forHTTPHeaderField: "Accept-Encoding") == "gzip, br")
#expect(urlRequest.value(forHTTPHeaderField: "cookie") == "a=b; c=d")
}
func testRequestFromFoundation() throws {
@Test func requestFromFoundation() throws {
var urlRequest = URLRequest(url: URL(string: "https://www.example.com/")!)
urlRequest.httpMethod = "POST"
urlRequest.setValue("Bar", forHTTPHeaderField: "X-Foo")
let request = try XCTUnwrap(urlRequest.httpRequest)
XCTAssertEqual(request.method, .post)
XCTAssertEqual(request.scheme, "https")
XCTAssertEqual(request.authority, "www.example.com")
XCTAssertEqual(request.path, "/")
XCTAssertEqual(request.headerFields[.init("x-foo")!], "Bar")
let request = try #require(urlRequest.httpRequest)
#expect(request.method == .post)
#expect(request.scheme == "https")
#expect(request.authority == "www.example.com")
#expect(request.path == "/")
#expect(request.headerFields[.init("x-foo")!] == "Bar")
}
func testWebSocketRequest() throws {
@Test func webSocketRequest() throws {
let urlRequest = URLRequest(url: URL(string: "wss://www.example.com/")!)
let request = try XCTUnwrap(urlRequest.httpRequest)
XCTAssertEqual(request.method, .connect)
XCTAssertEqual(request.scheme, "https")
XCTAssertEqual(request.authority, "www.example.com")
XCTAssertEqual(request.path, "/")
XCTAssertEqual(request.extendedConnectProtocol, "websocket")
let request = try #require(urlRequest.httpRequest)
#expect(request.method == .connect)
#expect(request.scheme == "https")
#expect(request.authority == "www.example.com")
#expect(request.path == "/")
#expect(request.extendedConnectProtocol == "websocket")
let urlRequestConverted = try XCTUnwrap(URLRequest(httpRequest: request))
XCTAssertEqual(urlRequestConverted.httpMethod, "GET")
XCTAssertEqual(urlRequestConverted.url, URL(string: "wss://www.example.com/"))
XCTAssertEqual(urlRequest, urlRequestConverted)
let urlRequestConverted = try #require(URLRequest(httpRequest: request))
#expect(urlRequestConverted.httpMethod == "GET")
#expect(urlRequestConverted.url == URL(string: "wss://www.example.com/"))
#expect(urlRequest == urlRequestConverted)
}
func testResponseToFoundation() throws {
@Test func responseToFoundation() throws {
let response = HTTPResponse(
status: .ok,
headerFields: [
@@ -79,14 +80,14 @@ final class HTTPTypesFoundationTests: XCTestCase {
]
)
let urlResponse = try XCTUnwrap(
let urlResponse = try #require(
HTTPURLResponse(httpResponse: response, url: URL(string: "https://www.example.com/")!)
)
XCTAssertEqual(urlResponse.statusCode, 200)
XCTAssertEqual(urlResponse.value(forHTTPHeaderField: "Server"), "HTTPServer/1.0")
#expect(urlResponse.statusCode == 200)
#expect(urlResponse.value(forHTTPHeaderField: "Server") == "HTTPServer/1.0")
}
func testResponseFromFoundation() throws {
@Test func responseFromFoundation() throws {
let urlResponse = HTTPURLResponse(
url: URL(string: "https://www.example.com/")!,
statusCode: 204,
@@ -96,8 +97,8 @@ final class HTTPTypesFoundationTests: XCTestCase {
]
)!
let response = try XCTUnwrap(urlResponse.httpResponse)
XCTAssertEqual(response.status, .noContent)
XCTAssertEqual(response.headerFields[.init("X-EMOJI")!], "😀")
let response = try #require(urlResponse.httpResponse)
#expect(response.status == .noContent)
#expect(response.headerFields[.init("X-EMOJI")!] == "😀")
}
}
+87 -86
View File
@@ -12,8 +12,9 @@
//
//===----------------------------------------------------------------------===//
import Foundation
import HTTPTypes
import XCTest
import Testing
extension HTTPField.Name {
static let acceptEncodingLower = HTTPField.Name("accept-encoding")!
@@ -22,26 +23,26 @@ extension HTTPField.Name {
static let acceptLanguageUpper = HTTPField.Name("ACCEPT-LANGUAGE")!
}
final class HTTPTypesTests: XCTestCase {
func testFields() {
@Suite struct HTTPTypesTests {
@Test func fields() {
var fields = HTTPFields()
fields[.acceptEncoding] = "gzip"
fields.append(HTTPField(name: .acceptEncodingLower, value: "br"))
fields.insert(HTTPField(name: .acceptEncodingMixed, value: "deflate"), at: 1)
XCTAssertEqual(fields[.acceptEncoding], "gzip, deflate, br")
XCTAssertEqual(fields[values: .acceptEncodingUpper].count, 3)
#expect(fields[.acceptEncoding] == "gzip, deflate, br")
#expect(fields[values: .acceptEncodingUpper].count == 3)
}
func testFieldValue() {
XCTAssertEqual(HTTPField(name: .accept, value: " \n 😀 \t ").value, "😀")
XCTAssertEqual(HTTPField(name: .accept, value: " a 😀 \t\n b \t \r ").value, "a 😀 \t b")
XCTAssertEqual(HTTPField(name: .accept, value: "").value, "")
XCTAssertFalse(HTTPField.isValidValue(" "))
XCTAssertEqual(HTTPField(name: .accept, lenientValue: " \r\n\0\t ".utf8).value, " \t ")
@Test func fieldValue() {
#expect(HTTPField(name: .accept, value: " \n 😀 \t ").value == "😀")
#expect(HTTPField(name: .accept, value: " a 😀 \t\n b \t \r ").value == "a 😀 \t b")
#expect(HTTPField(name: .accept, value: "").value == "")
#expect(!HTTPField.isValidValue(" "))
#expect(HTTPField(name: .accept, lenientValue: " \r\n\0\t ".utf8).value == " \t ")
}
func testRequest() {
@Test func request() {
var request1 = HTTPRequest(method: .get, scheme: "https", authority: "www.example.com", path: "/")
request1.headerFields = [
.acceptLanguage: "en"
@@ -54,11 +55,11 @@ final class HTTPTypesTests: XCTestCase {
)
request2.headerFields.append(HTTPField(name: .acceptLanguageUpper, value: "en"))
XCTAssertEqual(request2.method, .get)
XCTAssertEqual(request1, request2)
#expect(request2.method == .get)
#expect(request1 == request2)
}
func testResponse() {
@Test func response() {
var response1 = HTTPResponse(status: 200)
response1.headerFields = [
.server: "HTTPServer/1.0",
@@ -69,60 +70,60 @@ final class HTTPTypesTests: XCTestCase {
response2.status = .movedPermanently
response2.headerFields.append(HTTPField(name: .location, value: "https://www.example.com/new"))
XCTAssertEqual(response1.status, .ok)
XCTAssertEqual(response1.status.kind, .successful)
XCTAssertEqual(response1.headerFields.count, 2)
#expect(response1.status == .ok)
#expect(response1.status.kind == .successful)
#expect(response1.headerFields.count == 2)
XCTAssertEqual(response2.status, 301)
XCTAssertEqual(response2.status.kind, .redirection)
XCTAssertEqual(response2.headerFields.count, 3)
XCTAssertEqual(response2.headerFields[.server], "HTTPServer/1.0")
#expect(response2.status == 301)
#expect(response2.status.kind == .redirection)
#expect(response2.headerFields.count == 3)
#expect(response2.headerFields[.server] == "HTTPServer/1.0")
}
func testComparison() {
@Test func comparison() {
let fields1: HTTPFields = [
.acceptEncoding: "br",
.acceptEncoding: "gzip",
.accept: "*/*",
]
XCTAssertNotEqual(fields1, [:])
#expect(fields1 != [:])
let fields2: HTTPFields = [
.acceptEncoding: "br",
.acceptEncoding: "gzip",
.accept: "*/*",
]
XCTAssertEqual(fields1, fields2)
#expect(fields1 == fields2)
let fields3: HTTPFields = [
.acceptEncoding: "br",
.accept: "*/*",
.acceptEncoding: "gzip",
]
XCTAssertEqual(fields1, fields3)
#expect(fields1 == fields3)
let fields4: HTTPFields = [
.acceptEncoding: "br",
.accept: "*/*",
]
XCTAssertNotEqual(fields1, fields4)
#expect(fields1 != fields4)
let fields5: HTTPFields = [
.acceptEncoding: "gzip",
.acceptEncoding: "br",
.accept: "*/*",
]
XCTAssertNotEqual(fields1, fields5)
#expect(fields1 != fields5)
let fields6: HTTPFields = [
.acceptEncoding: "gzip",
.acceptEncoding: "br",
.acceptLanguage: "en",
]
XCTAssertNotEqual(fields1, fields6)
#expect(fields1 != fields6)
}
func testSendable() {
@Test func sendable() {
func isSendable(_ value: some Sendable) -> Bool { true }
func isSendable(_ value: Any) -> Bool { false }
@@ -137,19 +138,19 @@ final class HTTPTypesTests: XCTestCase {
let status: HTTPResponse.Status = response.status
let responsePseudoHeaderFields: HTTPResponse.PseudoHeaderFields = response.pseudoHeaderFields
XCTAssertTrue(isSendable(field))
XCTAssertTrue(isSendable(indexingStrategy))
XCTAssertTrue(isSendable(name))
XCTAssertTrue(isSendable(fields))
XCTAssertTrue(isSendable(request))
XCTAssertTrue(isSendable(method))
XCTAssertTrue(isSendable(requestPseudoHeaderFields))
XCTAssertTrue(isSendable(response))
XCTAssertTrue(isSendable(status))
XCTAssertTrue(isSendable(responsePseudoHeaderFields))
#expect(isSendable(field))
#expect(isSendable(indexingStrategy))
#expect(isSendable(name))
#expect(isSendable(fields))
#expect(isSendable(request))
#expect(isSendable(method))
#expect(isSendable(requestPseudoHeaderFields))
#expect(isSendable(response))
#expect(isSendable(status))
#expect(isSendable(responsePseudoHeaderFields))
}
func testRequestCoding() throws {
@Test func requestCoding() throws {
let request = HTTPRequest(
method: .put,
scheme: "https",
@@ -164,28 +165,28 @@ final class HTTPTypesTests: XCTestCase {
let encoded = try JSONEncoder().encode(request)
let json = try JSONSerialization.jsonObject(with: encoded)
XCTAssertEqual(
json as? NSDictionary,
[
"pseudoHeaderFields": [
["name": ":method", "value": "PUT"],
["name": ":scheme", "value": "https"],
["name": ":authority", "value": "www.example.com"],
["name": ":path", "value": "/upload"],
],
"headerFields": [
["name": "Accept-Encoding", "value": "br"],
["name": "Accept-Encoding", "value": "gzip"],
["name": "Content-Length", "value": "1024"],
],
]
#expect(
json as? NSDictionary
== [
"pseudoHeaderFields": [
["name": ":method", "value": "PUT"],
["name": ":scheme", "value": "https"],
["name": ":authority", "value": "www.example.com"],
["name": ":path", "value": "/upload"],
],
"headerFields": [
["name": "Accept-Encoding", "value": "br"],
["name": "Accept-Encoding", "value": "gzip"],
["name": "Content-Length", "value": "1024"],
],
]
)
let decoded = try JSONDecoder().decode(HTTPRequest.self, from: encoded)
XCTAssertEqual(request, decoded)
#expect(request == decoded)
}
func testResponseCoding() throws {
@Test func responseCoding() throws {
var response = HTTPResponse(
status: .noContent,
headerFields: [
@@ -196,24 +197,24 @@ final class HTTPTypesTests: XCTestCase {
let encoded = try JSONEncoder().encode(response)
let json = try JSONSerialization.jsonObject(with: encoded)
XCTAssertEqual(
json as? NSDictionary,
[
"pseudoHeaderFields": [
["name": ":status", "value": "204"]
],
"reasonPhrase": "No Content",
"headerFields": [
["name": "Server", "value": "HTTPServer/1.0", "indexingStrategy": 1]
],
]
#expect(
json as? NSDictionary
== [
"pseudoHeaderFields": [
["name": ":status", "value": "204"]
],
"reasonPhrase": "No Content",
"headerFields": [
["name": "Server", "value": "HTTPServer/1.0", "indexingStrategy": 1]
],
]
)
let decoded = try JSONDecoder().decode(HTTPResponse.self, from: encoded)
XCTAssertEqual(response, decoded)
#expect(response == decoded)
}
func testRequestParsing() throws {
@Test func requestParsing() throws {
let fields = [
HTTPField(name: HTTPField.Name(parsed: ":method")!, lenientValue: "PUT".utf8),
HTTPField(name: HTTPField.Name(parsed: ":scheme")!, lenientValue: "https".utf8),
@@ -222,36 +223,36 @@ final class HTTPTypesTests: XCTestCase {
HTTPField(name: HTTPField.Name(parsed: "content-length")!, lenientValue: "1024".utf8),
]
let request = try HTTPRequest(parsed: fields)
XCTAssertEqual(request.method, .put)
XCTAssertEqual(request.scheme, "https")
XCTAssertEqual(request.authority, "www.example.com")
XCTAssertEqual(request.path, "/upload")
XCTAssertEqual(request.headerFields[.contentLength], "1024")
#expect(request.method == .put)
#expect(request.scheme == "https")
#expect(request.authority == "www.example.com")
#expect(request.path == "/upload")
#expect(request.headerFields[.contentLength] == "1024")
}
func testResponseParsing() throws {
@Test func responseParsing() throws {
let fields = [
HTTPField(name: HTTPField.Name(parsed: ":status")!, lenientValue: "204".utf8),
HTTPField(name: HTTPField.Name(parsed: "server")!, lenientValue: "HTTPServer/1.0".utf8),
]
let response = try HTTPResponse(parsed: fields)
XCTAssertEqual(response.status, .noContent)
XCTAssertEqual(response.headerFields[.server], "HTTPServer/1.0")
#expect(response.status == .noContent)
#expect(response.headerFields[.server] == "HTTPServer/1.0")
}
func testTrailerFieldsParsing() throws {
@Test func trailerFieldsParsing() throws {
let fields = [
HTTPField(name: HTTPField.Name(parsed: "trailer1")!, lenientValue: "value1".utf8),
HTTPField(name: HTTPField.Name(parsed: "trailer2")!, lenientValue: "value2".utf8),
]
let trailerFields = try HTTPFields(parsedTrailerFields: fields)
XCTAssertEqual(trailerFields[HTTPField.Name("trailer1")!], "value1")
XCTAssertEqual(trailerFields[HTTPField.Name("trailer2")!], "value2")
#expect(trailerFields[HTTPField.Name("trailer1")!] == "value1")
#expect(trailerFields[HTTPField.Name("trailer2")!] == "value2")
}
func testTypeLayoutSize() {
XCTAssertEqual(MemoryLayout<HTTPRequest>.size, MemoryLayout<AnyObject>.size * 2)
XCTAssertEqual(MemoryLayout<HTTPResponse>.size, MemoryLayout<AnyObject>.size * 2)
XCTAssertEqual(MemoryLayout<HTTPFields>.size, MemoryLayout<AnyObject>.size)
@Test func typeLayoutSize() {
#expect(MemoryLayout<HTTPRequest>.size == MemoryLayout<AnyObject>.size * 2)
#expect(MemoryLayout<HTTPResponse>.size == MemoryLayout<AnyObject>.size * 2)
#expect(MemoryLayout<HTTPFields>.size == MemoryLayout<AnyObject>.size)
}
}
+46 -46
View File
@@ -13,7 +13,7 @@
//===----------------------------------------------------------------------===//
import HTTPTypes
import XCTest
import Testing
#if canImport(FoundationEssentials)
import FoundationEssentials
@@ -21,77 +21,77 @@ import FoundationEssentials
import Foundation
#endif
final class HTTPTypesURLTests: XCTestCase {
func testRequestURLParsing() {
@Suite struct HTTPTypesURLTests {
@Test func requestURLParsing() {
let request1 = HTTPRequest(url: URL(string: "h://a")!)
XCTAssertEqual(request1.scheme, "h")
XCTAssertEqual(request1.authority, "a")
XCTAssertEqual(request1.path, "/")
XCTAssertEqual(request1.url?.absoluteString, "h://a/")
#expect(request1.scheme == "h")
#expect(request1.authority == "a")
#expect(request1.path == "/")
#expect(request1.url?.absoluteString == "h://a/")
let request2 = HTTPRequest(url: URL(string: "h://a:4?")!)
XCTAssertEqual(request2.scheme, "h")
XCTAssertEqual(request2.authority, "a:4")
XCTAssertEqual(request2.path, "/?")
XCTAssertEqual(request2.url?.absoluteString, "h://a:4/?")
#expect(request2.scheme == "h")
#expect(request2.authority == "a:4")
#expect(request2.path == "/?")
#expect(request2.url?.absoluteString == "h://a:4/?")
let request3 = HTTPRequest(url: URL(string: "h://a/")!)
XCTAssertEqual(request3.scheme, "h")
XCTAssertEqual(request3.authority, "a")
XCTAssertEqual(request3.path, "/")
XCTAssertEqual(request3.url?.absoluteString, "h://a/")
#expect(request3.scheme == "h")
#expect(request3.authority == "a")
#expect(request3.path == "/")
#expect(request3.url?.absoluteString == "h://a/")
let request4 = HTTPRequest(url: URL(string: "h://a/p?q#1")!)
XCTAssertEqual(request4.scheme, "h")
XCTAssertEqual(request4.authority, "a")
XCTAssertEqual(request4.path, "/p?q")
XCTAssertEqual(request4.url?.absoluteString, "h://a/p?q")
#expect(request4.scheme == "h")
#expect(request4.authority == "a")
#expect(request4.path == "/p?q")
#expect(request4.url?.absoluteString == "h://a/p?q")
let request5 = HTTPRequest(url: URL(string: "data:,Hello%2C%20World%21")!)
XCTAssertEqual(request5.scheme, "data")
XCTAssertNil(request5.authority)
#expect(request5.scheme == "data")
#expect(request5.authority == nil)
#if !canImport(FoundationEssentials)
XCTAssertEqual(request5.path, "/")
#expect(request5.path == "/")
#else // !canImport(FoundationEssentials)
XCTAssertEqual(request5.path, ",Hello%2C%20World%21")
#expect(request5.path == ",Hello%2C%20World%21")
#endif // !canImport(FoundationEssentials)
XCTAssertNil(request5.url)
#expect(request5.url == nil)
}
func testRequestURLAuthorityParsing() {
@Test func requestURLAuthorityParsing() {
let request1 = HTTPRequest(url: URL(string: "https://[::1]")!)
XCTAssertEqual(request1.scheme, "https")
XCTAssertEqual(request1.authority, "[::1]")
XCTAssertEqual(request1.path, "/")
XCTAssertEqual(request1.url?.absoluteString, "https://[::1]/")
#expect(request1.scheme == "https")
#expect(request1.authority == "[::1]")
#expect(request1.path == "/")
#expect(request1.url?.absoluteString == "https://[::1]/")
let request2 = HTTPRequest(url: URL(string: "https://[::1]:443")!)
XCTAssertEqual(request2.scheme, "https")
XCTAssertEqual(request2.authority, "[::1]:443")
XCTAssertEqual(request2.path, "/")
XCTAssertEqual(request2.url?.absoluteString, "https://[::1]:443/")
#expect(request2.scheme == "https")
#expect(request2.authority == "[::1]:443")
#expect(request2.path == "/")
#expect(request2.url?.absoluteString == "https://[::1]:443/")
let request3 = HTTPRequest(url: URL(string: "https://127.0.0.1")!)
XCTAssertEqual(request3.scheme, "https")
XCTAssertEqual(request3.authority, "127.0.0.1")
XCTAssertEqual(request3.path, "/")
XCTAssertEqual(request3.url?.absoluteString, "https://127.0.0.1/")
#expect(request3.scheme == "https")
#expect(request3.authority == "127.0.0.1")
#expect(request3.path == "/")
#expect(request3.url?.absoluteString == "https://127.0.0.1/")
let request4 = HTTPRequest(url: URL(string: "https://127.0.0.1:443")!)
XCTAssertEqual(request4.scheme, "https")
XCTAssertEqual(request4.authority, "127.0.0.1:443")
XCTAssertEqual(request4.path, "/")
XCTAssertEqual(request4.url?.absoluteString, "https://127.0.0.1:443/")
#expect(request4.scheme == "https")
#expect(request4.authority == "127.0.0.1:443")
#expect(request4.path == "/")
#expect(request4.url?.absoluteString == "https://127.0.0.1:443/")
}
func testNilRequestURL() {
@Test func nilRequestURL() {
let request1 = HTTPRequest(
method: .connect,
scheme: "https",
authority: "www.example.com:443",
path: "www.example.com:443"
)
XCTAssertNil(request1.url)
#expect(request1.url == nil)
var request2 = HTTPRequest(
method: .connect,
@@ -100,12 +100,12 @@ final class HTTPTypesURLTests: XCTestCase {
path: "/"
)
request2.extendedConnectProtocol = "websocket"
XCTAssertEqual(request2.url?.absoluteString, "https://www.example.com/")
#expect(request2.url?.absoluteString == "https://www.example.com/")
let request3 = HTTPRequest(method: .options, scheme: "https", authority: "www.example.com", path: "*")
XCTAssertNil(request3.url)
#expect(request3.url == nil)
let request4 = HTTPRequest(method: .options, scheme: "https", authority: "www.example.com", path: "/")
XCTAssertEqual(request4.url?.absoluteString, "https://www.example.com/")
#expect(request4.url?.absoluteString == "https://www.example.com/")
}
}