Add InstantiableRequestContext

Sources/Hummingbird/Application.swift

@@ -41,7 +41,8 @@ public enum EventLoopGroupProvider {
     }
 }
 
-public protocol ApplicationProtocol: Service where Context: RequestContext, Context.Source == ServerRequestContextSource {
+/// Protocol for an Application. Brings together all the components of Hummingbird together
+public protocol ApplicationProtocol: Service where Context: InstantiableRequestContext, Context.Source == ServerRequestContextSource {
     /// Responder that generates a response from a requests and context
     associatedtype Responder: HTTPResponder
     /// Context passed with Request to responder
@@ -100,10 +101,11 @@ extension ApplicationProtocol {
             eventLoopGroup: self.eventLoopGroup,
             logger: self.logger
         ) { request, channel in
+            let logger = self.logger.with(metadataKey: "hb_id", value: .stringConvertible(RequestID()))
             let context = Self.Responder.Context(
                 source: .init(
                     channel: channel,
-                    logger: self.logger.with(metadataKey: "hb_id", value: .stringConvertible(RequestID()))
+                    logger: logger
                 )
             )
             // respond to request
@@ -117,7 +119,7 @@ extension ApplicationProtocol {
                     response = httpError.response(allocator: channel.allocator)
                 default:
                     // this error has not been recognised
-                    context.logger.debug("Unrecognised Error", metadata: ["error": "\(error)"])
+                    logger.debug("Unrecognised Error", metadata: ["error": "\(error)"])
                     response = Response(
                         status: .internalServerError,
                         body: .init()
@@ -171,7 +173,7 @@ extension ApplicationProtocol {
 /// try await app.runService()
 /// ```
 /// Editing the application setup after calling `runService` will produce undefined behaviour.
-public struct Application<Responder: HTTPResponder>: ApplicationProtocol where Responder.Context: RequestContext, Responder.Context.Source == ServerRequestContextSource {
+public struct Application<Responder: HTTPResponder>: ApplicationProtocol where Responder.Context: InstantiableRequestContext, Responder.Context.Source == ServerRequestContextSource {
     // MARK: Member variables
 
     /// event loop group used by application

Sources/Hummingbird/Server/RequestContext.swift

@@ -78,15 +78,20 @@ public struct CoreRequestContext: Sendable {
     }
 }
 
+/// A RequestContext that can be built from some source
+public protocol InstantiableRequestContext: Sendable {
+    associatedtype Source
+    /// Initialise RequestContext from source
+    init(source: Source)
+}
+
 /// Protocol that all request contexts should conform to. Holds data associated with
 /// a request. Provides context for request processing
-public protocol RequestContext: Sendable {
+public protocol RequestContext: InstantiableRequestContext {
     associatedtype Source: RequestContextSource = ServerRequestContextSource
     associatedtype Decoder: RequestDecoder = JSONDecoder
     associatedtype Encoder: ResponseEncoder = JSONEncoder
 
-    /// Initialise RequestContext from source
-    init(source: Source)
     /// Core context
     var coreContext: CoreRequestContext { get set }
     /// Maximum upload size allowed for routes that don't stream the request payload. This

Sources/HummingbirdTesting/Application+Test.swift

@@ -44,7 +44,7 @@ public struct TestingSetup {
 }
 
 /// Extends `ApplicationProtocol` to support testing of applications
-extension ApplicationProtocol where Responder.Context: RequestContext {
+extension ApplicationProtocol {
     // MARK: Initialization
 
     /// Test `Application`

Sources/HummingbirdTesting/RouterTestFramework.swift

@@ -25,14 +25,14 @@ import NIOPosix
 import ServiceLifecycle
 
 /// Test sending requests directly to router. This does not setup a live server
-struct RouterTestFramework<Responder: HTTPResponder>: ApplicationTestFramework where Responder.Context: RequestContext {
+struct RouterTestFramework<Responder: HTTPResponder>: ApplicationTestFramework where Responder.Context: InstantiableRequestContext {
     let responder: Responder
     let makeContext: @Sendable (Logger) -> Responder.Context
     let services: [any Service]
     let logger: Logger
     let processesRunBeforeServerStart: [@Sendable () async throws -> Void]
 
-    init<App: ApplicationProtocol>(app: App) async throws where App.Responder == Responder, Responder.Context: RequestContext {
+    init<App: ApplicationProtocol>(app: App) async throws where App.Responder == Responder, Responder.Context: InstantiableRequestContext {
         self.responder = try await app.responder
         self.processesRunBeforeServerStart = app.processesRunBeforeServerStart
         self.services = app.services

Tests/HummingbirdTests/ApplicationTests.swift

@@ -554,6 +554,25 @@ final class ApplicationTests: XCTestCase {
         }
     }
 
+    /// test we can create an application that accepts a responder with an empty context
+    func testEmptyRequestContext() async throws {
+        struct EmptyRequestContext: InstantiableRequestContext {
+            typealias Source = ServerRequestContextSource
+
+            init(source: Source) {}
+        }
+        let app = Application(
+            responder: CallbackResponder { (_: Request, _: EmptyRequestContext) in
+                return Response(status: .ok)
+            }
+        )
+        try await app.test(.live) { client in
+            try await client.execute(uri: "/hello", method: .get) { response in
+                XCTAssertEqual(response.status, .ok)
+            }
+        }
+    }
+
     func testHummingbirdServices() async throws {
         struct MyService: Service {
             static let started = ManagedAtomic(false)