Miscellaneous documentation, tests, helper functions (#534)

adam-fowler · web-flow · commit ce76c210550d · 2024-08-27T19:05:41.000+02:00
* Documentation fixes

* Remove unnecessary @preconcurrency

* Add ResponseBody(contentsOf:)

* Add test for ResponseBody(contentsOf:)

* Add test for reading two file on one connection
diff --git a/Sources/Hummingbird/Codable/URLEncodedForm/URLEncodedForm.swift b/Sources/Hummingbird/Codable/URLEncodedForm/URLEncodedForm.swift
@@ -12,11 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if os(Linux)
-@preconcurrency import Foundation
-#else
 import Foundation
-#endif
 
 internal enum URLEncodedForm {
     /// CodingKey used by URLEncodedFormEncoder and URLEncodedFormDecoder
diff --git a/Sources/Hummingbird/Configuration.swift b/Sources/Hummingbird/Configuration.swift
@@ -33,7 +33,7 @@ public struct ApplicationConfiguration: Sendable {
     public var backlog: Int
     /// Allows socket to be bound to an address that is already in use.
     public var reuseAddress: Bool
-    /// Object deciding on when we should accept new connection. Use ``MaximumAvailableConnections``
+    /// Object deciding on when we should accept new connection. Use ``HummingbirdCore/MaximumAvailableConnections``
     /// to set the maximum allowed connections.
     public var availableConnectionsDelegate: AvailableConnectionsDelegate?
     #if canImport(Network)
@@ -48,11 +48,11 @@ public struct ApplicationConfiguration: Sendable {
     /// - Parameters:
     ///   - address: Bind address for server
     ///   - serverName: Server name to return in "server" header
-    ///   - backlog: the maximum length for the queue of pending connections.  If a connection request arrives with the queue full,
-    ///         the client may receive an error with an indication of ECONNREFUSE
+    ///   - backlog: the maximum length for the queue of pending connections.  If a connection request 
+    ///         arrives with the queue full, the client may receive an error with an indication of ECONNREFUSE
     ///   - reuseAddress: Allows socket to be bound to an address that is already in use.
-    ///   - availableConnectionsDelegate: Object deciding on when we should accept new connection. Use ``MaximumAvailableConnections``
-    ///         to set the maximum allowed connections.
+    ///   - availableConnectionsDelegate: Object deciding on when we should accept new connection. Use 
+    ///         ``HummingbirdCore/MaximumAvailableConnections`` to set the maximum allowed connections.
     public init(
         address: BindAddress = .hostname(),
         serverName: String? = nil,
@@ -77,8 +77,8 @@ public struct ApplicationConfiguration: Sendable {
     ///   - address: Bind address for server
     ///   - serverName: Server name to return in "server" header
     ///   - reuseAddress: Allows socket to be bound to an address that is already in use.
-    ///   - availableConnectionsDelegate: Object deciding on when we should accept new connection. Use ``MaximumAvailableConnections``
-    ///         to set the maximum allowed connections.
+    ///   - availableConnectionsDelegate: Object deciding on when we should accept new connection. Use 
+    ///         ``HummingbirdCore/MaximumAvailableConnections`` to set the maximum allowed connections.
     ///   - tlsOptions: TLS options for when you are using NIOTransportServices
     public init(
         address: BindAddress = .hostname(),
diff --git a/Sources/HummingbirdCore/Response/ResponseBody.swift b/Sources/HummingbirdCore/Response/ResponseBody.swift
@@ -23,13 +23,14 @@ public struct ResponseBody: Sendable {
 
     /// Initialise ResponseBody with closure writing body contents.
     ///
-    /// When you have finished writing the response body you need to indicate you
-    /// have finished by calling ``ResponseBodyWriter.finish``. At this point you can also
-    /// send trailing headers by including them as a parameter in the finsh() call.
+    /// When you have finished writing the response body you need to indicate you have
+    /// finished by calling ``ResponseBodyWriter/finish(_:)``. At this
+    /// point you can also send trailing headers by including them as a parameter in
+    /// the finsh() call.
     /// ```
     /// let responseBody = ResponseBody(contentLength: contentLength) { writer in
     ///     try await writer.write(buffer)
-    ///     try await writer.finish()
+    ///     try await writer.finish(nil)
     /// }
     /// ```
     /// - Parameters:
@@ -58,13 +59,20 @@ public struct ResponseBody: Sendable {
         }
     }
 
+    /// Initialise ResponseBody that contains a sequence of ByteBuffers
+    /// - Parameter byteBuffers: Sequence of ByteBuffers to write
+    public init<BufferSequence: Sequence & Sendable>(contentsOf byteBuffers: BufferSequence) where BufferSequence.Element == ByteBuffer {
+        self.init(contentLength: byteBuffers.map { $0.readableBytes }.reduce(0, +)) { writer in
+            try await writer.write(contentsOf: byteBuffers)
+            try await writer.finish(nil)
+        }
+    }
+
     /// Initialise ResponseBody with an AsyncSequence of ByteBuffers
     /// - Parameter asyncSequence: ByteBuffer AsyncSequence
     public init<BufferSequence: AsyncSequence & Sendable>(asyncSequence: BufferSequence) where BufferSequence.Element == ByteBuffer {
         self.init { writer in
-            for try await buffer in asyncSequence {
-                try await writer.write(buffer)
-            }
+            try await writer.write(asyncSequence)
             try await writer.finish(nil)
         }
     }
diff --git a/Tests/HummingbirdTests/ApplicationTests.swift b/Tests/HummingbirdTests/ApplicationTests.swift
@@ -249,6 +249,29 @@ final class ApplicationTests: XCTestCase {
         }
     }
 
+    func testResponseBodySequence() async throws {
+        let router = Router()
+        router
+            .group("/echo-body")
+            .post { request, _ -> Response in
+                var buffers: [ByteBuffer] = []
+                for try await buffer in request.body {
+                    buffers.append(buffer)
+                }
+                return .init(status: .ok, headers: [:], body: .init(contentsOf: buffers))
+            }
+        let app = Application(responder: router.buildResponder())
+        try await app.test(.router) { client in
+
+            let buffer = Self.randomBuffer(size: 400_000)
+            try await client.execute(uri: "/echo-body", method: .post, body: buffer) { response in
+                XCTAssertEqual(response.status, .ok)
+                XCTAssertEqual(response.headers[.contentLength], "400000")
+                XCTAssertEqual(response.body, buffer)
+            }
+        }
+    }
+
     /// Test streaming of requests and streaming of responses by streaming the request body into a response streamer
     func testStreaming() async throws {
         let router = Router()
diff --git a/Tests/HummingbirdTests/FileIOTests.swift b/Tests/HummingbirdTests/FileIOTests.swift
@@ -27,12 +27,12 @@ class FileIOTests: XCTestCase {
         let router = Router()
         router.get("test.jpg") { _, context -> Response in
             let fileIO = FileIO(threadPool: .singleton)
-            let body = try await fileIO.loadFile(path: "test.jpg", context: context)
+            let body = try await fileIO.loadFile(path: "testReadFileIO.jpg", context: context)
             return .init(status: .ok, headers: [:], body: body)
         }
         let buffer = Self.randomBuffer(size: 320_003)
         let data = Data(buffer: buffer)
-        let fileURL = URL(fileURLWithPath: "test.jpg")
+        let fileURL = URL(fileURLWithPath: "testReadFileIO.jpg")
         XCTAssertNoThrow(try data.write(to: fileURL))
         defer { XCTAssertNoThrow(try FileManager.default.removeItem(at: fileURL)) }
 
@@ -45,6 +45,31 @@ class FileIOTests: XCTestCase {
         }
     }
 
+    func testReadMultipleFilesOnSameConnection() async throws {
+        let router = Router()
+        router.get("test.jpg") { _, context -> Response in
+            let fileIO = FileIO(threadPool: .singleton)
+            let body = try await fileIO.loadFile(path: "testReadMultipleFilesOnSameConnection.jpg", context: context)
+            return .init(status: .ok, headers: [:], body: body)
+        }
+        let buffer = Self.randomBuffer(size: 54003)
+        let data = Data(buffer: buffer)
+        let fileURL = URL(fileURLWithPath: "testReadMultipleFilesOnSameConnection.jpg")
+        XCTAssertNoThrow(try data.write(to: fileURL))
+        defer { XCTAssertNoThrow(try FileManager.default.removeItem(at: fileURL)) }
+
+        let app = Application(responder: router.buildResponder())
+
+        try await app.test(.live) { client in
+            try await client.execute(uri: "/test.jpg", method: .get) { response in
+                XCTAssertEqual(response.body, buffer)
+            }
+            try await client.execute(uri: "/test.jpg", method: .get) { response in
+                XCTAssertEqual(response.body, buffer)
+            }
+        }
+    }
+
     func testWrite() async throws {
         let filename = "testWrite.txt"
         let router = Router()
diff --git a/Tests/HummingbirdTests/MetricsTests.swift b/Tests/HummingbirdTests/MetricsTests.swift
@@ -14,7 +14,7 @@
 
 import Hummingbird
 import HummingbirdTesting
-@preconcurrency import Metrics
+import Metrics
 import NIOConcurrencyHelpers
 import XCTest
 
