Provide a 'FakeChannel' (#864)

Motivation:

When consuming gRPC it is often helpful to be able to write tests that
ensure the client is integrated correctly. At the moment this is only
possible by running a local gRPC server with a custom service handler to
return the responses you would like to test.

Modifications:

This is a continuation of the work started in #855.

- This change addes a 'FakeChannel' this is the glue that binds the Call
  objects with the 'fake responses' added in the aforementioned pull
  request.
- Also adds a 'write capturing' handler which forwards request parts to
  a handler provided on the fake response.
- Appropriate internal initializers on each of the call types.

Result:

- Users can manually create 'test' RPCs.

Sources/GRPC/ClientCalls/BidirectionalStreamingCall.swift

@@ -166,5 +166,34 @@ extension BidirectionalStreamingCall {
 
     return BidirectionalStreamingCall(transport: transport, options: callOptions)
   }
-}
 
+  internal static func make(
+    fakeResponse: FakeStreamingResponse<RequestPayload, ResponsePayload>?,
+    callOptions: CallOptions,
+    logger: Logger,
+    responseHandler: @escaping (ResponsePayload) -> Void
+  ) -> BidirectionalStreamingCall<RequestPayload, ResponsePayload> {
+    let eventLoop = fakeResponse?.channel.eventLoop ?? EmbeddedEventLoop()
+    let responseContainer = ResponsePartContainer(eventLoop: eventLoop, streamingResponseHandler: responseHandler)
+
+    let transport: ChannelTransport<RequestPayload, ResponsePayload>
+    if let fakeResponse = fakeResponse {
+      transport = .init(
+        fakeResponse: fakeResponse,
+        responseContainer: responseContainer,
+        timeLimit: callOptions.timeLimit,
+        logger: logger
+      )
+
+      fakeResponse.activate()
+    } else {
+      transport = .makeTransportForMissingFakeResponse(
+        eventLoop: eventLoop,
+        responseContainer: responseContainer,
+        logger: logger
+      )
+    }
+
+    return BidirectionalStreamingCall(transport: transport, options: callOptions)
+  }
+}

Sources/GRPC/ClientCalls/ClientCallTransport.swift

@@ -179,6 +179,46 @@ internal class ChannelTransport<Request: GRPCPayload, Response: GRPCPayload> {
       }
     }
   }
+
+  internal convenience init(
+    fakeResponse: _FakeResponseStream<Request, Response>,
+    responseContainer: ResponsePartContainer<Response>,
+    timeLimit: TimeLimit,
+    logger: Logger
+  ) {
+    self.init(
+      eventLoop: fakeResponse.channel.eventLoop,
+      responseContainer: responseContainer,
+      timeLimit: timeLimit,
+      errorDelegate: nil,
+      logger: logger
+    ) { call, streamPromise in
+      fakeResponse.channel.pipeline.addHandler(GRPCClientCallHandler(call: call)).map {
+        fakeResponse.channel
+      }.cascade(to: streamPromise)
+    }
+  }
+
+  /// Makes a transport whose channel promise is failed immediately.
+  internal static func makeTransportForMissingFakeResponse(
+    eventLoop: EventLoop,
+    responseContainer: ResponsePartContainer<Response>,
+    logger: Logger
+  ) -> ChannelTransport<Request, Response> {
+    return .init(
+      eventLoop: eventLoop,
+      responseContainer: responseContainer,
+      timeLimit: .none,
+      errorDelegate: nil,
+      logger: logger
+    ) { call, promise in
+      let error = GRPCStatus(
+        code: .unavailable,
+        message: "No fake response was registered before starting an RPC."
+      )
+      promise.fail(error)
+    }
+  }
 }
 
 // MARK: - Call API (i.e. called from {Unary,ClientStreaming,...}Call)

Sources/GRPC/ClientCalls/ClientStreamingCall.swift

@@ -170,4 +170,35 @@ extension ClientStreamingCall {
     )
     return ClientStreamingCall(response: responsePromise.futureResult, transport: transport, options: callOptions)
   }
+
+  internal static func make(
+    fakeResponse: FakeUnaryResponse<RequestPayload, ResponsePayload>?,
+    callOptions: CallOptions,
+    logger: Logger
+  ) -> ClientStreamingCall<RequestPayload, ResponsePayload> {
+    let eventLoop = fakeResponse?.channel.eventLoop ?? EmbeddedEventLoop()
+    let responsePromise: EventLoopPromise<ResponsePayload> = eventLoop.makePromise()
+    let responseContainer = ResponsePartContainer(eventLoop: eventLoop, unaryResponsePromise: responsePromise)
+
+    let transport: ChannelTransport<RequestPayload, ResponsePayload>
+    if let fakeResponse = fakeResponse {
+      transport = .init(
+        fakeResponse: fakeResponse,
+        responseContainer: responseContainer,
+        timeLimit: callOptions.timeLimit,
+        logger: logger
+      )
+
+      fakeResponse.activate()
+    } else {
+      transport = .makeTransportForMissingFakeResponse(
+        eventLoop: eventLoop,
+        responseContainer: responseContainer,
+        logger: logger
+      )
+    }
+
+    return ClientStreamingCall(response: responsePromise.futureResult, transport: transport, options: callOptions)
+  }
+
 }

Sources/GRPC/ClientCalls/ServerStreamingCall.swift

@@ -112,4 +112,34 @@ extension ServerStreamingCall {
 
     return ServerStreamingCall(transport: transport, options: callOptions)
   }
+
+  internal static func make(
+    fakeResponse: FakeStreamingResponse<RequestPayload, ResponsePayload>?,
+    callOptions: CallOptions,
+    logger: Logger,
+    responseHandler: @escaping (ResponsePayload) -> Void
+  ) -> ServerStreamingCall<RequestPayload, ResponsePayload> {
+    let eventLoop = fakeResponse?.channel.eventLoop ?? EmbeddedEventLoop()
+    let responseContainer = ResponsePartContainer(eventLoop: eventLoop, streamingResponseHandler: responseHandler)
+
+    let transport: ChannelTransport<RequestPayload, ResponsePayload>
+    if let callProxy = fakeResponse {
+      transport = .init(
+        fakeResponse: callProxy,
+        responseContainer: responseContainer,
+        timeLimit: callOptions.timeLimit,
+        logger: logger
+      )
+
+      callProxy.activate()
+    } else {
+      transport = .makeTransportForMissingFakeResponse(
+        eventLoop: eventLoop,
+        responseContainer: responseContainer,
+        logger: logger
+      )
+    }
+
+    return ServerStreamingCall(transport: transport, options: callOptions)
+  }
 }

Sources/GRPC/ClientCalls/UnaryCall.swift

@@ -118,4 +118,34 @@ extension UnaryCall {
     )
     return UnaryCall(response: responsePromise.futureResult, transport: transport, options: callOptions)
   }
+
+  internal static func make(
+    fakeResponse: FakeUnaryResponse<RequestPayload, ResponsePayload>?,
+    callOptions: CallOptions,
+    logger: Logger
+  ) -> UnaryCall<RequestPayload, ResponsePayload> {
+    let eventLoop = fakeResponse?.channel.eventLoop ?? EmbeddedEventLoop()
+    let responsePromise: EventLoopPromise<ResponsePayload> = eventLoop.makePromise()
+    let responseContainer = ResponsePartContainer(eventLoop: eventLoop, unaryResponsePromise: responsePromise)
+
+    let transport: ChannelTransport<RequestPayload, ResponsePayload>
+    if let fakeResponse = fakeResponse {
+      transport = .init(
+        fakeResponse: fakeResponse,
+        responseContainer: responseContainer,
+        timeLimit: callOptions.timeLimit,
+        logger: logger
+      )
+
+      fakeResponse.activate()
+    } else {
+      transport = .makeTransportForMissingFakeResponse(
+        eventLoop: eventLoop,
+        responseContainer: responseContainer,
+        logger: logger
+      )
+    }
+
+    return UnaryCall(response: responsePromise.futureResult, transport: transport, options: callOptions)
+  }
 }

Sources/GRPC/FakeChannel.swift

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2020, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import NIO
+import Logging
+
+/// A fake channel for use with generated test clients.
+///
+/// The `FakeChannel` provides factories for calls which avoid most of the gRPC stack and don't do
+/// real networking. Each call relies on either a `FakeUnaryResponse` or a `FakeStreamingResponse`
+/// to get responses or errors. The fake response of each type should be registered with the channel
+/// prior to making a call via `makeFakeUnaryResponse` or `makeFakeStreamingResponse` respectively.
+///
+/// Users will typically not be required to interact with the channel directly, instead they should
+/// do so via a generated test client.
+public class FakeChannel: GRPCChannel {
+  /// Fake response streams keyed by their path.
+  private var responseStreams: [String: CircularBuffer<Any>]
+
+  /// A logger.
+  public let logger: Logger
+
+  public init(logger: Logger = Logger(label: "io.grpc.testing")) {
+    self.responseStreams = [:]
+    self.logger = logger
+  }
+
+  /// Make and store a fake unary response for the given path. Users should prefer making a response
+  /// stream for their RPC directly via the appropriate method on their generated test client.
+  public func makeFakeUnaryResponse<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    requestHandler: @escaping (FakeRequestPart<Request>) -> ()
+  ) -> FakeUnaryResponse<Request, Response> {
+    let proxy = FakeUnaryResponse<Request, Response>(requestHandler: requestHandler)
+    self.responseStreams[path, default: []].append(proxy)
+    return proxy
+  }
+
+  /// Make and store a fake streaming response for the given path. Users should prefer making a
+  /// response stream for their RPC directly via the appropriate method on their generated test
+  /// client.
+  public func makeFakeStreamingResponse<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    requestHandler: @escaping (FakeRequestPart<Request>) -> ()
+  ) -> FakeStreamingResponse<Request, Response> {
+    let proxy = FakeStreamingResponse<Request, Response>(requestHandler: requestHandler)
+    self.responseStreams[path, default: []].append(proxy)
+    return proxy
+  }
+
+  // (Docs inherited from `GRPCChannel`)
+  public func makeUnaryCall<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    request: Request,
+    callOptions: CallOptions
+  ) -> UnaryCall<Request, Response> {
+    let call = UnaryCall<Request, Response>.make(
+      fakeResponse: self.dequeueResponseStream(forPath: path),
+      callOptions: callOptions,
+      logger: self.logger
+    )
+
+    call.send(self.makeRequestHead(path: path, callOptions: callOptions), request: request)
+
+    return call
+  }
+
+  // (Docs inherited from `GRPCChannel`)
+  public func makeServerStreamingCall<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    request: Request,
+    callOptions: CallOptions,
+    handler: @escaping (Response) -> Void
+  ) -> ServerStreamingCall<Request, Response> {
+    let call = ServerStreamingCall<Request, Response>.make(
+      fakeResponse: self.dequeueResponseStream(forPath: path),
+      callOptions: callOptions,
+      logger: self.logger,
+      responseHandler: handler
+    )
+
+    call.send(self.makeRequestHead(path: path, callOptions: callOptions), request: request)
+
+    return call
+  }
+
+  // (Docs inherited from `GRPCChannel`)
+  public func makeClientStreamingCall<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    callOptions: CallOptions
+  ) -> ClientStreamingCall<Request, Response> {
+    let call = ClientStreamingCall<Request, Response>.make(
+      fakeResponse: self.dequeueResponseStream(forPath: path),
+      callOptions: callOptions,
+      logger: self.logger
+    )
+
+    call.sendHead(self.makeRequestHead(path: path, callOptions: callOptions))
+
+    return call
+  }
+
+  // (Docs inherited from `GRPCChannel`)
+  public func makeBidirectionalStreamingCall<Request: GRPCPayload, Response: GRPCPayload>(
+    path: String,
+    callOptions: CallOptions,
+    handler: @escaping (Response) -> Void
+  ) -> BidirectionalStreamingCall<Request, Response> {
+    let call = BidirectionalStreamingCall<Request, Response>.make(
+      fakeResponse: self.dequeueResponseStream(forPath: path),
+      callOptions: callOptions,
+      logger: self.logger,
+      responseHandler: handler
+    )
+
+    call.sendHead(self.makeRequestHead(path: path, callOptions: callOptions))
+
+    return call
+  }
+
+  public func close() -> EventLoopFuture<Void> {
+    // We don't have anything to close.
+    return EmbeddedEventLoop().makeSucceededFuture(())
+  }
+}
+
+extension FakeChannel {
+  /// Dequeue a proxy for the given path and casts it to the given type, if one exists.
+  private func dequeueResponseStream<Stream>(
+    forPath path: String,
+    as: Stream.Type = Stream.self
+  ) -> Stream? {
+    guard var streams = self.responseStreams[path], !streams.isEmpty else {
+      return nil
+    }
+
+    // This is fine: we know we're non-empty.
+    let first = streams.removeFirst()
+    self.responseStreams.updateValue(streams, forKey: path)
+
+    return first as? Stream
+  }
+
+  private func makeRequestHead(path: String, callOptions: CallOptions) -> _GRPCRequestHead {
+    return _GRPCRequestHead(
+      scheme: "http",
+      path: path,
+      host: "localhost",
+      requestID: callOptions.requestIDProvider.requestID(),
+      options: callOptions
+    )
+  }
+}

Sources/GRPC/WriteCapturingHandler.swift

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import NIO
+
+/// A handler which redirects all writes into a callback until the `.end` part is seen, after which
+/// all writes will be failed.
+///
+/// This handler is intended for use with 'fake' response streams the 'FakeChannel'.
+internal final class WriteCapturingHandler<Request: GRPCPayload>: ChannelOutboundHandler {
+  typealias OutboundIn = _GRPCClientRequestPart<Request>
+  typealias RequestHandler = (FakeRequestPart<Request>) -> ()
+
+  private var state: State
+  private enum State {
+    case active(RequestHandler)
+    case inactive
+  }
+
+  internal init(requestHandler: @escaping RequestHandler) {
+    self.state = .active(requestHandler)
+  }
+
+  internal func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
+    guard case let .active(handler) = self.state else {
+      promise?.fail(ChannelError.ioOnClosedChannel)
+      return
+    }
+
+    switch self.unwrapOutboundIn(data) {
+    case .head(let requestHead):
+      handler(.metadata(requestHead.customMetadata))
+
+    case .message(let messageContext):
+      handler(.message(messageContext.message))
+
+    case .end:
+      handler(.end)
+      // We're done now.
+      self.state = .inactive
+    }
+
+    promise?.succeed(())
+  }
+}

Sources/GRPC/_FakeResponseStream.swift

@@ -16,6 +16,12 @@
 import NIO
 import NIOHPACK
 
+public enum FakeRequestPart<Request: GRPCPayload> {
+  case metadata(HPACKHeaders)
+  case message(Request)
+  case end
+}
+
 /// Sending on a fake response stream would have resulted in a protocol violation (such as
 /// sending initial metadata multiple times or sending messages after the stream has closed).
 public struct FakeResponseProtocolViolation: Error, Hashable {
@@ -70,11 +76,11 @@ public class _FakeResponseStream<Request: GRPCPayload, Response: GRPCPayload> {
     case closed
   }
 
-  internal init() {
+  internal init(requestHandler: @escaping (FakeRequestPart<Request>) -> ()) {
     self.activeState = .inactive
     self.sendState = .idle
     self.responseBuffer = CircularBuffer()
-    self.channel = EmbeddedChannel()
+    self.channel = EmbeddedChannel(handler: WriteCapturingHandler(requestHandler: requestHandler))
   }
 
   /// Activate the test proxy; this should be called
@@ -227,8 +233,8 @@ public class _FakeResponseStream<Request: GRPCPayload, Response: GRPCPayload> {
 /// `sendError` may be used to terminate an RPC without providing a response. As for `sendMessage`,
 /// the `trailingMetadata` defaults to being empty.
 public class FakeUnaryResponse<Request: GRPCPayload, Response: GRPCPayload>: _FakeResponseStream<Request, Response> {
-  public override init() {
-    super.init()
+  public override init(requestHandler: @escaping (FakeRequestPart<Request>) -> () = { _ in }) {
+    super.init(requestHandler: requestHandler)
   }
 
   /// Send a response message to the client.
@@ -290,8 +296,8 @@ public class FakeUnaryResponse<Request: GRPCPayload, Response: GRPCPayload>: _Fa
 /// `sendError` may be called at any time to indicate an error on the response stream.
 /// Like `sendEnd`, `trailingMetadata` is empty by default.
 public class FakeStreamingResponse<Request: GRPCPayload, Response: GRPCPayload>: _FakeResponseStream<Request, Response> {
-  public override init() {
-    super.init()
+  public override init(requestHandler: @escaping (FakeRequestPart<Request>) -> () = { _ in }) {
+    super.init(requestHandler: requestHandler)
   }
 
   /// Send initial metadata to the client.

Tests/GRPCTests/FakeChannelTests.swift

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2020, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import GRPC
+import EchoModel
+import NIO
+import XCTest
+
+class FakeChannelTests: GRPCTestCase {
+  typealias Request = Echo_EchoRequest
+  typealias Response = Echo_EchoResponse
+
+  var channel: FakeChannel!
+
+  override func setUp() {
+    self.channel = FakeChannel()
+  }
+
+  private func makeUnaryResponse(
+    path: String = "/foo/bar",
+    requestHandler: @escaping (FakeRequestPart<Request>) -> () = { _ in }
+  ) -> FakeUnaryResponse<Request, Response> {
+    return self.channel.makeFakeUnaryResponse(path: path, requestHandler: requestHandler)
+  }
+
+  private func makeStreamingResponse(
+    path: String = "/foo/bar",
+    requestHandler: @escaping (FakeRequestPart<Request>) -> () = { _ in }
+  ) -> FakeStreamingResponse<Request, Response> {
+    return self.channel.makeFakeStreamingResponse(path: path, requestHandler: requestHandler)
+  }
+
+  private func makeUnaryCall(
+    request: Request,
+    path: String = "/foo/bar",
+    callOptions: CallOptions = CallOptions()
+  ) -> UnaryCall<Request, Response> {
+    return self.channel.makeUnaryCall(path: path, request: request, callOptions: callOptions)
+  }
+
+  private func makeBidirectionalStreamingCall(
+    path: String = "/foo/bar",
+    callOptions: CallOptions = CallOptions(),
+    handler: @escaping (Response) -> ()
+  ) -> BidirectionalStreamingCall<Request, Response> {
+    return self.channel.makeBidirectionalStreamingCall(path: path, callOptions: callOptions, handler: handler)
+  }
+
+  func testUnary() {
+    let response = self.makeUnaryResponse { part in
+      switch part {
+      case .message(let request):
+        XCTAssertEqual(request, Request.with { $0.text = "Foo" })
+      default:
+        ()
+      }
+    }
+
+    let call = self.makeUnaryCall(request: .with { $0.text = "Foo" })
+
+    XCTAssertNoThrow(try response.sendMessage(.with { $0.text = "Bar" }))
+    XCTAssertEqual(try call.response.wait(), .with { $0.text = "Bar"} )
+    XCTAssertTrue(try call.status.map { $0.isOk }.wait())
+  }
+
+  func testBidirectional() {
+    var requests: [Request] = []
+    let response = self.makeStreamingResponse { part in
+      switch part {
+      case .message(let request):
+        requests.append(request)
+      default:
+        ()
+      }
+    }
+
+    var responses: [Response] = []
+    let call = self.makeBidirectionalStreamingCall {
+      responses.append($0)
+    }
+
+    XCTAssertNoThrow(try call.sendMessage(.with { $0.text = "1" }).wait())
+    XCTAssertNoThrow(try call.sendMessage(.with { $0.text = "2" }).wait())
+    XCTAssertNoThrow(try call.sendMessage(.with { $0.text = "3" }).wait())
+    XCTAssertNoThrow(try call.sendEnd().wait())
+
+    XCTAssertEqual(requests, (1...3).map { number in .with { $0.text = "\(number)" }})
+
+    XCTAssertNoThrow(try response.sendMessage(.with { $0.text = "4" }))
+    XCTAssertNoThrow(try response.sendMessage(.with { $0.text = "5" }))
+    XCTAssertNoThrow(try response.sendMessage(.with { $0.text = "6" }))
+    XCTAssertNoThrow(try response.sendEnd())
+
+    XCTAssertEqual(responses, (4...6).map { number in .with { $0.text = "\(number)" }})
+    XCTAssertTrue(try call.status.map { $0.isOk }.wait())
+  }
+
+  func testMissingResponse() {
+    let call = self.makeUnaryCall(request: .with { $0.text = "Not going to work" })
+
+    XCTAssertThrowsError(try call.initialMetadata.wait())
+    XCTAssertThrowsError(try call.response.wait())
+    XCTAssertThrowsError(try call.trailingMetadata.wait())
+    XCTAssertFalse(try call.status.map { $0.isOk }.wait())
+  }
+
+  func testResponseIsReallyDequeued() {
+    let response = self.makeUnaryResponse()
+    let call = self.makeUnaryCall(request: .with { $0.text = "Ping" })
+
+    XCTAssertNoThrow(try response.sendMessage(.with { $0.text = "Pong" }))
+    XCTAssertEqual(try call.response.wait(), .with { $0.text = "Pong" })
+
+    let failedCall = self.makeUnaryCall(request: .with { $0.text = "Not going to work" })
+    XCTAssertThrowsError(try failedCall.initialMetadata.wait())
+    XCTAssertThrowsError(try failedCall.response.wait())
+    XCTAssertThrowsError(try failedCall.trailingMetadata.wait())
+    XCTAssertFalse(try failedCall.status.map { $0.isOk }.wait())
+  }
+}

Tests/GRPCTests/XCTestManifests.swift

@@ -186,6 +186,18 @@ extension DelegatingErrorHandlerTests {
     ]
 }
 
+extension FakeChannelTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FakeChannelTests = [
+        ("testBidirectional", testBidirectional),
+        ("testMissingResponse", testMissingResponse),
+        ("testResponseIsReallyDequeued", testResponseIsReallyDequeued),
+        ("testUnary", testUnary),
+    ]
+}
+
 extension FakeResponseStreamTests {
     // DO NOT MODIFY: This is autogenerated, use:
     //   `swift test --generate-linuxmain`
@@ -807,6 +819,7 @@ public func __allTests() -> [XCTestCaseEntry] {
         testCase(ConnectionManagerTests.__allTests__ConnectionManagerTests),
         testCase(ConnectivityStateMonitorTests.__allTests__ConnectivityStateMonitorTests),
         testCase(DelegatingErrorHandlerTests.__allTests__DelegatingErrorHandlerTests),
+        testCase(FakeChannelTests.__allTests__FakeChannelTests),
         testCase(FakeResponseStreamTests.__allTests__FakeResponseStreamTests),
         testCase(FunctionalTestsAnonymousClient.__allTests__FunctionalTestsAnonymousClient),
         testCase(FunctionalTestsAnonymousClientNIOTS.__allTests__FunctionalTestsAnonymousClientNIOTS),