Test error propagation when throwing during reading/writing

Author: aryan-25

Tests/HTTPServerTests/HTTPRequestConcludingAsyncReaderTests.swift

@@ -134,6 +134,35 @@ struct HTTPRequestConcludingAsyncReaderTests {
         }
     }
 
+    @Test("Throw while reading request")
+    @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
+    func testThrowingWhileReadingRequest() async throws {
+        let (stream, source) = NIOAsyncChannelInboundStream<HTTPRequestPart>.makeTestingStream()
+
+        let bodyChunks = (0..<10).map { i in ByteBuffer(bytes: [i]) }
+        for chunk in bodyChunks {
+            source.yield(.body(chunk))
+        }
+        source.yield(.end([.cookie: "test"]))
+        source.finish()
+
+        // Check that the read error is propagated
+        try await #require(throws: TestError.errorWhileReading) {
+            let requestReader = HTTPRequestConcludingAsyncReader(
+                iterator: stream.makeAsyncIterator(),
+                readerState: .init()
+            )
+
+            _ = try await requestReader.consumeAndConclude { bodyReader in
+                var bodyReader = bodyReader
+
+                try await bodyReader.read { element in
+                    throw TestError.errorWhileReading
+                }
+            }
+        }
+    }
+
     @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
     @Test("More bytes available than consumption limit")
     func testCollectMoreBytesThanAvailable() async throws {

Tests/HTTPServerTests/HTTPResponseConcludingAsyncWriterTests.swift

@@ -55,6 +55,30 @@ struct HTTPResponseConcludingAsyncWriterTests {
         #expect(trailer == .end(self.trailerSampleOne))
     }
 
+    @Test("Throw while writing response")
+    @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
+    func testThrowWhileProducing() async throws {
+        let (writer, sink) = NIOAsyncChannelOutboundWriter<HTTPResponsePart>.makeTestingWriter()
+
+        // Check that the write error is propagated
+        try await #require(throws: TestError.errorWhileWriting) {
+            let responseWriter = HTTPResponseConcludingAsyncWriter(writer: writer, writerState: .init())
+            try await responseWriter.produceAndConclude { bodyWriter in
+                var bodyWriter = bodyWriter
+
+                // Write an element
+                try await bodyWriter.write(self.bodySampleOne.span)
+                // Then throw
+                throw TestError.errorWhileWriting
+            }
+        }
+
+        var responseIterator = sink.makeAsyncIterator()
+
+        let firstElement = try #require(await responseIterator.next())
+        #expect(firstElement == .body(.init(bytes: self.bodySampleOne)))
+    }
+
     @Test("Write multiple elements and multiple trailers")
     @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
     func testProduceMultipleElementsAndMultipleTrailers() async throws {

Tests/HTTPServerTests/Utilities/TestError.swift

@@ -0,0 +1,5 @@
+// An error type for use in tests
+enum TestError: Error {
+    case errorWhileReading
+    case errorWhileWriting
+}