HTTPDownstreamTest< C > Class Template Reference

Inheritance diagram for HTTPDownstreamTest< C >:

Public Member Functions
	HTTPDownstreamTest (std::vector< int64_t > flowControl={-1,-1,-1}, bool startImmediately=true)
HTTPCodec::StreamID	sendRequest (const std::string &url="/", int8_t priority=0, bool eom=true)
HTTPCodec::StreamID	sendRequest (const HTTPMessage &req, bool eom=true)
HTTPCodec::StreamID	sendHeader ()
Promise< Unit >	sendRequestLater (HTTPMessage req, bool eof=false)
void	SetUp () override
void	cleanup ()
std::unique_ptr< testing::StrictMock< MockHTTPHandler > >	addSimpleStrictHandler ()
std::unique_ptr< testing::NiceMock< MockHTTPHandler > >	addSimpleNiceHandler ()
void	onEOMTerminateHandlerExpectShutdown (MockHTTPHandler &handler)
void	expectDetachSession ()
void	addSingleByteReads (const char *data, milliseconds delay={})
void	flushRequestsAndLoop (bool eof=false, milliseconds eofDelay=milliseconds(0), milliseconds initialDelay=milliseconds(0), std::function< void()> extraEventsFn=std::function< void()>())
void	flushRequestsAndLoopN (uint64_t n, bool eof=false, milliseconds eofDelay=milliseconds(0), milliseconds initialDelay=milliseconds(0), std::function< void()> extraEventsFn=std::function< void()>())
void	flushRequests (bool eof=false, milliseconds eofDelay=milliseconds(0), milliseconds initialDelay=milliseconds(0), std::function< void()> extraEventsFn=std::function< void()>())
void	testSimpleUpgrade (const std::string &upgradeHeader, CodecProtocol expectedProtocol, const std::string &expectedUpgradeHeader)
void	gracefulShutdown ()
void	testPriorities (uint32_t numPriorities)
void	testChunks (bool trailers)
void	expect101 (CodecProtocol expectedProtocol, const std::string &expectedUpgrade, bool expect100=false)
void	expectResponse (uint32_t code=200, ErrorCode errorCode=ErrorCode::NO_ERROR, bool expect100=false, bool expectGoaway=false)
void	expectResponses (uint32_t n, uint32_t code=200, ErrorCode errorCode=ErrorCode::NO_ERROR, bool expect100=false, bool expectGoaway=false)
void	parseOutput (HTTPCodec &clientCodec)
void	resumeWritesInLoop ()
void	resumeWritesAfterDelay (milliseconds delay)
MockByteEventTracker *	setMockByteEventTracker ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()

Protected Attributes
EventBase	eventBase_
TestAsyncTransport *	transport_
folly::HHWheelTimer::UniquePtr	transactionTimeouts_
std::vector< int64_t >	flowControl_
StrictMock< MockController >	mockController_
HTTPDownstreamSession *	httpSession_
IOBufQueue	requests_ {IOBufQueue::cacheChainLength()}
unique_ptr< HTTPCodec >	clientCodec_
NiceMock< MockHTTPCodecCallback >	callbacks_
IOBufQueue	parseOutputStream_ {IOBufQueue::cacheChainLength()}
bool	breakParseOutput_ {false}
C::Codec *	rawCodec_ {nullptr}
HeaderIndexingStrategy	testH2IndexingStrat_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()

Detailed Description

template<typename C>
class HTTPDownstreamTest< C >

Definition at line 44 of file HTTPDownstreamSessionTest.cpp.

Constructor & Destructor Documentation

template<typename C>

HTTPDownstreamTest< C >::HTTPDownstreamTest ( std::vector< int64_t >  flowControl = { -1, -1, -1 }, bool  startImmediately = true  )

inlineexplicit

Definition at line 46 of file HTTPDownstreamSessionTest.cpp.

                                     { -1, -1, -1 },
    bool startImmediately = true)
    : eventBase_(),
      transport_(new TestAsyncTransport(&eventBase_)),
      transactionTimeouts_(makeTimeoutSet(&eventBase_)),
      flowControl_(flowControl) {
    EXPECT_CALL(mockController_, getGracefulShutdownTimeout())
      .WillRepeatedly(Return(std::chrono::milliseconds(0)));
    EXPECT_CALL(mockController_, attachSession(_))
      .WillRepeatedly(Invoke([&] (HTTPSessionBase* session) {
        session->setPrioritySampled(true);
      }));
    HTTPSession::setDefaultReadBufferLimit(65536);
    auto codec = makeServerCodec<typename C::Codec>(C::version);
    rawCodec_ = codec.get();

    // If the codec is H2, getHeaderIndexingStrategy will be called when setting
    // up the codec
    if (rawCodec_->getProtocol() == CodecProtocol::HTTP_2) {
      EXPECT_CALL(mockController_, getHeaderIndexingStrategy())
        .WillOnce(
          Return(&testH2IndexingStrat_)
      );
    }

    httpSession_ = new HTTPDownstreamSession(
      transactionTimeouts_.get(),
      std::move(AsyncTransportWrapper::UniquePtr(transport_)),
      localAddr, peerAddr,
      &mockController_,
      std::move(codec),
      mockTransportInfo /* no stats for now */,
      nullptr);
    for (auto& param: flowControl) {
      if (param < 0) {
        param = rawCodec_->getDefaultWindowSize();
      }
    }

    // Ensure the H2 header indexing strategy was setup correctly if applicable
    if (rawCodec_->getProtocol() == CodecProtocol::HTTP_2) {
      HTTP2Codec* recastedCodec = dynamic_cast<HTTP2Codec*>(rawCodec_);
      EXPECT_EQ(
        recastedCodec->getHeaderIndexingStrategy(), &testH2IndexingStrat_);
    }

    httpSession_->setFlowControl(flowControl[0], flowControl[1],
                                 flowControl[2]);
    httpSession_->setEgressSettings({{ SettingsId::MAX_CONCURRENT_STREAMS, 80 },
                                     { SettingsId::HEADER_TABLE_SIZE, 5555 },
                                     { SettingsId::ENABLE_PUSH, 1 },
                                     { SettingsId::ENABLE_EX_HEADERS, 1 }});
    if (startImmediately) {
      httpSession_->startNow();
    }
    clientCodec_ = makeClientCodec<typename C::Codec>(C::version);
    if (clientCodec_->getProtocol() == CodecProtocol::HTTP_2) {
      clientCodec_->getEgressSettings()->setSetting(
        SettingsId::ENABLE_EX_HEADERS, 1);
    }
    clientCodec_->generateConnectionPreface(requests_);
    clientCodec_->setCallback(&callbacks_);
  }

Member Function Documentation

template<typename C>

std::unique_ptr<testing::NiceMock<MockHTTPHandler> > HTTPDownstreamTest< C >::addSimpleNiceHandler ( )

inline

Definition at line 173 of file HTTPDownstreamSessionTest.cpp.

                         {
    std::unique_ptr<testing::NiceMock<MockHTTPHandler>> handler =
      std::make_unique<testing::NiceMock<MockHTTPHandler>>();

    // See comment above
    auto rawHandler = handler.get();
    EXPECT_CALL(mockController_, getRequestHandler(testing::_, testing::_))
      .WillOnce(testing::Return(rawHandler))
      .RetiresOnSaturation();

    EXPECT_CALL(*handler, setTransaction(testing::_))
      .WillOnce(testing::SaveArg<0>(&handler->txn_));

    return handler;
  }

template<typename C>

std::unique_ptr<testing::StrictMock<MockHTTPHandler> > HTTPDownstreamTest< C >::addSimpleStrictHandler ( )

inline

Definition at line 155 of file HTTPDownstreamSessionTest.cpp.

                           {
    std::unique_ptr<testing::StrictMock<MockHTTPHandler>> handler =
      std::make_unique<testing::StrictMock<MockHTTPHandler>>();

    // The ownership model here is suspect, but assume the callers won't destroy
    // handler before it's requested
    auto rawHandler = handler.get();
    EXPECT_CALL(mockController_, getRequestHandler(testing::_, testing::_))
      .WillOnce(testing::Return(rawHandler))
      .RetiresOnSaturation();

    EXPECT_CALL(*handler, setTransaction(testing::_))
      .WillOnce(testing::SaveArg<0>(&handler->txn_));

    return handler;
  }

template<typename C>

void HTTPDownstreamTest< C >::addSingleByteReads ( const char *  data, milliseconds  delay = {}  )

inline

Definition at line 199 of file HTTPDownstreamSessionTest.cpp.

                                                               {}) {
    for (const char* p = data; *p != '\0'; ++p) {
      transport_->addReadEvent(p, 1, delay);
    }
  }

template<typename C>

void HTTPDownstreamTest< C >::cleanup ( )

inline

Definition at line 148 of file HTTPDownstreamSessionTest.cpp.

                 {
    EXPECT_CALL(mockController_, detachSession(_));
    httpSession_->dropConnection();
  }

template<typename C>

void HTTPDownstreamTest< C >::expect101 ( CodecProtocol  expectedProtocol, const std::string &  expectedUpgrade, bool  expect100 = false  )

inline

Definition at line 253 of file HTTPDownstreamSessionTest.cpp.

                                         {
    NiceMock<MockHTTPCodecCallback> callbacks;

    EXPECT_CALL(callbacks, onMessageBegin(_, _));
    EXPECT_CALL(callbacks, onNativeProtocolUpgrade(_, _, _, _))
      .WillOnce(
        Invoke([this, expectedUpgrade] (HTTPCodec::StreamID,
                                        CodecProtocol,
                                        const std::string&,
                                        HTTPMessage& msg) {
             EXPECT_EQ(msg.getStatusCode(), 101);
             EXPECT_EQ(msg.getStatusMessage(), "Switching Protocols");
             EXPECT_EQ(msg.getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE),
                       expectedUpgrade);
             // also connection and date
             EXPECT_EQ(msg.getHeaders().size(), 3);
             breakParseOutput_ = true;
             return true;
               }));
    // this comes before 101, but due to gmock this is backwards
    if (expect100) {
      EXPECT_CALL(callbacks, onMessageBegin(_, _))
        .RetiresOnSaturation();
      EXPECT_CALL(callbacks, onHeadersComplete(_, _))
        .WillOnce(Invoke([] (HTTPCodec::StreamID,
                             std::shared_ptr<HTTPMessage> msg) {
                 LOG(INFO) << "100 headers";
                 EXPECT_EQ(msg->getStatusCode(), 100);
                         }))
        .RetiresOnSaturation();
      EXPECT_CALL(callbacks, onMessageComplete(_, _))
        .RetiresOnSaturation();
    }
    clientCodec_->setCallback(&callbacks);
    parseOutput(*clientCodec_);
    clientCodec_ = HTTPCodecFactory::getCodec(expectedProtocol,
                                              TransportDirection::UPSTREAM);
  }

template<typename C>

void HTTPDownstreamTest< C >::expectDetachSession ( )

inline

Definition at line 195 of file HTTPDownstreamSessionTest.cpp.

                             {
    EXPECT_CALL(mockController_, detachSession(testing::_));
  }

template<typename C>

void HTTPDownstreamTest< C >::expectResponse ( uint32_t  code = 200, ErrorCode  errorCode = ErrorCode::NO_ERROR, bool  expect100 = false, bool  expectGoaway = false  )

inline

Definition at line 293 of file HTTPDownstreamSessionTest.cpp.

                                                                         {
    expectResponses(1, code, errorCode, expect100, expectGoaway);
  }

template<typename C>

void HTTPDownstreamTest< C >::expectResponses ( uint32_t  n, uint32_t  code = 200, ErrorCode  errorCode = ErrorCode::NO_ERROR, bool  expect100 = false, bool  expectGoaway = false  )

inline

Definition at line 298 of file HTTPDownstreamSessionTest.cpp.

                                                                          {
    clientCodec_->setCallback(&callbacks_);
    if (isParallelCodecProtocol(clientCodec_->getProtocol())) {
      EXPECT_CALL(callbacks_, onSettings(_))
        .WillOnce(Invoke([this] (const SettingsList& settings) {
              if (flowControl_[0] > 0) {
                bool foundInitialWindow = false;
                for (const auto& setting: settings) {
                  if (setting.id == SettingsId::INITIAL_WINDOW_SIZE) {
                    EXPECT_EQ(flowControl_[0], setting.value);
                    foundInitialWindow = true;
                  }
                }
                EXPECT_TRUE(foundInitialWindow);
              }
            }));
    }
    if (flowControl_[2] > 0) {
      int64_t sessionDelta =
        flowControl_[2] - clientCodec_->getDefaultWindowSize();
      if (clientCodec_->supportsSessionFlowControl() && sessionDelta) {
        EXPECT_CALL(callbacks_, onWindowUpdate(0, sessionDelta));
      }
    }
    if (flowControl_[1] > 0) {
      size_t initWindow = flowControl_[0] > 0 ?
        flowControl_[0] : clientCodec_->getDefaultWindowSize();
      int64_t streamDelta = flowControl_[1] - initWindow;
      if (clientCodec_->supportsStreamFlowControl() && streamDelta) {
        EXPECT_CALL(callbacks_, onWindowUpdate(1, streamDelta));
      }
    }

    if (expectGoaway) {
      EXPECT_CALL(callbacks_, onGoaway(HTTPCodec::StreamID(1),
                                      ErrorCode::NO_ERROR, _));
    }

    for (uint32_t i = 0; i < n; i++) {
      uint8_t times = (expect100) ? 2 : 1;
      EXPECT_CALL(callbacks_, onMessageBegin(_, _))
        .Times(times).RetiresOnSaturation();
      EXPECT_CALL(callbacks_, onHeadersComplete(_, _))
        .WillOnce(Invoke([code] (HTTPCodec::StreamID,
                                 std::shared_ptr<HTTPMessage> msg) {
                           EXPECT_EQ(msg->getStatusCode(), code);
                         }));
      if (expect100) {
        EXPECT_CALL(callbacks_, onHeadersComplete(_, _))
          .WillOnce(Invoke([] (HTTPCodec::StreamID,
                               std::shared_ptr<HTTPMessage> msg) {
                             EXPECT_EQ(msg->getStatusCode(), 100);
                           }))
          .RetiresOnSaturation();
      }
      if (errorCode != ErrorCode::NO_ERROR) {
        EXPECT_CALL(callbacks_, onAbort(_, _))
          .WillOnce(Invoke([errorCode] (HTTPCodec::StreamID,
                                        ErrorCode error) {
                             EXPECT_EQ(error, errorCode);
                         }));
      }
      EXPECT_CALL(callbacks_, onBody(_, _, _)).RetiresOnSaturation();
      EXPECT_CALL(callbacks_, onMessageComplete(_, _)).RetiresOnSaturation();
    }
    parseOutput(*clientCodec_);
  }

template<typename C>

void HTTPDownstreamTest< C >::flushRequests ( bool  eof = false, milliseconds  eofDelay = milliseconds(0), milliseconds  initialDelay = milliseconds(0), std::function< void()>  extraEventsFn = std::function<void()>()  )

inline

Definition at line 223 of file HTTPDownstreamSessionTest.cpp.

                                                               {
    transport_->addReadEvent(requests_, initialDelay);
    if (extraEventsFn) {
      extraEventsFn();
    }
    if (eof) {
      transport_->addReadEOF(eofDelay);
    }
    transport_->startReadEvents();
  }

template<typename C>

void HTTPDownstreamTest< C >::flushRequestsAndLoop ( bool  eof = false, milliseconds  eofDelay = milliseconds(0), milliseconds  initialDelay = milliseconds(0), std::function< void()>  extraEventsFn = std::function<void()>()  )

inline

Definition at line 205 of file HTTPDownstreamSessionTest.cpp.

                                                               {
    flushRequests(eof, eofDelay, initialDelay, extraEventsFn);
    eventBase_.loop();
  }

template<typename C>

void HTTPDownstreamTest< C >::flushRequestsAndLoopN ( uint64_t  n, bool  eof = false, milliseconds  eofDelay = milliseconds(0), milliseconds  initialDelay = milliseconds(0), std::function< void()>  extraEventsFn = std::function<void()>()  )

inline

Definition at line 213 of file HTTPDownstreamSessionTest.cpp.

                                                               {
    flushRequests(eof, eofDelay, initialDelay, extraEventsFn);
    for (uint64_t i = 0; i < n; i++) {
      eventBase_.loopOnce();
    }
  }

template<typename C>

void HTTPDownstreamTest< C >::gracefulShutdown ( )

inline

Definition at line 242 of file HTTPDownstreamSessionTest.cpp.

                          {
    folly::DelayedDestruction::DestructorGuard g(httpSession_);
    clientCodec_->generateGoaway(this->requests_, 0, ErrorCode::NO_ERROR);
    expectDetachSession();
    flushRequestsAndLoop(true);
  }

template<typename C>

void HTTPDownstreamTest< C >::onEOMTerminateHandlerExpectShutdown ( MockHTTPHandler &  handler )

inline

Definition at line 189 of file HTTPDownstreamSessionTest.cpp.

                                                                     {
    handler.expectEOM([&] { handler.terminate(); });
    handler.expectDetachTransaction();
    expectDetachSession();
  }

template<typename C>

void HTTPDownstreamTest< C >::parseOutput ( HTTPCodec &  clientCodec )

inline

Definition at line 368 of file HTTPDownstreamSessionTest.cpp.

                                           {
    auto writeEvents = transport_->getWriteEvents();
    while (!breakParseOutput_ &&
           (!writeEvents->empty() || !parseOutputStream_.empty())) {
      if (!writeEvents->empty()) {
        auto event = writeEvents->front();
        auto vec = event->getIoVec();
        for (size_t i = 0; i < event->getCount(); i++) {
          parseOutputStream_.append(
            IOBuf::copyBuffer(vec[i].iov_base, vec[i].iov_len));
        }
        writeEvents->pop_front();
      }
      uint32_t consumed = clientCodec.onIngress(*parseOutputStream_.front());
      parseOutputStream_.split(consumed);
    }
    if (!breakParseOutput_) {
      EXPECT_EQ(parseOutputStream_.chainLength(), 0);
    }
    breakParseOutput_ = false;
  }

template<typename C>

void HTTPDownstreamTest< C >::resumeWritesAfterDelay ( milliseconds  delay )

inline

Definition at line 394 of file HTTPDownstreamSessionTest.cpp.

                                                  {
    eventBase_.runAfterDelay([this] { transport_->resumeWrites(); },
                             delay.count());
  }

template<typename C>

void HTTPDownstreamTest< C >::resumeWritesInLoop ( )

inline

Definition at line 390 of file HTTPDownstreamSessionTest.cpp.

                            {
    eventBase_.runInLoop([this] { transport_->resumeWrites(); });
  }

template<typename C>

HTTPCodec::StreamID HTTPDownstreamTest< C >::sendHeader ( )

inline

Definition at line 126 of file HTTPDownstreamSessionTest.cpp.

                                 {
    return sendRequest("/", 0, false);
  }

template<typename C>

HTTPCodec::StreamID HTTPDownstreamTest< C >::sendRequest ( const std::string &  url = "/", int8_t  priority = 0, bool  eom = true  )

inline

Definition at line 111 of file HTTPDownstreamSessionTest.cpp.

                                                   {
    auto req = getGetRequest();
    req.setURL(url);
    req.setPriority(priority);
    return sendRequest(req, eom);
  }

template<typename C>

HTTPCodec::StreamID HTTPDownstreamTest< C >::sendRequest ( const HTTPMessage &  req, bool  eom = true  )

inline

Definition at line 120 of file HTTPDownstreamSessionTest.cpp.

                                                                         {
    auto streamID = clientCodec_->createStream();
    clientCodec_->generateHeader(requests_, streamID, req, eom);
    return streamID;
  }

template<typename C>

Promise<Unit> HTTPDownstreamTest< C >::sendRequestLater ( HTTPMessage  req, bool  eof = false  )

inline

Definition at line 130 of file HTTPDownstreamSessionTest.cpp.

                                                                  {
    Promise<Unit> reqp;
    reqp.getFuture().then(&eventBase_, [=] {
        sendRequest(req);
        transport_->addReadEvent(requests_, milliseconds(0));
        if (eof) {
          transport_->addReadEOF(milliseconds(0));
        }
      });
    return reqp;
  }

template<typename C>

MockByteEventTracker* HTTPDownstreamTest< C >::setMockByteEventTracker ( )

inline

Definition at line 399 of file HTTPDownstreamSessionTest.cpp.

                                                  {
    auto byteEventTracker = new MockByteEventTracker(nullptr);
    httpSession_->setByteEventTracker(
      std::unique_ptr<ByteEventTracker>(byteEventTracker));
    EXPECT_CALL(*byteEventTracker, preSend(_, _, _))
      .WillRepeatedly(Return(0));
    EXPECT_CALL(*byteEventTracker, drainByteEvents())
      .WillRepeatedly(Return(0));
    EXPECT_CALL(*byteEventTracker, processByteEvents(_, _))
      .WillRepeatedly(Invoke([]
                             (std::shared_ptr<ByteEventTracker> self,
                              uint64_t bytesWritten) {
                               return self->ByteEventTracker::processByteEvents(
                                 self,
                                 bytesWritten);
                             }));

    return byteEventTracker;
  }

template<typename C>

void HTTPDownstreamTest< C >::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 142 of file HTTPDownstreamSessionTest.cpp.

                        {
    folly::EventBaseManager::get()->clearEventBase();
    HTTPSession::setDefaultWriteBufferLimit(65536);
    HTTP2PriorityQueue::setNodeLifetime(std::chrono::milliseconds(2));
  }

template<class C >

void HTTPDownstreamTest< C >::testChunks

(

bool

trailers

)

Definition at line 1365 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, g(), handler(), and i.

                                                    {
  InSequence enforceOrder;

  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectEOM([&handler, trailers] () {
      handler->sendChunkedReplyWithBody(200, 100, 17, trailers);
    });
  handler->expectDetachTransaction();

  HTTPSession::DestructorGuard g(httpSession_);
  sendRequest();
  flushRequestsAndLoop(true, milliseconds(0));

  EXPECT_CALL(callbacks_, onMessageBegin(1, _))
    .Times(1);
  EXPECT_CALL(callbacks_, onHeadersComplete(1, _))
    .Times(1);
  for (int i = 0; i < 6; i++) {
    EXPECT_CALL(callbacks_, onChunkHeader(1, _));
    EXPECT_CALL(callbacks_, onBody(1, _, _));
    EXPECT_CALL(callbacks_, onChunkComplete(1));
  }
  if (trailers) {
    EXPECT_CALL(callbacks_, onTrailersComplete(1, _));
  }
  EXPECT_CALL(callbacks_, onMessageComplete(1, _));

  parseOutput(*clientCodec_);
  expectDetachSession();
}

template<class C >

void HTTPDownstreamTest< C >::testPriorities

(

uint32_t

numPriorities

)

Definition at line 2170 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_GE, EXPECT_LE, handler(), i, testing::Invoke(), folly::gen::move, and uint32_t.

                                                                 {
  uint32_t iterations = 10;
  uint32_t maxPriority = numPriorities - 1;
  std::vector<std::unique_ptr<testing::NiceMock<MockHTTPHandler>>> handlers;
  for (int pri = numPriorities - 1; pri >= 0; pri--) {
    for (uint32_t i = 0; i < iterations; i++) {
      sendRequest("/", pri * (8 / numPriorities));
      InSequence handlerSequence;
      auto handler = addSimpleNiceHandler();
      auto rawHandler = handler.get();
      handlers.push_back(std::move(handler));
      rawHandler->expectHeaders();
      rawHandler->expectEOM([rawHandler] {
          rawHandler->sendReplyWithBody(200, 1000);
        });
      rawHandler->expectDetachTransaction([] {  });
    }
  }

  auto buf = requests_.move();
  buf->coalesce();
  requests_.append(std::move(buf));

  flushRequestsAndLoop();

  std::list<HTTPCodec::StreamID> streams;
  EXPECT_CALL(callbacks_, onMessageBegin(_, _))
    .Times(iterations * numPriorities);
  EXPECT_CALL(callbacks_, onHeadersComplete(_, _))
    .Times(iterations * numPriorities);
  // body is variable and hence ignored
  EXPECT_CALL(callbacks_, onMessageComplete(_, _))
      .Times(iterations * numPriorities)
      .WillRepeatedly(Invoke([&](HTTPCodec::StreamID stream, bool /*upgrade*/) {
        streams.push_back(stream);
      }));

  parseOutput(*clientCodec_);

  // transactions finish in priority order (higher streamIDs first)
  EXPECT_EQ(streams.size(), iterations * numPriorities);
  auto txn = streams.begin();
  for (int band = maxPriority; band >= 0; band--) {
    auto upperID = iterations * 2 * (band + 1);
    auto lowerID = iterations * 2 * band;
    for (uint32_t i = 0; i < iterations; i++) {
      EXPECT_LE(lowerID, (uint32_t)*txn);
      EXPECT_GE(upperID, (uint32_t)*txn);
      ++txn;
    }
  }
}

template<class C >

void HTTPDownstreamTest< C >::testSimpleUpgrade	(	const std::string &	upgradeHeader,
		CodecProtocol	expectedProtocol,
		const std::string &	expectedUpgradeHeader
	)

Definition at line 1864 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_NE, codec, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, proxygen::HTTP2Codec::getHeaderIndexingStrategy(), proxygen::getUpgradeRequest(), handler(), proxygen::http2::kProtocolCleartextString, and testing::Return().

                                          {
  this->rawCodec_->setAllowedUpgradeProtocols({expectedUpgradeHeader});

  auto handler = addSimpleStrictHandler();

  HeaderIndexingStrategy testH2IndexingStrat;
  handler->expectHeaders();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM(
    [&handler, expectedProtocol, expectedUpgradeHeader, &testH2IndexingStrat] {
      EXPECT_FALSE(handler->txn_->getSetupTransportInfo().secure);
      EXPECT_EQ(*handler->txn_->getSetupTransportInfo().appProtocol,
                expectedUpgradeHeader);
      if (expectedProtocol == CodecProtocol::HTTP_2) {
        const HTTP2Codec* codec = dynamic_cast<const HTTP2Codec*>(
          &handler->txn_->getTransport().getCodec());
        ASSERT_NE(codec, nullptr);
        EXPECT_EQ(codec->getHeaderIndexingStrategy(), &testH2IndexingStrat);
      }
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectDetachTransaction();

  if (expectedProtocol == CodecProtocol::HTTP_2) {
    EXPECT_CALL(mockController_, getHeaderIndexingStrategy())
      .WillOnce(
        Return(&testH2IndexingStrat)
    );
  }

  HTTPMessage req = getUpgradeRequest(upgradeHeader);
  if (upgradeHeader == http2::kProtocolCleartextString) {
    HTTP2Codec::requestUpgrade(req);
  }
  sendRequest(req);
  flushRequestsAndLoop();

  expect101(expectedProtocol, expectedUpgradeHeader);
  expectResponse();

  gracefulShutdown();
}

Member Data Documentation

template<typename C>

bool HTTPDownstreamTest< C >::breakParseOutput_ {false}

protected

Definition at line 430 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

NiceMock<MockHTTPCodecCallback> HTTPDownstreamTest< C >::callbacks_

protected

Definition at line 428 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

unique_ptr<HTTPCodec> HTTPDownstreamTest< C >::clientCodec_

protected

Definition at line 427 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

EventBase HTTPDownstreamTest< C >::eventBase_

protected

Definition at line 420 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

std::vector<int64_t> HTTPDownstreamTest< C >::flowControl_

protected

Definition at line 423 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

HTTPDownstreamSession* HTTPDownstreamTest< C >::httpSession_

protected

Definition at line 425 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

StrictMock<MockController> HTTPDownstreamTest< C >::mockController_

protected

Definition at line 424 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

IOBufQueue HTTPDownstreamTest< C >::parseOutputStream_ {IOBufQueue::cacheChainLength()}

protected

Definition at line 429 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

C::Codec* HTTPDownstreamTest< C >::rawCodec_ {nullptr}

protected

Definition at line 431 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

IOBufQueue HTTPDownstreamTest< C >::requests_ {IOBufQueue::cacheChainLength()}

protected

Definition at line 426 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

HeaderIndexingStrategy HTTPDownstreamTest< C >::testH2IndexingStrat_

protected

Definition at line 432 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

folly::HHWheelTimer::UniquePtr HTTPDownstreamTest< C >::transactionTimeouts_

protected

Definition at line 422 of file HTTPDownstreamSessionTest.cpp.

template<typename C>

TestAsyncTransport* HTTPDownstreamTest< C >::transport_

protected

Definition at line 421 of file HTTPDownstreamSessionTest.cpp.

---

The documentation for this class was generated from the following file:

• proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp