EvbHandshakeHelperTest.cpp File Reference

#include <wangle/acceptor/EvbHandshakeHelper.h>
#include <chrono>
#include <thread>
#include <folly/synchronization/Baton.h>
#include <folly/futures/Barrier.h>
#include <folly/io/async/ScopedEventBaseThread.h>
#include <folly/io/async/test/MockAsyncSSLSocket.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <wangle/acceptor/test/AcceptorHelperMocks.h>

Go to the source code of this file.

Classes
class	EvbHandshakeHelperTest

Functions
	TEST_F (EvbHandshakeHelperTest, TestSuccessPath)
	TEST_F (EvbHandshakeHelperTest, TestFailPath)
	TEST_F (EvbHandshakeHelperTest, TestDropConnection)
	TEST_F (EvbHandshakeHelperTest, TestDropConnectionTricky)

Function Documentation

TEST_F	(	EvbHandshakeHelperTest	,
		TestSuccessPath
	)

Definition at line 80 of file EvbHandshakeHelperTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, FAIL, testing::Invoke(), folly::gen::move, folly::none, folly::Baton< MayBlock, Atom >::post(), s, and folly::Baton< MayBlock, Atom >::try_wait_for().

                                                {
  folly::Baton<> barrier;

  EXPECT_CALL(mockCb_, connectionReadyInternalRaw(_, _, _, _))
      .WillOnce(Invoke([&](auto sock, auto nextProtocol, auto&&, auto&&) {
        EXPECT_EQ(original_.getEventBase(), sock->getEventBase());
        EXPECT_EQ(originalThreadId_, std::this_thread::get_id());
        EXPECT_EQ("h2", nextProtocol);
        sock->destroy();
        barrier.post();
      }));

  EXPECT_CALL(*mockHelper_, startInternal(_, _))
      .WillOnce(Invoke([&](auto sock, auto cb) {
        EXPECT_EQ(alternate_.getEventBase(), sock->getEventBase());
        EXPECT_EQ(alternateThreadId_, std::this_thread::get_id());

        sock->getEventBase()->runInLoop([sock, cb] {
          cb->connectionReady(
              AsyncTransportWrapper::UniquePtr(sock),
              "h2",
              SecureTransportType::TLS,
              folly::none);
        });
      }));

  original_.getEventBase()->runInEventBaseThreadAndWait(
      [=] { evbHelper_->start(std::move(sockPtr_), &mockCb_); });

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout waiting for connectionReady callback to be called";
  }
}

TEST_F	(	EvbHandshakeHelperTest	,
		TestFailPath
	)

Definition at line 114 of file EvbHandshakeHelperTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, FAIL, testing::Invoke(), folly::gen::move, folly::none, folly::Baton< MayBlock, Atom >::post(), s, and folly::Baton< MayBlock, Atom >::try_wait_for().

                                             {
  folly::Baton<> barrier;

  EXPECT_NE(nullptr, sockPtr_->getEventBase());
  EXPECT_CALL(mockCb_, connectionError_(_, _, _))
      .WillOnce(Invoke([&](auto sock, auto&&, auto&&) {
        EXPECT_EQ(sock, nullptr);
        EXPECT_EQ(originalThreadId_, std::this_thread::get_id());
        barrier.post();
      }));

  EXPECT_CALL(*mockHelper_, startInternal(_, _))
      .WillOnce(Invoke([&](auto sock, auto cb) {
        EXPECT_EQ(alternate_.getEventBase(), sock->getEventBase());
        EXPECT_EQ(alternateThreadId_, std::this_thread::get_id());

        sock->getEventBase()->runInLoop([sock, cb, this] {
          folly::DelayedDestruction::DestructorGuard dg(mockHelper_);
          EXPECT_FALSE(mockHelper_->getDestroyPending());
          cb->connectionError(sock, {}, folly::none);
          EXPECT_TRUE(mockHelper_->getDestroyPending());
          EXPECT_EQ(alternate_.getEventBase(), sock->getEventBase());
          sock->destroy();
        });
      }));

  original_.getEventBase()->runInEventBaseThreadAndWait(
      [=] { evbHelper_->start(std::move(sockPtr_), &mockCb_); });

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for connectionError callback to be called";
  }
}

TEST_F	(	EvbHandshakeHelperTest	,
		TestDropConnection
	)

Definition at line 148 of file EvbHandshakeHelperTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, FAIL, testing::Invoke(), folly::gen::move, folly::Baton< MayBlock, Atom >::post(), folly::Baton< MayBlock, Atom >::reset(), s, and folly::Baton< MayBlock, Atom >::try_wait_for().

                                                   {
  folly::Baton<> barrier;

  EXPECT_CALL(*mockHelper_, dropConnection(_)).WillOnce(Invoke([&](auto) {
    EXPECT_EQ(alternateThreadId_, std::this_thread::get_id());
    // Need to wait here else its possible the test destructor may be invoked
    // before the lamda below actually tries to execute.
    alternate_.getEventBase()->runInEventBaseThreadAndWait([=]{
        evbHelper_->connectionError(sslSock_, {}, {});
    });
    barrier.post();
  }));

  AsyncTransportWrapper* transport;
  EXPECT_CALL(mockCb_, connectionError_(_, _, _))
      .WillOnce(SaveArg<0>(&transport));

  EXPECT_CALL(*mockHelper_, startInternal(_, _))
      .WillOnce(Invoke([&](auto sock, auto&&) {
        EXPECT_EQ(alternate_.getEventBase(), sock->getEventBase());
        EXPECT_EQ(alternateThreadId_, std::this_thread::get_id());
        sslSock_ = dynamic_cast<MockAsyncSSLSocket*>(sock);
        sockPtr_.reset(sslSock_);
        barrier.post();
      }));

  original_.getEventBase()->runInEventBaseThreadAndWait(
      [=] { evbHelper_->start(std::move(sockPtr_), &mockCb_); });

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for startInternal to be called";
  }

  barrier.reset();

  original_.getEventBase()->runInEventBaseThreadAndWait(
      [=] { evbHelper_->dropConnection(SSLErrorEnum::DROPPED); });

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for dropConnection to be called";
  }

  EXPECT_EQ(nullptr, transport);
}

TEST_F	(	EvbHandshakeHelperTest	,
		TestDropConnectionTricky
	)

Definition at line 193 of file EvbHandshakeHelperTest.cpp.

References testing::_, testing::AtMost(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, FAIL, testing::Invoke(), folly::gen::move, folly::Baton< MayBlock, Atom >::post(), folly::Baton< MayBlock, Atom >::reset(), s, folly::Baton< MayBlock, Atom >::try_wait_for(), and folly::futures::Barrier::wait().

                                                         {
  folly::Baton<> barrier;
  folly::Baton<> connectionReadyCalled;
  folly::futures::Barrier raceBarrier(3);


  // One of these two methods will be called depending on the race, but
  // not both of them.
  bool called = false;
  EXPECT_CALL(mockCb_, connectionError_(_, _, _))
      .Times(AtMost(1))
      .WillOnce(Invoke([&](auto, auto, auto) {
        EXPECT_FALSE(called);
        called = true;
        barrier.post();
      }));

  EXPECT_CALL(mockCb_, connectionReadyInternalRaw(_, _, _, _))
      .Times(AtMost(1))
      .WillOnce(Invoke([&](auto, auto, auto, auto) {
        EXPECT_FALSE(called);
        called = true;
        barrier.post();
      }));

  EXPECT_CALL(*mockHelper_, startInternal(_, _))
      .WillOnce(Invoke([&](auto sock, auto&&) {
        EXPECT_EQ(alternate_.getEventBase(), sock->getEventBase());
        EXPECT_EQ(alternateThreadId_, std::this_thread::get_id());
        sslSock_ = dynamic_cast<MockAsyncSSLSocket*>(sock);
        sockPtr_.reset(sslSock_);
        barrier.post();
      }));

  original_.getEventBase()->runInEventBaseThreadAndWait(
      [=] { evbHelper_->start(std::move(sockPtr_), &mockCb_); });

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for startInternal to be called";
  }

  barrier.reset();

  // Race the dropConnection() and handshakeSuccess() calls
  original_.getEventBase()->runInEventBaseThread([=, &raceBarrier] {
    raceBarrier.wait().get();
    evbHelper_->dropConnection(SSLErrorEnum::DROPPED);
  });

  alternate_.getEventBase()->runInEventBaseThread(
      [=, &raceBarrier, &connectionReadyCalled]() mutable {
        raceBarrier.wait().get();
        evbHelper_->connectionReady(std::move(sockPtr_), "test", {}, {});
        connectionReadyCalled.post();
      });

  raceBarrier.wait();

  if (!barrier.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for connectionError to be called";
  }

  if (!connectionReadyCalled.try_wait_for(2s)) {
    FAIL() << "Timeout while waiting for connectionReady to call";
  }
}