folly/io/async/test/MockAsyncSSLSocket.h

   1 /*
   2  * Copyright 2015 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_METHOD2(
  46    getSelectedNextProtocol,
  47    void(const unsigned char**, unsigned*));
  48   MOCK_CONST_METHOD2(
  49    getSelectedNextProtocolNoThrow,
  50    bool(const unsigned char**, unsigned*));
  51   MOCK_METHOD1(setPeek, void(bool));
  52   MOCK_METHOD1(setReadCB, void(ReadCallback*));
  53
  54   void sslConn(
  55     AsyncSSLSocket::HandshakeCB* cb,
  56     uint64_t timeout,
  57     const SSLContext::SSLVerifyPeerEnum& verify)
  58       override {
  59     if (timeout > 0) {
  60       handshakeTimeout_.scheduleTimeout((uint32_t)timeout);
  61     }
  62
  63     state_ = StateEnum::ESTABLISHED;
  64     sslState_ = STATE_CONNECTING;
  65     handshakeCallback_ = cb;
  66
  67     sslConnectMockable(cb, timeout, verify);
  68   }
  69
  70   void sslAccept(
  71     AsyncSSLSocket::HandshakeCB* cb,
  72     uint32_t timeout,
  73     const SSLContext::SSLVerifyPeerEnum& verify)
  74       override {
  75     if (timeout > 0) {
  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(AsyncSSLSocket::HandshakeCB*, uint64_t,
  89      const SSLContext::SSLVerifyPeerEnum&));
  90
  91   MOCK_METHOD3(
  92    sslAcceptMockable,
  93    void(AsyncSSLSocket::HandshakeCB*, uint32_t,
  94      const SSLContext::SSLVerifyPeerEnum&));
  95 };
  96
  97 }}