grpc-swift/Tests/GRPCTests/XCTestHelpers.swift

/*
 * 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.
 */
@testable import GRPC
import NIOHPACK
import NIOHTTP2
import XCTest

struct UnwrapError: Error {}

// We support Swift versions before 'XCTUnwrap' was introduced.
func assertNotNil<Value>(
  _ expression: @autoclosure () throws -> Value?,
  message: @autoclosure () -> String = "Optional value was nil",
  file: StaticString = #file,
  line: UInt = #line
) throws -> Value {
  guard let value = try expression() else {
    XCTFail(message(), file: file, line: line)
    throw UnwrapError()
  }
  return value
}

func assertNoThrow<Value>(
  _ expression: @autoclosure () throws -> Value,
  message: @autoclosure () -> String = "Unexpected error thrown",
  file: StaticString = #file,
  line: UInt = #line
) throws -> Value {
  do {
    return try expression()
  } catch {
    XCTFail(message(), file: file, line: line)
    throw error
  }
}

// MARK: - Matchers.

func assertThat<Value>(
  _ expression: @autoclosure @escaping () throws -> Value,
  _ matcher: Matcher<Value>,
  file: StaticString = #file,
  line: UInt = #line
) {
  // For value matchers we'll assert that we don't throw by default.
  assertThat(try expression(), .doesNotThrow(matcher), file: file, line: line)
}

func assertThat<Value>(
  _ expression: @autoclosure @escaping () throws -> Value,
  _ matcher: ExpressionMatcher<Value>,
  file: StaticString = #file,
  line: UInt = #line
) {
  switch matcher.evaluate(expression) {
  case .match:
    ()
  case let .noMatch(actual: actual, expected: expected):
    XCTFail("ACTUAL: \(actual), EXPECTED: \(expected)", file: file, line: line)
  }
}

enum MatchResult {
  case match
  case noMatch(actual: String, expected: String)
}

struct Matcher<Value> {
  fileprivate typealias Evaluator = (Value) -> MatchResult
  private var matcher: Evaluator

  fileprivate init(_ matcher: @escaping Evaluator) {
    self.matcher = matcher
  }

  fileprivate func evaluate(_ value: Value) -> MatchResult {
    return self.matcher(value)
  }

  // MARK: Sugar

  /// Just returns the provided matcher.
  static func `is`<Value>(_ matcher: Matcher<Value>) -> Matcher<Value> {
    return matcher
  }

  /// Just returns the provided matcher.
  static func and<Value>(_ matcher: Matcher<Value>) -> Matcher<Value> {
    return matcher
  }

  // MARK: Equality

  /// Checks the equality of the actual value against the provided value. See `equalTo(_:)`.
  static func `is`<Value: Equatable>(_ value: Value) -> Matcher<Value> {
    return .equalTo(value)
  }

  /// Checks the equality of the actual value against the provided value.
  static func equalTo<Value: Equatable>(_ expected: Value) -> Matcher<Value> {
    return .init { actual in
      actual == expected
        ? .match
        : .noMatch(actual: "\(actual)", expected: "equal to \(expected)")
    }
  }

  /// Always returns a 'match', useful when the expected value is `Void`.
  static func isVoid() -> Matcher<Void> {
    return .init {
      return .match
    }
  }

  /// Matches if the value is `nil`.
  static func `nil`<Value>() -> Matcher<Value?> {
    return .init { actual in
      actual == nil
        ? .match
        : .noMatch(actual: String(describing: actual), expected: "nil")
    }
  }

  /// Matches if the value is not `nil`.
  static func notNil<Value>(_ matcher: Matcher<Value>? = nil) -> Matcher<Value?> {
    return .init { actual in
      if let actual = actual {
        return matcher?.evaluate(actual) ?? .match
      } else {
        return .noMatch(actual: "nil", expected: "not nil")
      }
    }
  }

  // MARK: Result

  static func success<Value>(_ matcher: Matcher<Value>? = nil) -> Matcher<Result<Value, Error>> {
    return .init { actual in
      switch actual {
      case let .success(value):
        return matcher?.evaluate(value) ?? .match
      case let .failure(error):
        return .noMatch(actual: "\(error)", expected: "success")
      }
    }
  }

  static func success() -> Matcher<Result<Void, Error>> {
    return .init { actual in
      switch actual {
      case .success:
        return .match
      case let .failure(error):
        return .noMatch(actual: "\(error)", expected: "success")
      }
    }
  }

  static func failure<Success, Failure: Error>(
    _ matcher: Matcher<Failure>? = nil
  ) -> Matcher<Result<Success, Failure>> {
    return .init { actual in
      switch actual {
      case let .success(value):
        return .noMatch(actual: "\(value)", expected: "failure")
      case let .failure(error):
        return matcher?.evaluate(error) ?? .match
      }
    }
  }

  // MARK: Utility

  static func all<Value>(_ matchers: Matcher<Value>...) -> Matcher<Value> {
    return .init { actual in
      for matcher in matchers {
        let result = matcher.evaluate(actual)
        switch result {
        case .noMatch:
          return result
        case .match:
          ()
        }
      }
      return .match
    }
  }

  // MARK: Type

  /// Checks that the actual value is an instance of the given type.
  static func instanceOf<Value, Expected>(_: Expected.Type) -> Matcher<Value> {
    return .init { actual in
      if actual is Expected {
        return .match
      } else {
        return .noMatch(
          actual: String(describing: type(of: actual)) + " (\(actual))",
          expected: "value of type \(Expected.self)"
        )
      }
    }
  }

  // MARK: Collection

  /// Checks whether the collection has the expected count.
  static func hasCount<C: Collection>(_ count: Int) -> Matcher<C> {
    return .init { actual in
      actual.count == count
        ? .match
        : .noMatch(actual: "has count \(actual.count)", expected: "count of \(count)")
    }
  }

  static func isEmpty<C: Collection>() -> Matcher<C> {
    return .init { actual in
      actual.isEmpty
        ? .match
        : .noMatch(actual: "has \(actual.count) items", expected: "is empty")
    }
  }

  // MARK: gRPC matchers

  static func hasCode(_ code: GRPCStatus.Code) -> Matcher<GRPCStatus> {
    return .init { actual in
      actual.code == code
        ? .match
        : .noMatch(actual: "has status code \(actual)", expected: "\(code)")
    }
  }

  static func metadata<Request>(
    _ matcher: Matcher<HPACKHeaders>? = nil
  ) -> Matcher<GRPCServerRequestPart<Request>> {
    return .init { actual in
      switch actual {
      case let .metadata(headers):
        return matcher?.evaluate(headers) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "metadata")
      }
    }
  }

  static func message<Request>(
    _ matcher: Matcher<Request>? = nil
  ) -> Matcher<GRPCServerRequestPart<Request>> {
    return .init { actual in
      switch actual {
      case let .message(message):
        return matcher?.evaluate(message) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "message")
      }
    }
  }

  static func metadata<Response>(
    _ matcher: Matcher<HPACKHeaders>? = nil
  ) -> Matcher<GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .metadata(headers):
        return matcher?.evaluate(headers) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "metadata")
      }
    }
  }

  static func message<Response>(
    _ matcher: Matcher<Response>? = nil
  ) -> Matcher<GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .message(message, _):
        return matcher?.evaluate(message) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "message")
      }
    }
  }

  static func end<Response>(
    status statusMatcher: Matcher<GRPCStatus>? = nil,
    trailers trailersMatcher: Matcher<HPACKHeaders>? = nil
  ) -> Matcher<GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .end(status, trailers):
        let statusMatch = (statusMatcher?.evaluate(status) ?? .match)
        switch statusMatcher?.evaluate(status) ?? .match {
        case .match:
          return trailersMatcher?.evaluate(trailers) ?? .match
        case .noMatch:
          return statusMatch
        }
      default:
        return .noMatch(actual: String(describing: actual), expected: "end")
      }
    }
  }

  static func headers<Response>(
    _ matcher: Matcher<HPACKHeaders>? = nil
  ) -> Matcher<_GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .headers(headers):
        return matcher?.evaluate(headers) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "headers")
      }
    }
  }

  static func message<Response>(
    _ matcher: Matcher<Response>? = nil
  ) -> Matcher<_GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .message(message):
        return matcher?.evaluate(message.message) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "message")
      }
    }
  }

  static func end<Response>(
    _ matcher: Matcher<GRPCStatus>? = nil
  ) -> Matcher<_GRPCServerResponsePart<Response>> {
    return .init { actual in
      switch actual {
      case let .statusAndTrailers(status, _):
        return matcher?.evaluate(status) ?? .match
      default:
        return .noMatch(actual: String(describing: actual), expected: "end")
      }
    }
  }

  // MARK: HTTP/2

  static func contains(
    _ name: String,
    _ values: [String]? = nil
  ) -> Matcher<HPACKHeaders> {
    return .init { actual in
      let headers = actual[canonicalForm: name]

      if headers.isEmpty {
        return .noMatch(actual: "does not contain '\(name)'", expected: "contains '\(name)'")
      } else {
        return values.map { Matcher.equalTo($0).evaluate(headers) } ?? .match
      }
    }
  }

  static func contains(
    caseSensitive caseSensitiveName: String
  ) -> Matcher<HPACKHeaders> {
    return .init { actual in
      for (name, _, _) in actual {
        if name == caseSensitiveName {
          return .match
        }
      }

      return .noMatch(
        actual: "does not contain '\(caseSensitiveName)'",
        expected: "contains '\(caseSensitiveName)'"
      )
    }
  }

  static func headers(
    _ headers: Matcher<HPACKHeaders>? = nil,
    endStream: Bool? = nil
  ) -> Matcher<HTTP2Frame.FramePayload> {
    return .init { actual in
      switch actual {
      case let .headers(payload):
        let headersMatch = headers?.evaluate(payload.headers)

        switch headersMatch {
        case .none,
             .some(.match):
          return endStream.map { Matcher.is($0).evaluate(payload.endStream) } ?? .match
        case .some(.noMatch):
          return headersMatch!
        }
      default:
        return .noMatch(actual: "\(actual)", expected: "headers")
      }
    }
  }

  static func data(endStream: Bool? = nil) -> Matcher<HTTP2Frame.FramePayload> {
    return .init { actual in
      switch actual {
      case let .data(payload):
        return endStream.map { Matcher.is($0).evaluate(payload.endStream) } ?? .match
      default:
        return .noMatch(actual: "\(actual)", expected: "data")
      }
    }
  }

  static func trailersOnly(
    code: GRPCStatus.Code,
    contentType: String = "application/grpc"
  ) -> Matcher<HTTP2Frame.FramePayload> {
    return .headers(
      .all(
        .contains(":status", ["200"]),
        .contains("content-type", [contentType]),
        .contains("grpc-status", ["\(code.rawValue)"])
      ),
      endStream: true
    )
  }

  static func trailers(code: GRPCStatus.Code, message: String) -> Matcher<HTTP2Frame.FramePayload> {
    return .headers(
      .all(
        .contains("grpc-status", ["\(code.rawValue)"]),
        .contains("grpc-message", [message])
      ),
      endStream: true
    )
  }

  // MARK: HTTP2ToRawGRPCStateMachine.Action

  static func errorCaught() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .errorCaught:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "errorCaught")
      }
    }
  }

  static func none() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .none:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "none")
      }
    }
  }

  static func configure() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .configure:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "configure")
      }
    }
  }

  static func completePromise(
    with matcher: Matcher<Result<Void, Error>>? = nil
  ) -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case let .completePromise(_, result):
        return matcher?.evaluate(result) ?? .match
      default:
        return .noMatch(actual: "\(actual)", expected: "completePromise")
      }
    }
  }

  static func forwardHeaders() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardHeaders:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardHeaders")
      }
    }
  }

  static func forwardMessage() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardMessage:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardMessage")
      }
    }
  }

  static func forwardEnd() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardEnd:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardEnd")
      }
    }
  }

  static func forwardMessageAndEnd() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardMessageAndEnd:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardMessageAndEnd")
      }
    }
  }

  static func forwardHeadersThenRead() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardHeadersThenReadNextMessage:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardHeadersThenReadNextMessage")
      }
    }
  }

  static func forwardMessageThenRead() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .forwardMessageThenReadNextMessage:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "forwardMessageThenReadNextMessage")
      }
    }
  }

  static func readNextRequest() -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case .readNextRequest:
        return .match
      default:
        return .noMatch(actual: "\(actual)", expected: "readNextRequest")
      }
    }
  }

  static func write(
    _ matcher: Matcher<HTTP2Frame.FramePayload>? = nil,
    flush: Bool = false
  ) -> Matcher<HTTP2ToRawGRPCStateMachine.Action> {
    return .init { actual in
      switch actual {
      case let .write(payload, _, insertFlush):
        if flush == insertFlush {
          return matcher.map { $0.evaluate(payload) } ?? .match
        } else {
          return .noMatch(actual: "write(_,_,\(insertFlush))", expected: "write(_,_,\(flush))")
        }
      default:
        return .noMatch(actual: "\(actual)", expected: "write")
      }
    }
  }
}

struct ExpressionMatcher<Value> {
  typealias Expression = () throws -> Value
  private typealias Evaluator = (Expression) -> MatchResult
  private var evaluator: Evaluator

  private init(_ evaluator: @escaping Evaluator) {
    self.evaluator = evaluator
  }

  fileprivate func evaluate(_ expression: Expression) -> MatchResult {
    return self.evaluator(expression)
  }

  /// Asserts that the expression does not throw and error. Returns the result of any provided
  /// matcher on the result of the expression.
  static func doesNotThrow<Value>(_ matcher: Matcher<Value>? = nil) -> ExpressionMatcher<Value> {
    return .init { expression in
      do {
        let value = try expression()
        return matcher?.evaluate(value) ?? .match
      } catch {
        return .noMatch(actual: "threw '\(error)'", expected: "should not throw error")
      }
    }
  }

  /// Asserts that the expression throws and error. Returns the result of any provided matcher
  /// on the error thrown by the expression.
  static func `throws`<Value>(_ matcher: Matcher<Error>? = nil) -> ExpressionMatcher<Value> {
    return .init { expression in
      do {
        let value = try expression()
        return .noMatch(actual: "returned '\(value)'", expected: "should throw error")
      } catch {
        return matcher?.evaluate(error) ?? .match
      }
    }
  }
}