Added additional tests for socketPath-based requests

Motivation:

While going through the existing tests, I identified a few more instances where we could add some testing.

Modifications:

Added one test that verifies Requests are being decoded correctly, and improved three others to check for path parsing, error throwing, and schema casing respectively.

Result:

Tests that continue to pass, but that will also catch any incompatible changes in the future.

Author: dimitribouniol

Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -99,8 +99,8 @@ extension HTTPClient {
     /// Represent HTTP request.
     public struct Request {
         /// Represent kind of Request
-        enum Kind {
-            enum UnixScheme {
+        enum Kind: Equatable {
+            enum UnixScheme: Equatable {
                 case baseURL
                 case http_unix
                 case https_unix

Tests/AsyncHTTPClientTests/HTTPClientInternalTests+XCTest.swift

@@ -41,6 +41,7 @@ extension HTTPClientInternalTests {
             ("testUncleanCloseThrows", testUncleanCloseThrows),
             ("testUploadStreamingIsCalledOnTaskEL", testUploadStreamingIsCalledOnTaskEL),
             ("testWeCanActuallyExactlySetTheEventLoops", testWeCanActuallyExactlySetTheEventLoops),
+            ("testInternalRequestURI", testInternalRequestURI),
         ]
     }
 }

Tests/AsyncHTTPClientTests/HTTPClientInternalTests.swift

@@ -891,4 +891,31 @@ class HTTPClientInternalTests: XCTestCase {
         XCTAssert(el1 === response.eventLoop)
         XCTAssertNoThrow(try response.wait())
     }
+
+    func testInternalRequestURI() throws {
+        let request1 = try Request(url: "https://someserver.com:8888/some/path?foo=bar")
+        XCTAssertEqual(request1.kind, .host)
+        XCTAssertEqual(request1.socketPath, "")
+        XCTAssertEqual(request1.uri, "/some/path?foo=bar")
+
+        let request2 = try Request(url: "https://someserver.com")
+        XCTAssertEqual(request2.kind, .host)
+        XCTAssertEqual(request2.socketPath, "")
+        XCTAssertEqual(request2.uri, "/")
+
+        let request3 = try Request(url: "unix:///tmp/file")
+        XCTAssertEqual(request3.kind, .unixSocket(.baseURL))
+        XCTAssertEqual(request3.socketPath, "/tmp/file")
+        XCTAssertEqual(request3.uri, "/")
+
+        let request4 = try Request(url: "http+unix://%2Ftmp%2Ffile/file/path")
+        XCTAssertEqual(request4.kind, .unixSocket(.http_unix))
+        XCTAssertEqual(request4.socketPath, "/tmp/file")
+        XCTAssertEqual(request4.uri, "/file/path")
+
+        let request5 = try Request(url: "https+unix://%2Ftmp%2Ffile/file/path")
+        XCTAssertEqual(request5.kind, .unixSocket(.https_unix))
+        XCTAssertEqual(request5.socketPath, "/tmp/file")
+        XCTAssertEqual(request5.uri, "/file/path")
+    }
 }

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -98,6 +98,18 @@ class HTTPClientTests: XCTestCase {
         XCTAssertEqual(request3.url.path, "/tmp/file")
         XCTAssertEqual(request3.port, 80)
         XCTAssertFalse(request3.useTLS)
+
+        let request4 = try Request(url: "http+unix://%2Ftmp%2Ffile/file/path")
+        XCTAssertEqual(request4.host, "")
+        XCTAssertEqual(request4.url.host, "/tmp/file")
+        XCTAssertEqual(request4.url.path, "/file/path")
+        XCTAssertFalse(request4.useTLS)
+
+        let request5 = try Request(url: "https+unix://%2Ftmp%2Ffile/file/path")
+        XCTAssertEqual(request5.host, "")
+        XCTAssertEqual(request5.url.host, "/tmp/file")
+        XCTAssertEqual(request5.url.path, "/file/path")
+        XCTAssertTrue(request5.useTLS)
     }
 
     func testBadRequestURI() throws {
@@ -110,11 +122,16 @@ class HTTPClientTests: XCTestCase {
         XCTAssertThrowsError(try Request(url: "https:/foo"), "should throw") { error in
             XCTAssertEqual(error as! HTTPClientError, HTTPClientError.emptyHost)
         }
+        XCTAssertThrowsError(try Request(url: "http+unix:///path"), "should throw") { error in
+            XCTAssertEqual(error as! HTTPClientError, HTTPClientError.missingSocketPath)
+        }
     }
 
     func testSchemaCasing() throws {
         XCTAssertNoThrow(try Request(url: "hTTpS://someserver.com:8888/some/path?foo=bar"))
         XCTAssertNoThrow(try Request(url: "uNIx:///some/path"))
+        XCTAssertNoThrow(try Request(url: "hTtP+uNIx://%2Fsome%2Fpath/"))
+        XCTAssertNoThrow(try Request(url: "hTtPS+uNIx://%2Fsome%2Fpath/"))
     }
 
     func testGet() throws {