Update proxy-server for swift 6

Author: adam-fowler

proxy-server/Package.swift

@@ -1,13 +1,13 @@
-// swift-tools-version:5.9
+// swift-tools-version:6.0
 import PackageDescription
 
 let package = Package(
     name: "proxy-server",
     platforms: [
-        .macOS(.v14),
+        .macOS(.v14)
     ],
     dependencies: [
-        .package(url: "https://github.com/hummingbird-project/hummingbird.git", from: "2.0.0"),
+        .package(url: "https://github.com/hummingbird-project/hummingbird.git", from: "2.19.0"),
         .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.4.0"),
         .package(url: "https://github.com/apple/swift-nio-extras.git", from: "1.22.0"),
         .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.6.0"),
@@ -25,7 +25,7 @@ let package = Package(
                 // Enable better optimizations when building in Release configuration. Despite the use of
                 // the `.unsafeFlags` construct required by SwiftPM, this flag is recommended for Release
                 // builds. See <https://github.com/swift-server/guides#building-for-production> for details.
-                .unsafeFlags(["-cross-module-optimization"], .when(configuration: .release)),
+                .unsafeFlags(["-cross-module-optimization"], .when(configuration: .release))
             ]
         ),
         .testTarget(

proxy-server/Sources/App/Middleware/ProxyServerMiddleware.swift

@@ -67,11 +67,12 @@ struct ProxyServerMiddleware: RouterMiddleware {
             }
         }
         // extract length from content-length header
-        let contentLength = if let header = request.headers[.contentLength], let value = Int(header) {
-            HTTPClientRequest.Body.Length.known(value)
-        } else {
-            HTTPClientRequest.Body.Length.unknown
-        }
+        let contentLength =
+            if let header = request.headers[.contentLength], let value = Int(header) {
+                HTTPClientRequest.Body.Length.known(Int64(value))
+            } else {
+                HTTPClientRequest.Body.Length.unknown
+            }
         clientRequest.body = .stream(
             request.body,
             length: contentLength

proxy-server/Tests/AppTests/AppTests.swift

@@ -1,10 +1,11 @@
-@testable import App
 import Hummingbird
 import HummingbirdTesting
 import ServiceLifecycle
-import XCTest
+import Testing
+
+@testable import App
 
-final class AppTests: XCTestCase {
+struct AppTests {
     struct TestAppArguments: AppArguments {
         var hostname: String { "127.0.0.1" }
         var port: Int { 8081 }
@@ -55,66 +56,66 @@ final class AppTests: XCTestCase {
 
     // MARK: tests
 
-    func testSimple() async throws {
+    @Test func testSimple() async throws {
         try await self.testProxy { router in
             router.get("hello") { _, _ in
-                return "Hello"
+                "Hello"
             }
         } test: { port in
             let proxy = buildApplication(TestAppArguments(location: "", target: "http://localhost:\(port)"))
             try await proxy.test(.live) { client in
                 try await client.execute(uri: "/hello", method: .get) { response in
-                    XCTAssertEqual(String(buffer: response.body), "Hello")
+                    #expect(String(buffer: response.body) == "Hello")
                 }
             }
         }
     }
 
-    func testLocation() async throws {
+    @Test func testLocation() async throws {
         try await self.testProxy { router in
             router.get("hello") { _, _ in
-                return "Hello"
+                "Hello"
             }
         } test: { port in
             let proxy = buildApplication(TestAppArguments(location: "/proxy", target: "http://localhost:\(port)"))
             try await proxy.test(.live) { client in
                 try await client.execute(uri: "/proxy/hello", method: .get) { response in
-                    XCTAssertEqual(String(buffer: response.body), "Hello")
+                    #expect(String(buffer: response.body) == "Hello")
                 }
             }
         }
     }
 
-    func testEchoBody() async throws {
+    @Test func testEchoBody() async throws {
         let string = "This is a test body"
         let buffer = ByteBuffer(string: string)
         try await self.testProxy { router in
             router.post("echo") { request, _ in
                 // test content length was passed through
-                XCTAssertEqual(request.headers[.contentLength], buffer.readableBytes.description)
+                #expect(request.headers[.contentLength] == buffer.readableBytes.description)
                 return Response(status: .ok, body: .init(asyncSequence: request.body))
             }
         } test: { port in
             let proxy = buildApplication(TestAppArguments(location: "", target: "http://localhost:\(port)"))
             try await proxy.test(.live) { client in
                 try await client.execute(uri: "/echo", method: .post, body: buffer) { response in
-                    XCTAssertEqual(response.body, buffer)
+                    #expect(response.body == buffer)
                 }
             }
         }
     }
 
-    func testLargeBody() async throws {
+    @Test func testLargeBody() async throws {
         try await self.testProxy { router in
             router.post("echo") { request, _ in
-                return Response(status: .ok, body: .init(asyncSequence: request.body))
+                Response(status: .ok, body: .init(asyncSequence: request.body))
             }
         } test: { port in
             let proxy = buildApplication(TestAppArguments(location: "", target: "http://localhost:\(port)"))
             try await proxy.test(.live) { client in
                 let buffer = self.randomBuffer(size: 1024 * 1500)
                 try await client.execute(uri: "/echo", method: .post, body: buffer) { response in
-                    XCTAssertEqual(response.body, buffer)
+                    #expect(response.body == buffer)
                 }
             }
         }