folly/io/async/test/MockAsyncSSLSocket.h

   1 /*
   2  * Copyright 2016 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 #include <gmock/gmock.h>
  18
  19 #include <folly/io/async/AsyncSSLSocket.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     uint64_t timeout,
  59     const SSLContext::SSLVerifyPeerEnum& verify)
  60       override {
  61     if (timeout > 0) {
  62       handshakeTimeout_.scheduleTimeout((uint32_t)timeout);
  63     }
  64
  65     state_ = StateEnum::ESTABLISHED;
  66     sslState_ = STATE_CONNECTING;
  67     handshakeCallback_ = cb;
  68
  69     sslConnectMockable(cb, timeout, verify);
  70   }
  71
  72   void sslAccept(
  73     AsyncSSLSocket::HandshakeCB* cb,
  74     uint32_t timeout,
  75     const SSLContext::SSLVerifyPeerEnum& verify)
  76       override {
  77     if (timeout > 0) {
  78       handshakeTimeout_.scheduleTimeout(timeout);
  79     }
  80
  81     state_ = StateEnum::ESTABLISHED;
  82     sslState_ = STATE_ACCEPTING;
  83     handshakeCallback_ = cb;
  84
  85     sslAcceptMockable(cb, timeout, verify);
  86   }
  87
  88   MOCK_METHOD3(
  89    sslConnectMockable,
  90    void(AsyncSSLSocket::HandshakeCB*, uint64_t,
  91      const SSLContext::SSLVerifyPeerEnum&));
  92
  93   MOCK_METHOD3(
  94    sslAcceptMockable,
  95    void(AsyncSSLSocket::HandshakeCB*, uint32_t,
  96      const SSLContext::SSLVerifyPeerEnum&));
  97 };
  98
  99 }}