folly/io/async/test/MockAsyncSSLSocket.h

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #pragma once
  17
  18 #include <folly/io/async/AsyncSSLSocket.h>
  19 #include <folly/portability/GMock.h>
  20
  21 namespace folly { namespace test {
  22
  23 class MockAsyncSSLSocket : public AsyncSSLSocket {
  24  public:
  25   MockAsyncSSLSocket(
  26    const std::shared_ptr<SSLContext>& ctx,
  27    EventBase* base,
  28    bool deferSecurityNegotiation = false) :
  29     AsyncSSLSocket(ctx, base, deferSecurityNegotiation) {
  30   }
  31
  32   GMOCK_METHOD5_(, noexcept, ,
  33    connect,
  34    void(AsyncSocket::ConnectCallback*,
  35     const folly::SocketAddress&,
  36     int,
  37     const OptionMap&,
  38     const folly::SocketAddress&));
  39   MOCK_CONST_METHOD1(getLocalAddress, void(folly::SocketAddress*));
  40   MOCK_CONST_METHOD1(getPeerAddress, void(folly::SocketAddress*));
  41   MOCK_METHOD0(closeNow, void());
  42   MOCK_CONST_METHOD0(good, bool());
  43   MOCK_CONST_METHOD0(readable, bool());
  44   MOCK_CONST_METHOD0(hangup, bool());
  45   MOCK_CONST_METHOD3(getSelectedNextProtocol,
  46                      void(const unsigned char**,
  47                           unsigned*,
  48                           SSLContext::NextProtocolType*));
  49   MOCK_CONST_METHOD3(getSelectedNextProtocolNoThrow,
  50                      bool(const unsigned char**,
  51                           unsigned*,
  52                           SSLContext::NextProtocolType*));
  53   MOCK_METHOD1(setPeek, void(bool));
  54   MOCK_METHOD1(setReadCB, void(ReadCallback*));
  55
  56   void sslConn(
  57       AsyncSSLSocket::HandshakeCB* cb,
  58       std::chrono::milliseconds timeout,
  59       const SSLContext::SSLVerifyPeerEnum& verify) override {
  60     if (timeout > std::chrono::milliseconds::zero()) {
  61       handshakeTimeout_.scheduleTimeout(timeout);
  62     }
  63
  64     state_ = StateEnum::ESTABLISHED;
  65     sslState_ = STATE_CONNECTING;
  66     handshakeCallback_ = cb;
  67
  68     sslConnectMockable(cb, timeout, verify);
  69   }
  70
  71   void sslAccept(
  72       AsyncSSLSocket::HandshakeCB* cb,
  73       std::chrono::milliseconds timeout,
  74       const SSLContext::SSLVerifyPeerEnum& verify) override {
  75     if (timeout > std::chrono::milliseconds::zero()) {
  76       handshakeTimeout_.scheduleTimeout(timeout);
  77     }
  78
  79     state_ = StateEnum::ESTABLISHED;
  80     sslState_ = STATE_ACCEPTING;
  81     handshakeCallback_ = cb;
  82
  83     sslAcceptMockable(cb, timeout, verify);
  84   }
  85
  86   MOCK_METHOD3(
  87       sslConnectMockable,
  88       void(
  89           AsyncSSLSocket::HandshakeCB*,
  90           std::chrono::milliseconds,
  91           const SSLContext::SSLVerifyPeerEnum&));
  92
  93   MOCK_METHOD3(
  94       sslAcceptMockable,
  95       void(
  96           AsyncSSLSocket::HandshakeCB*,
  97           std::chrono::milliseconds,
  98           const SSLContext::SSLVerifyPeerEnum&));
  99 };
 100
 101 }}