AcceptRoutingHandlerTest.cpp File Reference

#include "Mocks.h"

Go to the source code of this file.

Classes
class	TestClientPipelineFactory
class	AcceptRoutingHandlerTest

Typedefs
using	TestServer = ServerBootstrap< DefaultPipeline >
using	TestClient = ClientBootstrap< DefaultPipeline >

Functions
	TEST_F (AcceptRoutingHandlerTest, ParseRoutingDataSuccess)
	TEST_F (AcceptRoutingHandlerTest, SocketErrorInRoutingPipeline)
	TEST_F (AcceptRoutingHandlerTest, OnNewConnectionWithBadSocket)
	TEST_F (AcceptRoutingHandlerTest, RoutingPipelineErasedOnlyOnce)

Typedef Documentation

using TestClient = ClientBootstrap<DefaultPipeline>

Definition at line 23 of file AcceptRoutingHandlerTest.cpp.

using TestServer = ServerBootstrap<DefaultPipeline>

Definition at line 22 of file AcceptRoutingHandlerTest.cpp.

Function Documentation

TEST_F	(	AcceptRoutingHandlerTest	,
		ParseRoutingDataSuccess
	)

Definition at line 170 of file AcceptRoutingHandlerTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and fizz::detail::read().

                                                          {
  // Server receives data, and parses routing data
  EXPECT_CALL(*routingDataHandler_, transportActive(_));
  EXPECT_CALL(*routingDataHandler_, parseRoutingData(_, _))
      .WillOnce(
          Invoke([&](folly::IOBufQueue& /*bufQueue*/,
                     MockRoutingDataHandler::RoutingData& /*routingData*/) {
            VLOG(4) << "Parsed routing data";
            return true;
          }));

  // Downstream pipeline is created, and its handler receives events
  boost::barrier barrier(2);
  EXPECT_CALL(*downstreamHandler_, transportActive(_));
  EXPECT_CALL(*downstreamHandler_, read(_, _))
      .WillOnce(Invoke([&](MockBytesToBytesHandler::Context* /*ctx*/,
                           IOBufQueue& /*bufQueue*/) {
        VLOG(4) << "Downstream received a read";
      }));
  EXPECT_CALL(*downstreamHandler_, readEOF(_))
      .WillOnce(Invoke([&](MockBytesToBytesHandler::Context* ctx) {
        VLOG(4) << "Downstream EOF";
        ctx->fireClose();
        barrier.wait();
      }));
  EXPECT_CALL(*downstreamHandler_, transportInactive(_));

  // Send client request that triggers server processing
  clientConnectAndCleanClose();

  barrier.wait();

  // Routing pipeline has been erased
  EXPECT_EQ(0, acceptRoutingHandler_->getRoutingPipelineCount());
}

TEST_F	(	AcceptRoutingHandlerTest	,
		SocketErrorInRoutingPipeline
	)

Definition at line 206 of file AcceptRoutingHandlerTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, wangle::PipelineBase::getTransport(), testing::Invoke(), folly::gen::move, and wangle::Pipeline< R, W >::writeException().

                                                               {
  // Server receives data, and parses routing data
  boost::barrier barrierConnect(2);
  EXPECT_CALL(*routingDataHandler_, transportActive(_));
  EXPECT_CALL(*routingDataHandler_, parseRoutingData(_, _))
      .WillOnce(
          Invoke([&](folly::IOBufQueue& /*bufQueue*/,
                     MockRoutingDataHandler::RoutingData& /*routingData*/) {
            VLOG(4) << "Need more data to be parse.";
            barrierConnect.wait();
            return false;
          }));

  // Send client request that triggers server processing
  auto futureClientPipeline = clientConnectAndWrite();

  // Socket exception after routing pipeline had been created
  barrierConnect.wait();
  boost::barrier barrierException(2);
  std::move(futureClientPipeline).thenValue([](DefaultPipeline* clientPipeline) {
    clientPipeline->getTransport()->getEventBase()->runInEventBaseThread(
        [clientPipeline]() {
          clientPipeline->writeException(
              std::runtime_error("Socket error while expecting routing data."));
        });
  });
  EXPECT_CALL(*routingDataHandler_, readException(_, _))
      .WillOnce(Invoke([&](MockBytesToBytesHandler::Context* /*ctx*/,
                           folly::exception_wrapper ex) {
        VLOG(4) << "Routing data handler Exception";
        acceptRoutingHandler_->onError(kConnId0, ex);
        barrierException.wait();
      }));
  barrierException.wait();

  // Downstream pipeline is not created
  EXPECT_CALL(*downstreamHandler_, transportActive(_)).Times(0);
  delete downstreamHandler_;

  // Routing pipeline has been erased
  EXPECT_EQ(0, acceptRoutingHandler_->getRoutingPipelineCount());
}

TEST_F	(	AcceptRoutingHandlerTest	,
		OnNewConnectionWithBadSocket
	)

Definition at line 249 of file AcceptRoutingHandlerTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, and testing::Invoke().

                                                               {
  // Routing data handler doesn't receive any data
  EXPECT_CALL(*routingDataHandler_, parseRoutingData(_, _)).Times(0);

  // Downstream pipeline is not created
  EXPECT_CALL(*downstreamHandler_, transportActive(_)).Times(0);
  delete downstreamHandler_;

  // Send client request that triggers server processing
  boost::barrier barrierConnect(2);
  EXPECT_CALL(*routingDataHandler_, transportActive(_))
      .WillOnce(Invoke([&](MockBytesToBytesHandler::Context* /*ctx*/) {
        barrierConnect.wait();
      }));
  auto futureClientPipeline = justClientConnect();
  barrierConnect.wait();
  futureClientPipeline.wait();

  // Expect an exception on the routing data handler
  boost::barrier barrierException(2);
  EXPECT_CALL(*routingDataHandler_, readException(_, _))
      .WillOnce(Invoke(
          [&](MockBytesToBytesHandler::Context* /*ctx*/,
              folly::exception_wrapper /*ex*/) { barrierException.wait(); }));
  sendClientException(futureClientPipeline.value());
  barrierException.wait();

  // Routing pipeline has been added
  EXPECT_EQ(1, acceptRoutingHandler_->getRoutingPipelineCount());
}

TEST_F	(	AcceptRoutingHandlerTest	,
		RoutingPipelineErasedOnlyOnce
	)

Definition at line 280 of file AcceptRoutingHandlerTest.cpp.

                                                                {
  // Simulate client socket throwing an exception, while routing data handler
  // parsed data successfully.
  acceptPipeline_->readException(
      std::runtime_error("An exception from the socket."));
  acceptRoutingHandler_->onRoutingData(kConnId0, routingData_);
}