Merge pull request #2 from PassiveLogic/chore/sync-with-base

Chore: Pull base changes

Author: NeedleInAJayStack

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 PassiveLogic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Sources/GraphQLTransportWS/Server.swift

@@ -13,9 +13,9 @@ public class Server<InitPayload: Equatable & Codable> {
 
     let onExecute: (GraphQLRequest) -> EventLoopFuture<GraphQLResult>
     let onSubscribe: (GraphQLRequest) -> EventLoopFuture<SubscriptionResult>
-
-    var auth: (InitPayload) throws -> Void = { _ in }
-    var onExit: () -> Void = {}
+    var auth: (InitPayload) throws -> EventLoopFuture<Void>
+    
+    var onExit: () -> Void = { }
     var onOperationComplete: (String) -> Void = { _ in }
     var onOperationError: (String) -> Void = { _ in }
     var onMessage: (String) -> Void = { _ in }
@@ -33,14 +33,17 @@ public class Server<InitPayload: Equatable & Codable> {
     ///   - messenger: The messenger to bind the server to.
     ///   - onExecute: Callback run during `subscribe` resolution for non-streaming queries. Typically this is `API.execute`.
     ///   - onSubscribe: Callback run during `subscribe` resolution for streaming queries. Typically this is `API.subscribe`.
+    ///   - eventLoop: EventLoop on which to perform server operations.
     public init(
         messenger: Messenger,
         onExecute: @escaping (GraphQLRequest) -> EventLoopFuture<GraphQLResult>,
-        onSubscribe: @escaping (GraphQLRequest) -> EventLoopFuture<SubscriptionResult>
+        onSubscribe: @escaping (GraphQLRequest) -> EventLoopFuture<SubscriptionResult>,
+        eventLoop: EventLoop
     ) {
         self.messenger = messenger
         self.onExecute = onExecute
         self.onSubscribe = onSubscribe
+        self.auth = { _ in eventLoop.makeSucceededVoidFuture() }
 
         messenger.onReceive { message in
             self.onMessage(message)
@@ -103,9 +106,9 @@ public class Server<InitPayload: Equatable & Codable> {
     }
 
     /// Define the callback run during `connection_init` resolution that allows authorization using the `payload`.
-    /// Throw to indicate that authorization has failed.
+    /// Throw or fail the future to indicate that authorization has failed.
     ///  - Parameter callback: The callback to assign
-    public func auth(_ callback: @escaping (InitPayload) throws -> Void) {
+    public func auth(_ callback: @escaping (InitPayload) throws -> EventLoopFuture<Void>) {
         self.auth = callback
     }
 
@@ -150,14 +153,20 @@ public class Server<InitPayload: Equatable & Codable> {
         }
 
         do {
-            try self.auth(connectionInitRequest.payload)
+            let authResult = try self.auth(connectionInitRequest.payload)
+            authResult.whenSuccess {
+                self.initialized = true
+                self.sendConnectionAck()
+            }
+            authResult.whenFailure { error in
+                self.error(.unauthorized())
+                return
+            }
         }
         catch {
             self.error(.unauthorized())
             return
         }
-        initialized = true
-        self.sendConnectionAck()
     }
 
     private func onSubscribe(_ subscribeRequest: SubscribeRequest) {

Tests/GraphQLTransportWSTests/GraphQLTransportWSTests.swift

@@ -39,7 +39,8 @@ final class GraphqlTransportWSTests: XCTestCase {
                     context: context,
                     on: self.eventLoop
                 )
-            }
+            },
+            eventLoop: self.eventLoop
         )
     }
 
@@ -73,8 +74,8 @@ final class GraphqlTransportWSTests: XCTestCase {
     }
 
     /// Tests that throwing in the authorization callback forces an unauthorized error
-    func testAuth() throws {
-        server.auth { _ in
+    func testAuthWithThrow() throws {
+        server.auth { payload in
             throw TestError.couldBeAnything
         }
 
@@ -99,6 +100,34 @@ final class GraphqlTransportWSTests: XCTestCase {
             ["\(ErrorCode.unauthorized): Unauthorized"]
         )
     }
+    
+    /// Tests that failing a future in the authorization callback forces an unauthorized error
+    func testAuthWithFailedFuture() throws {
+        server.auth { payload in
+            self.eventLoop.makeFailedFuture(TestError.couldBeAnything)
+        }
+       
+        var messages = [String]()
+        let completeExpectation = XCTestExpectation()
+
+        let client = Client<TokenInitPayload>(messenger: clientMessenger)
+        client.onMessage { message, _ in
+            messages.append(message)
+            completeExpectation.fulfill()
+        }
+
+        client.sendConnectionInit(
+            payload: TokenInitPayload(
+                authToken: ""
+            )
+        )
+
+        wait(for: [completeExpectation], timeout: 2)
+        XCTAssertEqual(
+            messages,
+            ["\(ErrorCode.unauthorized): Unauthorized"]
+        )
+    }
 
     /// Tests a single-op conversation
     func testSingleOp() throws {