mirror of
https://github.com/apple/swift-http-types
synced 2026-11-22 04:30:40 +00:00
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:
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")!] == "😀")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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/")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user