HTTPUpstreamSessionTest.cpp File Reference

#include <folly/io/Cursor.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/TimeoutManager.h>
#include <wangle/acceptor/ConnectionManager.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
#include <proxygen/lib/http/codec/HTTPCodecFactory.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <proxygen/lib/http/session/HTTPUpstreamSession.h>
#include <proxygen/lib/http/session/test/MockByteEventTracker.h>
#include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
#include <proxygen/lib/http/session/test/HTTPSessionTest.h>
#include <proxygen/lib/http/session/test/TestUtils.h>
#include <proxygen/lib/test/TestAsyncTransport.h>
#include <string>
#include <folly/io/async/test/MockAsyncTransport.h>
#include <vector>

Go to the source code of this file.

Classes
class	TestPriorityMapBuilder
class	TestPriorityAdapter
class	HTTPUpstreamTest< C >
class	TimeoutableHTTPUpstreamTest< C >
class	HTTP2UpstreamSessionWithVirtualNodesTest
class	HTTP2UpstreamSessionWithPriorityTree
class	HTTPUpstreamRecvStreamTest
class	NoFlushUpstreamSessionTest
class	MockHTTPUpstreamTest
class	MockHTTP2UpstreamTest
class	TestAbortPost< stage >

Typedefs
using	HTTPUpstreamSessionTest = HTTPUpstreamTest< HTTP1xCodecPair >
using	SPDY3UpstreamSessionTest = HTTPUpstreamTest< SPDY3CodecPair >
using	HTTP2UpstreamSessionTest = HTTPUpstreamTest< HTTP2CodecPair >
using	HTTPUpstreamTimeoutTest = TimeoutableHTTPUpstreamTest< HTTP1xCodecPair >
typedef TestAbortPost< 0 >	TestAbortPost0
typedef TestAbortPost< 1 >	TestAbortPost1
typedef TestAbortPost< 2 >	TestAbortPost2
typedef TestAbortPost< 3 >	TestAbortPost3
typedef TestAbortPost< 4 >	TestAbortPost4
typedef TestAbortPost< 5 >	TestAbortPost5
using	AllTypes = ::testing::Types< HTTP1xCodecPair, SPDY3CodecPair >

Functions
	TYPED_TEST_CASE_P (HTTPUpstreamTest)
	TEST_F (SPDY3UpstreamSessionTest, ServerPush)
	TEST_F (SPDY3UpstreamSessionTest, IngressGoawayAbortUncreatedStreams)
	TEST_F (SPDY3UpstreamSessionTest, IngressGoawaySessionError)
	TEST_F (SPDY3UpstreamSessionTest, TestUnderLimitOnWriteError)
	TEST_F (SPDY3UpstreamSessionTest, TestOverlimitResume)
	TEST_F (HTTP2UpstreamSessionTest, TestPriority)
	TEST_F (HTTP2UpstreamSessionTest, TestSettingsAck)
	TEST_F (HTTP2UpstreamSessionTest, TestSettingsInfoCallbacks)
	TEST_F (HTTP2UpstreamSessionTest, TestSetControllerInitHeaderIndexingStrat)
	TEST_F (HTTP2UpstreamSessionTest, ExheaderFromServer)
	TEST_F (HTTP2UpstreamSessionTest, InvalidControlStream)
	TEST_F (HTTP2UpstreamSessionWithVirtualNodesTest, VirtualNodes)
	TEST_F (HTTP2UpstreamSessionWithPriorityTree, PriorityTree)
	TYPED_TEST_P (HTTPUpstreamTest, ImmediateEof)
	TEST_F (HTTPUpstreamSessionTest, BasicRequest)
	TEST_F (HTTPUpstreamSessionTest, TwoRequests)
	TEST_F (HTTPUpstreamSessionTest, 10Requests)
	TEST_F (HTTPUpstreamSessionTest, TestFirstHeaderByteEventTracker)
	TEST_F (HTTPUpstreamSessionTest, Http10Keepalive)
	TEST_F (HTTPUpstreamSessionTest, BasicTrailers)
	TEST_F (HTTP2UpstreamSessionTest, BasicTrailers)
	TEST_F (HTTP2UpstreamSessionTest, HeadersThenBodyThenHeaders)
	TEST_F (HTTPUpstreamSessionTest, TwoRequestsWithPause)
	TEST_F (HTTPUpstreamTimeoutTest, WriteTimeoutAfterResponse)
	TEST_F (HTTPUpstreamSessionTest, SetTransactionTimeout)
	TEST_F (HTTPUpstreamSessionTest, ReadTimeout)
	TEST_F (HTTPUpstreamSessionTest, 100ContinueKeepalive)
	TEST_F (HTTPUpstreamSessionTest, 417Keepalive)
	TEST_F (HTTPUpstreamSessionTest, 101Upgrade)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradeNativeH2)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradeNativeUnknown)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradeNativeWhitespace)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradeNativeJunk)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgrade101Unexpected)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgrade101MissingUpgrade)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgrade101BogusHeader)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradePost100)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradePost100Http2)
	TEST_F (HTTPUpstreamSessionTest, HttpUpgradeOnTxn2)
	TEST_F (HTTPUpstreamRecvStreamTest, UpgradeFlowControl)
	TEST_F (NoFlushUpstreamSessionTest, SessionPausedStartPaused)
	TEST_F (NoFlushUpstreamSessionTest, DeleteTxnOnUnpause)
	TEST_F (HTTP2UpstreamSessionTest, ServerPush)
	TEST_F (MockHTTP2UpstreamTest, ParseErrorNoTxn)
	TEST_F (MockHTTPUpstreamTest, 0MaxOutgoingTxns)
	TEST_F (MockHTTPUpstreamTest, OutgoingTxnSettings)
	TEST_F (MockHTTPUpstreamTest, IngressGoawayDrain)
	TEST_F (MockHTTPUpstreamTest, Goaway)
	TEST_F (MockHTTPUpstreamTest, GoawayPreHeaders)
	TEST_F (MockHTTPUpstreamTest, NoWindowUpdateOnDrain)
	TEST_F (MockHTTPUpstreamTest, GetWithBody)
	TEST_F (MockHTTPUpstreamTest, HeaderWithEom)
	TEST_F (TestAbortPost1, Test)
	TEST_F (TestAbortPost2, Test)
	TEST_F (TestAbortPost3, Test)
	TEST_F (TestAbortPost4, Test)
	TEST_F (TestAbortPost5, Test)
	TEST_F (MockHTTPUpstreamTest, AbortUpgrade)
	TEST_F (MockHTTPUpstreamTest, DrainBeforeSendHeaders)
	TEST_F (MockHTTP2UpstreamTest, ReceiveDoubleGoaway)
	TEST_F (MockHTTP2UpstreamTest, ServerPushInvalidAssoc)
	TEST_F (MockHTTP2UpstreamTest, ServerPushAfterFin)
	TEST_F (MockHTTP2UpstreamTest, ServerPushHandlerInstallFail)
	TEST_F (MockHTTP2UpstreamTest, ServerPushUnhandledAssoc)
	TEST_F (MockHTTPUpstreamTest, HeadersThenBodyThenHeaders)
	TEST_F (MockHTTP2UpstreamTest, DelayUpstreamWindowUpdate)
	TEST_F (MockHTTPUpstreamTest, ForceShutdownInSetTransaction)
	TEST_F (HTTP2UpstreamSessionTest, TestReplaySafetyCallback)
	TEST_F (HTTP2UpstreamSessionTest, TestAlreadyReplaySafe)
	TEST_F (HTTP2UpstreamSessionTest, TestChainedBufIngress)
	TEST_F (HTTP2UpstreamSessionTest, AttachDetach)
	REGISTER_TYPED_TEST_CASE_P (HTTPUpstreamTest, ImmediateEof)
	INSTANTIATE_TYPED_TEST_CASE_P (AllTypesPrefix, HTTPUpstreamTest, AllTypes)

Typedef Documentation

using AllTypes = ::testing::Types<HTTP1xCodecPair, SPDY3CodecPair>

Definition at line 2696 of file HTTPUpstreamSessionTest.cpp.

using HTTP2UpstreamSessionTest = HTTPUpstreamTest<HTTP2CodecPair>

Definition at line 405 of file HTTPUpstreamSessionTest.cpp.

using HTTPUpstreamSessionTest = HTTPUpstreamTest<HTTP1xCodecPair>

Definition at line 403 of file HTTPUpstreamSessionTest.cpp.

using HTTPUpstreamTimeoutTest = TimeoutableHTTPUpstreamTest<HTTP1xCodecPair>

Definition at line 1269 of file HTTPUpstreamSessionTest.cpp.

using SPDY3UpstreamSessionTest = HTTPUpstreamTest<SPDY3CodecPair>

Definition at line 404 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<0> TestAbortPost0

Definition at line 2258 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<1> TestAbortPost1

Definition at line 2259 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<2> TestAbortPost2

Definition at line 2260 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<3> TestAbortPost3

Definition at line 2261 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<4> TestAbortPost4

Definition at line 2262 of file HTTPUpstreamSessionTest.cpp.

typedef TestAbortPost<5> TestAbortPost5

Definition at line 2263 of file HTTPUpstreamSessionTest.cpp.

Function Documentation

INSTANTIATE_TYPED_TEST_CASE_P	(	AllTypesPrefix	,
		HTTPUpstreamTest	,
		AllTypes
	)

REGISTER_TYPED_TEST_CASE_P	(	HTTPUpstreamTest	,
		ImmediateEof
	)

Referenced by TEST_F().

TEST_F	(	SPDY3UpstreamSessionTest	,
		ServerPush
	)

Definition at line 407 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::SPDYCodec::generateBody(), proxygen::SPDYCodec::generateHeader(), proxygen::SPDYCodec::generatePushPromise(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_HOST, testing::Invoke(), folly::IOBuf::length(), makeBuf(), folly::IOBufQueue::move(), folly::gen::move, gmock_output_test::output, proxygen::HTTPHeaders::set(), proxygen::HTTPTransaction::setHandler(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), and proxygen::HTTPMessage::setURL().

                                             {
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());

  HTTPMessage push;
  push.getHeaders().set("HOST", "www.foo.com");
  push.setURL("https://www.foo.com/");
  egressCodec.generatePushPromise(output, 2, push, 1, false, nullptr);
  auto buf = makeBuf(100);
  egressCodec.generateBody(output, 2, std::move(buf), HTTPCodec::NoPadding,
                           true /* eom */);

  HTTPMessage resp;
  resp.setStatusCode(200);
  resp.setStatusMessage("Ohai");
  egressCodec.generateHeader(output, 1, resp, false, nullptr);
  buf = makeBuf(100);
  egressCodec.generateBody(output, 1, std::move(buf), HTTPCodec::NoPadding,
                           true /* eom */);

  std::unique_ptr<folly::IOBuf> input = output.move();
  input->coalesce();

  MockHTTPHandler pushHandler;

  InSequence enforceOrder;

  auto handler = openTransaction();
  EXPECT_CALL(*handler, onPushedTransaction(_))
    .WillOnce(Invoke([&pushHandler] (HTTPTransaction* pushTxn) {
          pushTxn->setHandler(&pushHandler);
        }));
  EXPECT_CALL(pushHandler, setTransaction(_));
  EXPECT_CALL(pushHandler, onHeadersComplete(_))
    .WillOnce(Invoke([&] (std::shared_ptr<HTTPMessage> msg) {
          EXPECT_EQ(httpSession_->getNumIncomingStreams(), 1);
          EXPECT_TRUE(msg->getIsChunked());
          EXPECT_FALSE(msg->getIsUpgraded());
          EXPECT_EQ(msg->getPath(), "/");
          EXPECT_EQ(msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST),
                    "www.foo.com");
        }));
  EXPECT_CALL(pushHandler, onBody(_));
  EXPECT_CALL(pushHandler, onEOM());
  EXPECT_CALL(pushHandler, detachTransaction());

  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  EXPECT_CALL(*handler, onBody(_));
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop(input->data(), input->length());

  EXPECT_EQ(httpSession_->getNumIncomingStreams(), 0);
  httpSession_->destroy();
}

TEST_F	(	SPDY3UpstreamSessionTest	,
		IngressGoawayAbortUncreatedStreams
	)

Definition at line 469 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_EQ, folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_EQ, EXPECT_TRUE, proxygen::SPDYCodec::generateGoaway(), proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorStreamUnacknowledged, folly::IOBuf::length(), string, and proxygen::Exception::what().

                                                                     {
  // Tests whether the session aborts the streams which are not created
  // at the remote end.

  // Create SPDY buf for GOAWAY with last good stream as 0 (no streams created)
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  folly::IOBufQueue respBuf{IOBufQueue::cacheChainLength()};
  egressCodec.generateGoaway(respBuf, 0, ErrorCode::NO_ERROR);
  std::unique_ptr<folly::IOBuf> goawayFrame = respBuf.move();
  goawayFrame->coalesce();

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectGoaway();
  handler->expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      EXPECT_EQ(err.getProxygenError(), kErrorStreamUnacknowledged);
      ASSERT_EQ(
        folly::to<std::string>("StreamUnacknowledged on transaction id: ",
                               handler->txn_->getID()),
        std::string(err.what()));
    });
  handler->expectDetachTransaction([this] {
      // Make sure the session can't create any more transactions.
      MockHTTPHandler handler2;
      EXPECT_EQ(httpSession_->newTransaction(&handler2), nullptr);
    });

  // Send the GET request
  handler->sendRequest();

  // Receive GOAWAY frame while waiting for SYN_REPLY
  readAndLoop(goawayFrame->data(), goawayFrame->length());

  // Session will delete itself after the abort
}

TEST_F	(	SPDY3UpstreamSessionTest	,
		IngressGoawaySessionError
	)

Definition at line 508 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_EQ, folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_EQ, EXPECT_TRUE, proxygen::SPDYCodec::generateGoaway(), proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorStreamUnacknowledged, folly::IOBuf::length(), string, and proxygen::Exception::what().

                                                            {
  // Tests whether the session aborts the streams which are not created
  // at the remote end which have error codes.

  // Create SPDY buf for GOAWAY with last good stream as 0 (no streams created)
  SPDYCodec egressCodec(TransportDirection::DOWNSTREAM,
                        SPDYVersion::SPDY3);
  folly::IOBufQueue respBuf{IOBufQueue::cacheChainLength()};
  egressCodec.generateGoaway(respBuf, 0, ErrorCode::PROTOCOL_ERROR);
  std::unique_ptr<folly::IOBuf> goawayFrame = respBuf.move();
  goawayFrame->coalesce();

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectGoaway();
  handler->expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      EXPECT_EQ(err.getProxygenError(), kErrorStreamUnacknowledged);
      ASSERT_EQ(
        folly::to<std::string>("StreamUnacknowledged on transaction id: ",
                               handler->txn_->getID(),
                               " with codec error: PROTOCOL_ERROR"),
        std::string(err.what()));
    });
  handler->expectDetachTransaction([this] {
      // Make sure the session can't create any more transactions.
      MockHTTPHandler handler2;
      EXPECT_EQ(httpSession_->newTransaction(&handler2), nullptr);
    });

  // Send the GET request
  handler->sendRequest();

  // Receive GOAWAY frame while waiting for SYN_REPLY
  readAndLoop(goawayFrame->data(), goawayFrame->length());

  // Session will delete itself after the abort
}

TEST_F	(	SPDY3UpstreamSessionTest	,
		TestUnderLimitOnWriteError
	)

Definition at line 548 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::getPostRequest(), handler(), and makeBuf().

                                                             {
  InSequence enforceOrder;
  auto handler = openTransaction();

  auto req = getPostRequest();
  handler->txn_->sendHeaders(req);
  // pause writes
  pauseWrites_ = true;
  handler->expectEgressPaused();

  // send body
  handler->txn_->sendBody(makeBuf(70000));
  eventBase_.loopOnce();

  // but no expectEgressResumed
  handler->expectError();
  handler->expectDetachTransaction();
  failWrites_ = true;
  resumeWrites();

  this->eventBase_.loop();
  EXPECT_EQ(this->sessionDestroyed_, true);
}

TEST_F	(	SPDY3UpstreamSessionTest	,
		TestOverlimitResume
	)

Definition at line 572 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::getPostRequest(), and makeBuf().

                                                      {
  InSequence enforceOrder;
  auto handler1 = openTransaction();
  auto handler2 = openTransaction();

  // Disable stream flow control for this test
  handler1->txn_->onIngressWindowUpdate(80000);
  handler2->txn_->onIngressWindowUpdate(80000);

  auto req = getPostRequest();
  handler1->txn_->sendHeaders(req);
  handler2->txn_->sendHeaders(req);
  // pause writes
  pauseWrites_ = true;
  handler1->expectEgressPaused();
  handler2->expectEgressPaused();

  // send body
  handler1->txn_->sendBody(makeBuf(70000));
  handler2->txn_->sendBody(makeBuf(70000));
  eventBase_.loopOnce();

  // when this handler is resumed, re-pause the pipe
  handler1->expectEgressResumed([&] {
      handler1->txn_->sendBody(makeBuf(70000));
    });
  // handler2 will get a shot
  handler2->expectEgressResumed();

  // both handlers will be paused
  handler1->expectEgressPaused();
  handler2->expectEgressPaused();
  resumeWrites();

  // They both get resumed
  handler1->expectEgressResumed([&] { handler1->txn_->sendEOM(); });
  handler2->expectEgressResumed([&] { handler2->txn_->sendEOM(); });

  this->eventBase_.loop();

  // less than graceful shutdown
  handler1->expectError();
  handler1->expectDetachTransaction();
  handler2->expectError();
  handler2->expectDetachTransaction();

  httpSession_->dropConnection();
  EXPECT_EQ(this->sessionDestroyed_, true);
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestPriority
	)

Definition at line 622 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, proxygen::getGetRequest(), testing::Invoke(), makeServerCodec(), and uint32_t.

                                               {
  InSequence enforceOrder;
  // virtual priority node with pri=8
  auto priGroupID = httpSession_->sendPriority({0, false, 7});
  auto handler1 = openTransaction();
  auto handler2 = openTransaction();

  auto req = getGetRequest();
  // send request with maximal weight
  req.setHTTP2Priority(HTTPMessage::HTTPPriority(0, false, 255));
  handler1->sendRequest(req);
  handler2->sendRequest(req);

  auto id = handler1->txn_->getID();
  auto id2 = handler2->txn_->getID();

  // Insert depth is 1, only root node has depth 0
  EXPECT_EQ(std::get<0>(handler1->txn_->getPrioritySummary()), 1);
  EXPECT_EQ(handler1->txn_->getPriorityFallback(), false);

  // update handler to be in the pri-group
  handler1->txn_->updateAndSendPriority(
    http2::PriorityUpdate{(uint32_t)priGroupID, false, 15});
  handler2->txn_->updateAndSendPriority(
    http2::PriorityUpdate{(uint32_t)priGroupID + 254, false, 15});

  // Change pri-group weight to max
  httpSession_->sendPriority(priGroupID, http2::PriorityUpdate{0, false, 255});
  eventBase_.loop();

  auto serverCodec = makeServerCodec();
  NiceMock<MockHTTPCodecCallback> callbacks;
  serverCodec->setCallback(&callbacks);
  EXPECT_CALL(callbacks, onPriority(priGroupID,
                                    HTTPMessage::HTTPPriority(0, false, 7)));
  EXPECT_CALL(callbacks, onHeadersComplete(id, _))
    .WillOnce(Invoke([&] (HTTPCodec::StreamID,
                          std::shared_ptr<HTTPMessage> msg) {
          EXPECT_EQ(*(msg->getHTTP2Priority()),
                    HTTPMessage::HTTPPriority(0, false, 255));
        }));
  EXPECT_CALL(callbacks, onHeadersComplete(id2, _))
    .WillOnce(Invoke([&] (HTTPCodec::StreamID,
                          std::shared_ptr<HTTPMessage> msg) {
          EXPECT_EQ(*(msg->getHTTP2Priority()),
                    HTTPMessage::HTTPPriority(0, false, 255));
          }));
  EXPECT_CALL(callbacks,
              onPriority(
                id, HTTPMessage::HTTPPriority(priGroupID, false, 15)));
  EXPECT_CALL(callbacks,
              onPriority(
                id2, HTTPMessage::HTTPPriority(priGroupID + 254, false, 15)));
  EXPECT_EQ(handler1->txn_->getPriorityFallback(), false);
  EXPECT_EQ(handler2->txn_->getPriorityFallback(), false);

  EXPECT_EQ(std::get<1>(handler1->txn_->getPrioritySummary()), 2);
  // created virtual parent node
  EXPECT_EQ(std::get<1>(handler2->txn_->getPrioritySummary()), 2);
  EXPECT_CALL(callbacks,
              onPriority(priGroupID, HTTPMessage::HTTPPriority(0, false, 255)));
  parseOutput(*serverCodec);
  eventBase_.loop();

  handler1->expectError();
  handler1->expectDetachTransaction();
  handler2->expectError();
  handler2->expectDetachTransaction();
  httpSession_->dropConnection();
  eventBase_.loop();
  EXPECT_EQ(sessionDestroyed_, true);
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestSettingsAck
	)

Definition at line 695 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), EXPECT_CALL, EXPECT_EQ, and makeServerCodec().

                                                  {
  auto serverCodec = makeServerCodec();
  folly::IOBufQueue buf{IOBufQueue::cacheChainLength()};
  serverCodec->generateSettings(buf);
  auto settingsFrame = buf.move();
  settingsFrame->coalesce();

  InSequence enforceOrder;

  NiceMock<MockHTTPCodecCallback> callbacks;
  serverCodec->setCallback(&callbacks);
  EXPECT_CALL(callbacks, onSettings(_));
  EXPECT_CALL(callbacks, onSettingsAck());

  readAndLoop(settingsFrame.get());
  parseOutput(*serverCodec);
  httpSession_->dropConnection();
  EXPECT_EQ(sessionDestroyed_, true);
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestSettingsInfoCallbacks
	)

Definition at line 715 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), EXPECT_CALL, and makeServerCodec().

                                                            {
  auto serverCodec = makeServerCodec();

  folly::IOBufQueue settingsBuf{IOBufQueue::cacheChainLength()};
  serverCodec->generateSettings(settingsBuf);
  auto settingsFrame = settingsBuf.move();

  folly::IOBufQueue settingsAckBuf{IOBufQueue::cacheChainLength()};
  serverCodec->generateSettingsAck(settingsAckBuf);
  auto settingsAckFrame = settingsAckBuf.move();

  MockHTTPSessionInfoCallback infoCb;
  httpSession_->setInfoCallback(&infoCb);

  EXPECT_CALL(infoCb, onRead(_, _)).Times(2);
  EXPECT_CALL(infoCb, onWrite(_, _)).Times(1);
  EXPECT_CALL(infoCb, onDestroy(_)).Times(1);

  EXPECT_CALL(infoCb, onSettings(_, _)).Times(1);
  EXPECT_CALL(infoCb, onSettingsAck(_)).Times(1);

  InSequence enforceOrder;

  readAndLoop(settingsFrame.get());
  readAndLoop(settingsAckFrame.get());

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestSetControllerInitHeaderIndexingStrat
	)

Definition at line 744 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, proxygen::HTTP2Codec::getHeaderIndexingStrategy(), handler(), and testing::Return().

                                                                           {
  StrictMock<MockUpstreamController> mockController;
  HeaderIndexingStrategy testH2IndexingStrat;
  EXPECT_CALL(mockController, getHeaderIndexingStrategy())
    .WillOnce(
      Return(&testH2IndexingStrat)
  );

  httpSession_->setController(&mockController);

  auto handler = openTransaction();
  handler->expectDetachTransaction();

  const HTTP2Codec* h2Codec = static_cast<const HTTP2Codec*>(
    &handler->txn_->getTransport().getCodec());
  EXPECT_EQ(h2Codec->getHeaderIndexingStrategy(), &testH2IndexingStrat);

  handler->txn_->sendAbort();
  eventBase_.loop();

  EXPECT_CALL(mockController, detachSession(_));
  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		ExheaderFromServer
	)

Definition at line 777 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), EXPECT_CALL, EXPECT_EQ, proxygen::getGetRequest(), proxygen::getResponse(), testing::Invoke(), makeServerCodec(), and proxygen::HTTPTransaction::setHandler().

                                                     {
  folly::IOBufQueue queue{IOBufQueue::cacheChainLength()};

  // generate enable_ex_headers setting
  auto serverCodec = makeServerCodec();
  enableExHeader(serverCodec.get());
  serverCodec->generateSettings(queue);
  // generate the response for control stream, but EOM
  auto cStreamId = HTTPCodec::StreamID(1);
  serverCodec->generateHeader(queue, cStreamId, getResponse(200, 0),
                              false, nullptr);
  // generate a request from server, encapsulated in EX_HEADERS frame
  serverCodec->generateExHeader(queue, 2, getGetRequest("/messaging"),
                                HTTPCodec::ExAttributes(cStreamId, false),
                                true, nullptr);
  serverCodec->generateEOM(queue, 1);

  auto cHandler = openTransaction();
  cHandler->sendRequest(getGetRequest("/cc"));

  NiceMock<MockHTTPHandler> pubHandler;
  InSequence handlerSequence;
  cHandler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });

  EXPECT_CALL(*cHandler, onExTransaction(_))
    .WillOnce(Invoke([&pubHandler] (HTTPTransaction* pubTxn) {
          pubTxn->setHandler(&pubHandler);
          pubHandler.txn_ = pubTxn;
        }));
  pubHandler.expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(msg->getPath(), "/messaging");
    });
  pubHandler.expectEOM([&] () {
      pubHandler.txn_->sendAbort();
    });
  pubHandler.expectDetachTransaction();

  cHandler->expectEOM();
  cHandler->expectDetachTransaction();

  auto buf = queue.move();
  buf->coalesce();
  readAndLoop(buf.get());

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		InvalidControlStream
	)

Definition at line 826 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), EXPECT_CALL, EXPECT_EQ, proxygen::getGetRequest(), proxygen::getResponse(), and makeServerCodec().

                                                       {
  folly::IOBufQueue queue{IOBufQueue::cacheChainLength()};

  // generate enable_ex_headers setting
  auto serverCodec = makeServerCodec();
  enableExHeader(serverCodec.get());
  serverCodec->generateSettings(queue);
  // generate the response for control stream, but EOM
  auto cStreamId = HTTPCodec::StreamID(1);
  serverCodec->generateHeader(queue, cStreamId, getResponse(200, 0),
                              false, nullptr);
  // generate a EX_HEADERS frame with non-existing control stream
  serverCodec->generateExHeader(queue, 2, getGetRequest("/messaging"),
                                HTTPCodec::ExAttributes(cStreamId + 2, false),
                                true, nullptr);
  serverCodec->generateEOM(queue, 1);

  auto cHandler = openTransaction();
  cHandler->sendRequest(getGetRequest("/cc"));

  InSequence handlerSequence;
  cHandler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });
  EXPECT_CALL(*cHandler, onExTransaction(_)).Times(0);
  cHandler->expectEOM();
  cHandler->expectDetachTransaction();

  auto buf = queue.move();
  buf->coalesce();
  readAndLoop(buf.get());

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionWithVirtualNodesTest	,
		VirtualNodes
	)

Definition at line 928 of file HTTPUpstreamSessionTest.cpp.

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

                                                               {
  InSequence enforceOrder;

  HTTPCodec::StreamID deps[] = {11, 13, 15};
  EXPECT_CALL(*codecPtr_, addPriorityNodes(_, _, _))
    .Times(1)
    .WillOnce(Invoke([&] (
            HTTPCodec::PriorityQueue&,
            folly::IOBufQueue&,
            uint8_t maxLevel) {
          for (size_t i = 0; i < maxLevel; i++) {
            dependencies.push_back(deps[i]);
          }
          return 123;
        }));
  httpSession_->startNow();

  EXPECT_EQ(level_, dependencies.size());
  StrictMock<MockHTTPHandler> handler;
  handler.expectTransaction();
  auto txn = httpSession_->newTransaction(&handler);

  EXPECT_CALL(*codecPtr_, mapPriorityToDependency(_))
    .Times(1)
    .WillOnce(Invoke([&] (uint8_t priority) {
            return dependencies[priority];
          }));
  txn->updateAndSendPriority(0);

  handler.expectError();
  handler.expectDetachTransaction();
  httpSession_->dropConnection();

  eventBase_.loop();
}

TEST_F	(	HTTP2UpstreamSessionWithPriorityTree	,
		PriorityTree
	)

Definition at line 972 of file HTTPUpstreamSessionTest.cpp.

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

                                                           {
  InSequence enforceOrder;

  std::array<HTTPCodec::StreamID, 3> deps = { {11, 13, 15} };
  EXPECT_CALL(*codecPtr_, addPriorityNodes(_, _, _))
    .Times(0)
    .WillOnce(Invoke([&] (
            HTTPCodec::PriorityQueue&,
            folly::IOBufQueue&,
            uint8_t maxLevel) {
          for (size_t i = 0; i < maxLevel; i++) {
            dependencies.push_back(deps[i]);
          }
          return 123;
        }));
  httpSession_->startNow();

  // It should have built the virtual streams from the tree but not the old
  // priority levels.
  EXPECT_EQ(dependencies.size(), 0);
  HTTPMessage::HTTPPriority hiPri =
      *httpSession_->getHTTPPriority(builder_->hiPriLevel_);
  EXPECT_EQ(std::get<2>(hiPri), builder_->hiPriWeight_);
  HTTPMessage::HTTPPriority loPri =
      *httpSession_->getHTTPPriority(builder_->loPriLevel_);
  EXPECT_EQ(std::get<2>(loPri), builder_->loPriWeight_);

  for (size_t level = 0; level < 256; ++level) {
    if (level == builder_->hiPriLevel_) {
      continue;
    }
    HTTPMessage::HTTPPriority pri = *httpSession_->getHTTPPriority(level);
    EXPECT_EQ(pri, loPri);
  }

  StrictMock<MockHTTPHandler> handler;
  handler.expectTransaction();
  auto txn = httpSession_->newTransaction(&handler);

  txn->updateAndSendPriority(0);

  handler.expectError();
  handler.expectDetachTransaction();
  httpSession_->dropConnection();

  eventBase_.loop();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		BasicRequest
	)

Definition at line 1049 of file HTTPUpstreamSessionTest.cpp.

                                              {
  testBasicRequest();
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		TwoRequests
	)

Definition at line 1054 of file HTTPUpstreamSessionTest.cpp.

                                             {
  testBasicRequest();
  testBasicRequest();
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		10Requests
	)

Definition at line 1060 of file HTTPUpstreamSessionTest.cpp.

References i, and uint16_t.

                                            {
  for (uint16_t i = 0; i < 10; i++) {
    testBasicRequest();
  }
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		TestFirstHeaderByteEventTracker
	)

Definition at line 1067 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, handler(), proxygen::HTTPTransaction::incrementPendingByteEvents(), testing::Invoke(), and uint64_t.

                                                                 {
  auto byteEventTracker = setMockByteEventTracker();

  EXPECT_CALL(*byteEventTracker, addFirstHeaderByteEvent(_, _))
      .WillOnce(Invoke([] (uint64_t /*byteNo*/,
                           HTTPTransaction* txn) {
                         txn->incrementPendingByteEvents();
                       }));

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop("HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n\r\n");

  CHECK(httpSession_->supportsMoreTransactions());
  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
  handler->txn_->decrementPendingByteEvents();
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		Http10Keepalive
	)

Definition at line 1132 of file HTTPUpstreamSessionTest.cpp.

                                                 {
  testBasicRequestHttp10(true);
  testBasicRequestHttp10(false);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		BasicTrailers
	)

Definition at line 1137 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and handler().

                                               {
  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  EXPECT_CALL(*handler, onTrailers(_));
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop("HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n"
              "X-Trailer1: foo\r\n"
              "\r\n");

  CHECK(httpSession_->supportsMoreTransactions());
  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		BasicTrailers
	)

Definition at line 1162 of file HTTPUpstreamSessionTest.cpp.

References folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), handler(), folly::IOBuf::length(), makeBuf(), makeServerCodec(), folly::IOBufQueue::move(), folly::gen::move, gmock_output_test::output, proxygen::HTTPHeaders::set(), and proxygen::HTTPMessage::setStatusCode().

                                                {
  auto egressCodec = makeServerCodec();
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());

  egressCodec->generateSettings(output);

  HTTPMessage resp;
  resp.setStatusCode(200);
  resp.getHeaders().set("header1", "value1");
  egressCodec->generateHeader(output, 1, resp);
  auto buf = makeBuf(100);
  egressCodec->generateBody(
      output, 1, std::move(buf), HTTPCodec::NoPadding, false /* eom */);
  HTTPHeaders trailers;
  trailers.set("trailer2", "value2");
  egressCodec->generateTrailers(output, 1, trailers);

  std::unique_ptr<folly::IOBuf> input = output.move();
  input->coalesce();

  auto handler = openTransaction();

  handler->expectHeaders([&](std::shared_ptr<HTTPMessage> msg) {
    EXPECT_EQ(200, msg->getStatusCode());
    EXPECT_EQ(msg->getHeaders().getSingleOrEmpty("header1"), "value1");
  });
  handler->expectBody();
  handler->expectTrailers([&](std::shared_ptr<HTTPHeaders> trailers) {
    EXPECT_EQ(trailers->getSingleOrEmpty("trailer2"), "value2");
  });
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop(input->data(), input->length());

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		HeadersThenBodyThenHeaders
	)

Definition at line 1201 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_EQ, folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_EQ, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorIngressStateTransition, folly::IOBuf::length(), makeBuf(), makeServerCodec(), folly::IOBufQueue::move(), folly::gen::move, gmock_output_test::output, proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setStatusCode(), string, and proxygen::Exception::what().

                                                             {
  auto egressCodec = makeServerCodec();
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());

  egressCodec->generateSettings(output);

  HTTPMessage resp;
  resp.setStatusCode(200);
  resp.getHeaders().set("header1", "value1");
  egressCodec->generateHeader(output, 1, resp);
  auto buf = makeBuf(100);
  egressCodec->generateBody(
      output, 1, std::move(buf), HTTPCodec::NoPadding, false /* eom */);
  // generate same headers again on the same stream
  egressCodec->generateHeader(output, 1, resp);

  std::unique_ptr<folly::IOBuf> input = output.move();
  input->coalesce();

  auto handler = openTransaction();

  handler->expectHeaders([&](std::shared_ptr<HTTPMessage> msg) {
    EXPECT_EQ(200, msg->getStatusCode());
    EXPECT_EQ(msg->getHeaders().getSingleOrEmpty("header1"), "value1");
  });
  handler->expectBody();
  handler->expectError([&](const HTTPException& err) {
    EXPECT_TRUE(err.hasProxygenError());
    EXPECT_EQ(err.getProxygenError(), kErrorIngressStateTransition);
    ASSERT_EQ(
        "Invalid ingress state transition, state=RegularBodyReceived, "
        "event=onHeaders, streamID=1",
        std::string(err.what()));
  });
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop(input->data(), input->length());

  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		TwoRequestsWithPause
	)

Definition at line 1243 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, and handler().

                                                      {
  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });

  handler->expectEOM([&] () { handler->txn_->pauseIngress(); });
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop("HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n\r\n");

  // Even though the previous transaction paused ingress just before it
  // finished up, reads resume automatically when the number of
  // transactions goes to zero. This way, the second request can read
  // without having to call resumeIngress()
  testBasicRequest();
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamTimeoutTest	,
		WriteTimeoutAfterResponse
	)

Definition at line 1270 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_EQ, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::HTTPException::getDirection(), proxygen::getPostRequest(), proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorWriteTimeout, string, and proxygen::Exception::what().

                                                           {
  // Test where the upstream session times out while writing the request
  // to the server, but after the server has already sent back a full
  // response.
  pauseWrites_ = true;
  HTTPMessage req = getPostRequest();

  InSequence enforceOrder;
  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      ASSERT_EQ(err.getDirection(),
                HTTPException::Direction::INGRESS_AND_EGRESS);
      EXPECT_EQ(err.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(
        folly::to<std::string>("WriteTimeout on transaction id: ",
                               handler->txn_->getID()),
        std::string(err.what()));
    });
  handler->expectDetachTransaction();

  handler->txn_->sendHeaders(req);
  // Don't send the body, but get a response immediately
  readAndLoop("HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n\r\n");
}

TEST_F	(	HTTPUpstreamSessionTest	,
		SetTransactionTimeout
	)

Definition at line 1304 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and handler().

                                                       {
  // Test that setting a new timeout on the transaction will cancel
  // the old one.
  auto handler = openTransaction();
  handler->expectDetachTransaction();

  EXPECT_TRUE(handler->txn_->hasIdleTimeout());
  handler->txn_->setIdleTimeout(std::chrono::milliseconds(747));
  EXPECT_TRUE(handler->txn_->hasIdleTimeout());
  EXPECT_TRUE(handler->txn_->isScheduled());
  EXPECT_EQ(transactionTimeouts_->count(), 1);
  handler->txn_->sendAbort();
  eventBase_.loop();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		ReadTimeout
	)

Definition at line 1319 of file HTTPUpstreamSessionTest.cpp.

References wangle::ConnectionManager::makeUnique().

                                             {
  NiceMock<MockUpstreamController> controller;
  httpSession_->setController(&controller);
  auto cm = wangle::ConnectionManager::makeUnique(
    &eventBase_, std::chrono::milliseconds(50));
  cm->addConnection(httpSession_, true);
  eventBase_.loop();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		100ContinueKeepalive
	)

Definition at line 1328 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_EXPECT, and proxygen::HTTPHeaders::set().

                                                      {
  // Test a request with 100 continue on a keepalive connection. Then make
  // another request.
  HTTPMessage req = getGetRequest();
  req.getHeaders().set(HTTP_HEADER_EXPECT, "100-continue");

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(100, msg->getStatusCode());
    });
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest(req);
  readAndLoop("HTTP/1.1 100 Continue\r\n\r\n"
              "HTTP/1.1 200 OK\r\n"
              "Transfer-Encoding: chunked\r\n\r\n"
              "0\r\n\r\n");

  // Now make sure everything still works
  testBasicRequest();
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		417Keepalive
	)

Definition at line 1361 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_EXPECT, and proxygen::HTTPHeaders::set().

                                              {
  // Test a request with 100 continue on a keepalive connection. Then make
  // another request after the expectation fails.
  HTTPMessage req = getGetRequest();
  req.getHeaders().set(HTTP_HEADER_EXPECT, "100-continue");

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(417, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest(req);
  readAndLoop("HTTP/1.1 417 Expectation Failed\r\n"
              "Content-Length: 0\r\n\r\n");

  // Now make sure everything still works
  testBasicRequest();
  EXPECT_FALSE(sessionDestroyed_);
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		101Upgrade
	)

Definition at line 1388 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_UPGRADE, and proxygen::HTTPHeaders::set().

                                            {
  // Test an upgrade request with sending 101 response. Then send
  // some data and check the onBody callback contents
  HTTPMessage req = getGetRequest();
  req.getHeaders().set(HTTP_HEADER_UPGRADE, "http/2.0");

  InSequence enforceOrder;

  auto handler = openTransaction();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_EQ(101, msg->getStatusCode());
    });
  EXPECT_CALL(*handler, onUpgrade(_));
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("Test Body\r\n"));
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest(req);
  eventBase_.loop();
  readAndLoop("HTTP/1.1 101 Switching Protocols\r\n"
              "Upgrade: http/2.0\r\n\r\n"
              "Test Body\r\n");
  readCallback_->readEOF();
  eventBase_.loop();

  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradeNativeH2
	)

Definition at line 1473 of file HTTPUpstreamSessionTest.cpp.

                                                     {
  testSimpleUpgrade("h2c", "h2c", CodecProtocol::HTTP_2);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradeNativeUnknown
	)

Definition at line 1478 of file HTTPUpstreamSessionTest.cpp.

                                                          {
  testSimpleUpgrade("blarf, h2c", "h2c", CodecProtocol::HTTP_2);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradeNativeWhitespace
	)

Definition at line 1483 of file HTTPUpstreamSessionTest.cpp.

                                                             {
  testSimpleUpgrade("blarf, \th2c\t, xyz", "h2c",
                    CodecProtocol::HTTP_2);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradeNativeJunk
	)

Definition at line 1489 of file HTTPUpstreamSessionTest.cpp.

                                                       {
  testSimpleUpgrade(",,,,   ,,\t~^%$(*&@(@$^^*(,h2c", "h2c",
                    CodecProtocol::HTTP_2);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgrade101Unexpected
	)

Definition at line 1494 of file HTTPUpstreamSessionTest.cpp.

References testing::_, dummy(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, and handler().

                                                          {
  InSequence dummy;
  auto handler = openTransaction();

  EXPECT_CALL(*handler, onError(_));
  handler->expectDetachTransaction();

  handler->sendRequest();
  eventBase_.loop();
  readAndLoop(folly::to<string>("HTTP/1.1 101 Switching Protocols\r\n"
                                "Upgrade: spdy/3\r\n"
                                "\r\n"));
  EXPECT_EQ(readCallback_, nullptr);
  EXPECT_TRUE(sessionDestroyed_);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgrade101MissingUpgrade
	)

Definition at line 1510 of file HTTPUpstreamSessionTest.cpp.

References testing::_, dummy(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, proxygen::getUpgradeRequest(), and handler().

                                                              {
  InSequence dummy;
  auto handler = openTransaction();

  EXPECT_CALL(*handler, onError(_));
  handler->expectDetachTransaction();

  handler->sendRequest(getUpgradeRequest("spdy/3"));
  readAndLoop(folly::to<string>("HTTP/1.1 101 Switching Protocols\r\n"
                                "\r\n"));
  EXPECT_EQ(readCallback_, nullptr);
  EXPECT_TRUE(sessionDestroyed_);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgrade101BogusHeader
	)

Definition at line 1524 of file HTTPUpstreamSessionTest.cpp.

References testing::_, dummy(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, proxygen::getUpgradeRequest(), and handler().

                                                           {
  InSequence dummy;
  auto handler = openTransaction();

  EXPECT_CALL(*handler, onError(_));
  handler->expectDetachTransaction();

  handler->sendRequest(getUpgradeRequest("spdy/3"));
  eventBase_.loop();
  readAndLoop(folly::to<string>("HTTP/1.1 101 Switching Protocols\r\n"
                                "Upgrade: blarf\r\n"
                                "\r\n"));
  EXPECT_EQ(readCallback_, nullptr);
  EXPECT_TRUE(sessionDestroyed_);
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradePost100
	)

Definition at line 1540 of file HTTPUpstreamSessionTest.cpp.

References dummy(), EXPECT_EQ, handler(), makeBuf(), and folly::gen::move.

                                                    {
  InSequence dummy;
  auto handler = openTransaction();

  handler->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(100, msg->getStatusCode());
    });
  handler->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectBody();
  handler->expectEOM();
  handler->expectDetachTransaction();

  auto txn = handler->txn_;
  HTTPMessage req = getUpgradePostRequest(100, "h2c", true /* 100 */);
  txn->sendHeaders(req);
  auto buf = makeBuf(100);
  txn->sendBody(std::move(buf));
  txn->sendEOM();
  eventBase_.loop();
  readAndLoop(folly::to<string>("HTTP/1.1 100 Continue\r\n"
                                "\r\n"
                                "HTTP/1.1 101 Switching Protocols\r\n"
                                "Upgrade: h2c\r\n"
                                "\r\n"));
  readAndLoop(
    getResponseBuf(CodecProtocol::HTTP_2, txn->getID(), 200, 100).get());
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradePost100Http2
	)

Definition at line 1571 of file HTTPUpstreamSessionTest.cpp.

References dummy(), EXPECT_EQ, handler(), makeBuf(), and folly::gen::move.

                                                         {
  InSequence dummy;
  auto handler = openTransaction();

  handler->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(100, msg->getStatusCode());
    });
  handler->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectBody();
  handler->expectEOM();
  handler->expectDetachTransaction();

  auto txn = handler->txn_;
  HTTPMessage req = getUpgradePostRequest(100, "h2c");
  txn->sendHeaders(req);
  auto buf = makeBuf(100);
  txn->sendBody(std::move(buf));
  txn->sendEOM();
  eventBase_.loop();
  readAndLoop(folly::to<string>("HTTP/1.1 101 Switching Protocols\r\n"
                                "Upgrade: h2c\r\n"
                                "\r\n"));
  readAndLoop(getResponseBuf(CodecProtocol::HTTP_2,
                             txn->getID(), 200, 100, true).get());
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamSessionTest	,
		HttpUpgradeOnTxn2
	)

Definition at line 1600 of file HTTPUpstreamSessionTest.cpp.

References dummy(), EXPECT_EQ, and proxygen::getUpgradeRequest().

                                                   {
  InSequence dummy;
  auto handler1 = openTransaction();

  handler1->expectHeaders([] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler1->expectBody();
  handler1->expectEOM();
  handler1->expectDetachTransaction();

  auto txn = handler1->txn_;
  HTTPMessage req = getUpgradeRequest("spdy/3");
  txn->sendHeaders(req);
  txn->sendEOM();
  readAndLoop("HTTP/1.1 200 Ok\r\n"
              "Content-Length: 10\r\n"
              "\r\n"
              "abcdefghij");
  eventBase_.loop();

  auto handler2 = openTransaction();

  txn = handler2->txn_;
  txn->sendHeaders(req);
  txn->sendEOM();

  handler2->expectHeaders();
  handler2->expectEOM();
  handler2->expectDetachTransaction();
  readAndLoop("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
  httpSession_->destroy();
}

TEST_F	(	HTTPUpstreamRecvStreamTest	,
		UpgradeFlowControl
	)

Definition at line 1641 of file HTTPUpstreamSessionTest.cpp.

References testing::_, dummy(), EXPECT_CALL, proxygen::HTTP2Codec::getDefaultWindowSize(), testing::Invoke(), proxygen::HTTPParallelCodec::setCallback(), and settings.

                                                       {
  InSequence dummy;
  testSimpleUpgrade("h2c", "h2c", CodecProtocol::HTTP_2);

  HTTP2Codec serverCodec(TransportDirection::DOWNSTREAM);
  NiceMock<MockHTTPCodecCallback> callbacks;
  serverCodec.setCallback(&callbacks);
  EXPECT_CALL(callbacks, onSettings(_))
    .WillOnce(Invoke([this] (const SettingsList& settings) {
          if (flowControl_[0] > 0) {
            for (const auto& setting: settings) {
              if (setting.id == SettingsId::INITIAL_WINDOW_SIZE) {
                EXPECT_EQ(flowControl_[0], setting.value);
              }
            }
          }
        }));
  EXPECT_CALL(callbacks, onWindowUpdate(0, flowControl_[2] -
                                        serverCodec.getDefaultWindowSize()));
  size_t initWindow = flowControl_[0] > 0 ?
    flowControl_[0] : serverCodec.getDefaultWindowSize();
  EXPECT_CALL(callbacks, onWindowUpdate(1, flowControl_[1] - initWindow));
  parseOutput(serverCodec);
}

TEST_F	(	NoFlushUpstreamSessionTest	,
		SessionPausedStartPaused
	)

Definition at line 1690 of file HTTPUpstreamSessionTest.cpp.

References proxygen::getGetRequest(), and makeBuf().

                                                             {
  // If the session is paused, new upstream transactions should start
  // paused too.
  HTTPMessage req = getGetRequest();

  InSequence enforceOrder;

  auto handler1 = openNiceTransaction();
  handler1->txn_->sendHeaders(req);
  Mock::VerifyAndClearExpectations(handler1.get());
  // The session pauses all txns since no writeSuccess for too many bytes
  handler1->expectEgressPaused();
  // Send a body big enough to pause egress
  handler1->txn_->sendBody(makeBuf(httpSession_->getWriteBufferLimit()));
  eventBase_.loop();
  Mock::VerifyAndClearExpectations(handler1.get());

  auto handler2 = openNiceTransaction(true /* expect start paused */);
  eventBase_.loop();
  Mock::VerifyAndClearExpectations(handler2.get());

  httpSession_->dropConnection();
}

TEST_F	(	NoFlushUpstreamSessionTest	,
		DeleteTxnOnUnpause
	)

Definition at line 1714 of file HTTPUpstreamSessionTest.cpp.

References proxygen::getGetRequest(), and makeBuf().

                                                       {
  // Test where the handler gets onEgressPaused() and triggers another
  // HTTPSession call to iterate over all transactions (to ensure nested
  // iteration works).

  HTTPMessage req = getGetRequest();

  InSequence enforceOrder;

  auto handler1 = openNiceTransaction();
  auto handler2 = openNiceTransaction();
  auto handler3 = openNiceTransaction();
  handler2->expectEgressPaused([this] {
      // This time it is invoked by the session on all transactions
      httpSession_->dropConnection();
    });
  handler2->txn_->sendHeaders(req);
  // This happens when the body write fills the txn egress queue
  // Send a body big enough to pause egress
  handler2->txn_->onIngressWindowUpdate(100);
  handler2->txn_->sendBody(makeBuf(httpSession_->getWriteBufferLimit() + 1));
  eventBase_.loop();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		ServerPush
	)

Definition at line 1798 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::cacheChainLength(), folly::IOBuf::coalesce(), folly::IOBuf::data(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::MockHTTPHandler::expectBody(), proxygen::MockHTTPHandler::expectDetachTransaction(), proxygen::MockHTTPHandler::expectEOM(), proxygen::MockHTTPHandler::expectHeaders(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_HOST, testing::Invoke(), folly::IOBuf::length(), makeBuf(), makeServerCodec(), folly::IOBufQueue::move(), folly::gen::move, gmock_output_test::output, proxygen::HTTPHeaders::set(), proxygen::HTTPTransaction::setHandler(), proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setURL().

                                             {
  httpSession_->setEgressSettings({{SettingsId::ENABLE_PUSH, 1}});

  auto egressCodec = makeServerCodec();
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());

  HTTPMessage push;
  push.getHeaders().set("HOST", "www.foo.com");
  push.setURL("https://www.foo.com/");
  egressCodec->generateSettings(output);
  // PUSH_PROMISE
  egressCodec->generatePushPromise(output, 2, push, 1);

  // Pushed resource
  HTTPMessage resp;
  resp.setStatusCode(200);
  resp.getHeaders().set("ohai", "push");
  egressCodec->generateHeader(output, 2, resp);
  auto buf = makeBuf(100);
  egressCodec->generateBody(output, 2, std::move(buf), HTTPCodec::NoPadding,
                            true /* eom */);

  // Original resource
  resp.getHeaders().set("ohai", "orig");
  egressCodec->generateHeader(output, 1, resp);
  buf = makeBuf(100);
  egressCodec->generateBody(output, 1, std::move(buf), HTTPCodec::NoPadding,
                           true /* eom */);

  std::unique_ptr<folly::IOBuf> input = output.move();
  input->coalesce();

  MockHTTPHandler pushHandler;

  InSequence enforceOrder;

  auto handler = openTransaction();
  EXPECT_CALL(*handler, onPushedTransaction(_))
    .WillOnce(Invoke([&pushHandler] (HTTPTransaction* pushTxn) {
          pushTxn->setHandler(&pushHandler);
        }));
  EXPECT_CALL(pushHandler, setTransaction(_));
  pushHandler.expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(httpSession_->getNumIncomingStreams(), 1);
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(msg->getPath(), "/");
      EXPECT_EQ(msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST),
                "www.foo.com");
    });
  pushHandler.expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(msg->getStatusCode(), 200);
      EXPECT_EQ(msg->getHeaders().getSingleOrEmpty("ohai"), "push");
    });
  pushHandler.expectBody();
  pushHandler.expectEOM();
  pushHandler.expectDetachTransaction();

  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
      EXPECT_EQ(msg->getHeaders().getSingleOrEmpty("ohai"), "orig");
    });
  handler->expectBody();
  handler->expectEOM();
  handler->expectDetachTransaction();

  handler->sendRequest();
  readAndLoop(input->data(), input->length());

  EXPECT_EQ(httpSession_->getNumIncomingStreams(), 0);
  httpSession_->destroy();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ParseErrorNoTxn
	)

Definition at line 1887 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::append(), EXPECT_CALL, proxygen::getPostRequest(), handler(), testing::Invoke(), proxygen::kErrorParseHeader, testing::Return(), proxygen::HTTPException::setCodecStatusCode(), proxygen::Exception::setProxygenError(), and fizz::detail::writeBuf().

                                               {
  // 1) Create streamID == 1
  // 2) Send request
  // 3) Detach handler
  // 4) Get an ingress parse error on reply
  // Expect that the codec should be asked to generate an abort on streamID==1

  // Setup the codec expectations.
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _))
    .WillOnce(Invoke([] (folly::IOBufQueue& writeBuf, HTTPCodec::StreamID,
                         const HTTPMessage&, bool, HTTPHeaderSize*) {
                       writeBuf.append("1", 1);
                     }));
  EXPECT_CALL(*codecPtr_, generateEOM(_, _))
    .WillOnce(Return(20));
  EXPECT_CALL(*codecPtr_, generateRstStream(_, 1, _));

  // 1)
  auto handler = openTransaction();

  // 2)
  handler->sendRequest(getPostRequest());

  // 3) Note this sendAbort() doesn't destroy the txn since byte events are
  // enqueued
  handler->txn_->sendAbort();

  // 4)
  HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, "foo");
  ex.setProxygenError(kErrorParseHeader);
  ex.setCodecStatusCode(ErrorCode::REFUSED_STREAM);
  codecCb_->onError(1, ex, true);

  // cleanup
  handler->expectDetachTransaction();
  httpSession_->dropConnection();
  eventBase_.loop();
}

TEST_F	(	MockHTTPUpstreamTest	,
		0MaxOutgoingTxns
	)

Definition at line 1926 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_TRUE.

                                               {
  // Test where an upstream session gets a SETTINGS frame with 0 max
  // outgoing transactions. In our implementation, we jsut send a GOAWAY
  // and close the connection.

  codecCb_->onSettings({{SettingsId::MAX_CONCURRENT_STREAMS, 0}});
  EXPECT_TRUE(transactionsFull_);
  httpSession_->dropConnection();
}

TEST_F	(	MockHTTPUpstreamTest	,
		OutgoingTxnSettings
	)

Definition at line 1936 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                                  {
  // Create 2 transactions, then receive a settings frame from
  // the server indicating 1 parallel transaction at a time is allowed.
  // Then get another SETTINGS frame indicating 100 max parallel
  // transactions. Expect that HTTPSession invokes both info callbacks.

  NiceMock<MockHTTPHandler> handler1;
  NiceMock<MockHTTPHandler> handler2;
  httpSession_->newTransaction(&handler1);
  httpSession_->newTransaction(&handler2);

  codecCb_->onSettings({{SettingsId::MAX_CONCURRENT_STREAMS, 1}});
  EXPECT_TRUE(transactionsFull_);
  codecCb_->onSettings({{SettingsId::MAX_CONCURRENT_STREAMS, 100}});
  EXPECT_FALSE(transactionsFull_);
  httpSession_->dropConnection();
}

TEST_F	(	MockHTTPUpstreamTest	,
		IngressGoawayDrain
	)

Definition at line 1954 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, handler(), proxygen::makeResponse(), and folly::gen::move.

                                                 {
  // Tests whether the session drains existing transactions and
  // deletes itself after receiving a GOAWAY.

  InSequence enforceOrder;

  auto handler = openTransaction();
  EXPECT_CALL(*handler, onGoaway(ErrorCode::NO_ERROR));
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  // Send the GET request
  handler->sendRequest();

  // Receive GOAWAY frame with last good stream as 1
  codecCb_->onGoaway(1, ErrorCode::NO_ERROR);

  // New transactions cannot be created afrer goaway
  EXPECT_FALSE(httpSession_->isReusable());
  EXPECT_EQ(httpSession_->newTransaction(handler.get()), nullptr);

  // Receive 200 OK
  auto resp = makeResponse(200);
  codecCb_->onMessageBegin(1, resp.get());
  codecCb_->onHeadersComplete(1, std::move(resp));
  codecCb_->onMessageComplete(1, false);
  eventBase_.loop();

  // Session will delete itself after getting the response
}

TEST_F	(	MockHTTPUpstreamTest	,
		Goaway
	)

Definition at line 1989 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, proxygen::MockHTTPHandler::expectDetachTransaction(), proxygen::MockHTTPHandler::expectEOM(), proxygen::MockHTTPHandler::expectHeaders(), proxygen::MockHTTPHandler::expectTransaction(), handler(), i, proxygen::makeResponse(), folly::gen::move, and proxygen::HTTPHandlerBase::sendRequest().

                                     {
  // Make sure existing txns complete successfully even if we drain the
  // upstream session
  const unsigned numTxns = 10;
  MockHTTPHandler handler[numTxns];

  InSequence enforceOrder;

  for (unsigned i = 0; i < numTxns; ++i) {
    handler[i].expectTransaction();
    handler[i].expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
        EXPECT_FALSE(msg->getIsUpgraded());
        EXPECT_EQ(200, msg->getStatusCode());
      });
    httpSession_->newTransaction(&handler[i]);

    // Send the GET request
    handler[i].sendRequest();

    // Receive 200 OK
    auto resp = makeResponse(200);
    codecCb_->onMessageBegin(handler[i].txn_->getID(), resp.get());
    codecCb_->onHeadersComplete(handler[i].txn_->getID(), std::move(resp));
  }

  codecCb_->onGoaway(numTxns * 2 + 1, ErrorCode::NO_ERROR);
  for (unsigned i = 0; i < numTxns; ++i) {
    handler[i].expectEOM();
    handler[i].expectDetachTransaction();
    codecCb_->onMessageComplete(i*2 + 1, false);
  }
  eventBase_.loop();

  // Session will delete itself after drain completes
}

TEST_F	(	MockHTTPUpstreamTest	,
		GoawayPreHeaders
	)

Definition at line 2025 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::append(), ASSERT_TRUE, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, proxygen::MockHTTPHandler::expectDetachTransaction(), proxygen::MockHTTPHandler::expectEOM(), proxygen::MockHTTPHandler::expectHeaders(), proxygen::MockHTTPHandler::expectTransaction(), proxygen::HTTPTransaction::getID(), handler(), testing::Invoke(), proxygen::makeResponse(), folly::gen::move, proxygen::HTTPHandlerBase::sendRequest(), string, proxygen::HTTPHandlerBase::txn_, and fizz::detail::writeBuf().

                                               {
  // Make sure existing txns complete successfully even if we drain the
  // upstream session
  MockHTTPHandler handler;

  InSequence enforceOrder;

  handler.expectTransaction();
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _))
      .WillOnce(Invoke(
          [&](IOBufQueue& writeBuf,
              HTTPCodec::StreamID /*stream*/,
              const HTTPMessage& /*msg*/,
              bool /*eom*/,
              HTTPHeaderSize* /*size*/) { writeBuf.append("HEADERS", 7); }));
  handler.expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  httpSession_->newTransaction(&handler);
  httpSession_->drain();

  // Send the GET request
  handler.sendRequest();

  // Receive 200 OK
  auto resp = makeResponse(200);
  codecCb_->onMessageBegin(handler.txn_->getID(), resp.get());
  codecCb_->onHeadersComplete(handler.txn_->getID(), std::move(resp));

  codecCb_->onGoaway(1, ErrorCode::NO_ERROR);
  handler.expectEOM();
  handler.expectDetachTransaction();
  codecCb_->onMessageComplete(1, false);
  eventBase_.loop();

  auto buf = writes_.move();
  ASSERT_TRUE(buf != nullptr);
  EXPECT_EQ(buf->moveToFbString().data(), string("HEADERSGOAWAY"));
  // Session will delete itself after drain completes
}

TEST_F	(	MockHTTPUpstreamTest	,
		NoWindowUpdateOnDrain
	)

Definition at line 2067 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::append(), dummy(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_LT, handler(), testing::Invoke(), makeBuf(), proxygen::makeResponse(), min, folly::gen::move, testing::Return(), streamID, string, uint32_t, and fizz::detail::writeBuf().

                                                    {
  EXPECT_CALL(*codecPtr_, supportsStreamFlowControl())
    .WillRepeatedly(Return(true));

  auto handler = openTransaction();

  handler->sendRequest();
  httpSession_->drain();
  auto streamID = handler->txn_->getID();

  EXPECT_CALL(*handler, onGoaway(ErrorCode::NO_ERROR));
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  EXPECT_CALL(*handler, onBody(_))
    .Times(3);
  handler->expectEOM();

  handler->expectDetachTransaction();

  uint32_t outstanding = 0;
  uint32_t sendWindow = 65536;
  uint32_t toSend = sendWindow * 1.55;

  // We'll get exactly one window update because we are draining
  EXPECT_CALL(*codecPtr_, generateWindowUpdate(_, _, _))
      .WillOnce(Invoke([&](folly::IOBufQueue& writeBuf,
                           HTTPCodec::StreamID /*stream*/,
                           uint32_t delta) {
        EXPECT_EQ(delta, sendWindow);
        outstanding -= delta;
        uint32_t len = std::min(toSend, sendWindow - outstanding);
        EXPECT_LT(len, sendWindow);
        toSend -= len;
        EXPECT_EQ(toSend, 0);
        eventBase_.tryRunAfterDelay(
            [this, streamID, len] {
              failWrites_ = true;
              auto respBody = makeBuf(len);
              codecCb_->onBody(streamID, std::move(respBody), 0);
              codecCb_->onMessageComplete(streamID, false);
            },
            50);

        const std::string dummy("window");
        writeBuf.append(dummy);
        return 6;
      }));

  codecCb_->onGoaway(streamID, ErrorCode::NO_ERROR);
  auto resp = makeResponse(200);
  codecCb_->onMessageBegin(streamID, resp.get());
  codecCb_->onHeadersComplete(streamID, std::move(resp));

  // While there is room and the window and body to send
  while (sendWindow - outstanding > 0 && toSend > 0) {
    // Send up to a 36k chunk
    uint32_t len = std::min(toSend, uint32_t(36000));
    // limited by the available window
    len = std::min(len, sendWindow - outstanding);
    auto respBody = makeBuf(len);
    toSend -= len;
    outstanding += len;
    codecCb_->onBody(streamID, std::move(respBody), 0);
  }

  eventBase_.loop();
}

TEST_F	(	MockHTTPUpstreamTest	,
		GetWithBody
	)

Definition at line 2137 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_CONTENT_LENGTH, makeBuf(), and proxygen::HTTPHeaders::set().

                                          {
  // Should be allowed to send a GET request with body.
  NiceMock<MockHTTPHandler> handler;
  HTTPMessage req = getGetRequest();
  req.getHeaders().set(HTTP_HEADER_CONTENT_LENGTH, "10");

  InSequence enforceOrder;

  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _));
  EXPECT_CALL(*codecPtr_, generateBody(_, _, _, _, true));

  auto txn = httpSession_->newTransaction(&handler);
  txn->sendHeaders(req);
  txn->sendBody(makeBuf(10));
  txn->sendEOM();

  eventBase_.loop();
  httpSession_->dropConnection();
}

TEST_F	(	MockHTTPUpstreamTest	,
		HeaderWithEom
	)

Definition at line 2157 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_TRUE, proxygen::getGetRequest(), and handler().

                                            {
  NiceMock<MockHTTPHandler> handler;
  HTTPMessage req = getGetRequest();
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, true, _));

  auto txn = httpSession_->newTransaction(&handler);
  txn->sendHeadersWithEOM(req);
  eventBase_.loop();
  EXPECT_TRUE(txn->isEgressComplete());
  httpSession_->dropConnection();
}

TEST_F	(	TestAbortPost1	,
		Test
	)

Definition at line 2265 of file HTTPUpstreamSessionTest.cpp.

{ doAbortTest(); }

TEST_F	(	TestAbortPost2	,
		Test
	)

Definition at line 2266 of file HTTPUpstreamSessionTest.cpp.

{ doAbortTest(); }

TEST_F	(	TestAbortPost3	,
		Test
	)

Definition at line 2267 of file HTTPUpstreamSessionTest.cpp.

{ doAbortTest(); }

TEST_F	(	TestAbortPost4	,
		Test
	)

Definition at line 2268 of file HTTPUpstreamSessionTest.cpp.

{ doAbortTest(); }

TEST_F	(	TestAbortPost5	,
		Test
	)

Definition at line 2269 of file HTTPUpstreamSessionTest.cpp.

{ doAbortTest(); }

TEST_F	(	MockHTTPUpstreamTest	,
		AbortUpgrade
	)

Definition at line 2271 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::getPostRequest(), handler(), makeBuf(), proxygen::makeResponse(), folly::gen::move, and streamID.

                                           {
  // This is basically the same test as above, just for the upgrade path
  InSequence enforceOrder;
  StrictMock<MockHTTPHandler> handler;
  HTTPMessage req = getPostRequest(10);

  std::unique_ptr<HTTPMessage> resp = makeResponse(200);

  handler.expectTransaction();
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _));

  auto txn = httpSession_->newTransaction(&handler);
  const auto streamID = txn->getID();
  txn->sendHeaders(req);
  txn->sendBody(makeBuf(5)); // only send half the body

  handler.expectHeaders();
  codecCb_->onHeadersComplete(streamID, std::move(resp));

  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID, _));
  handler.expectDetachTransaction();
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID,
                                            ErrorCode::_SPDY_INVALID_STREAM));
  txn->sendAbort();
  codecCb_->onMessageComplete(streamID, true); // upgrade
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID,
                                            ErrorCode::_SPDY_INVALID_STREAM));
  codecCb_->onMessageComplete(streamID, false); // eom

  eventBase_.loop();
}

TEST_F	(	MockHTTPUpstreamTest	,
		DrainBeforeSendHeaders
	)

Definition at line 2303 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, handler(), and proxygen::makeResponse().

                                                     {
  // Test that drain on session before sendHeaders() is called on open txn

  InSequence enforceOrder;
  MockHTTPHandler pushHandler;

  auto handler = openTransaction();
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _));

  handler->expectHeaders();
  handler->expectEOM();
  handler->expectDetachTransaction();

  httpSession_->drain();
  handler->sendRequest();
  codecCb_->onHeadersComplete(handler->txn_->getID(), makeResponse(200));
  codecCb_->onMessageComplete(handler->txn_->getID(), false); // eom

  eventBase_.loop();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ReceiveDoubleGoaway
	)

Definition at line 2324 of file HTTPUpstreamSessionTest.cpp.

References testing::_, ASSERT_EQ, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::Exception::getProxygenError(), proxygen::Exception::hasProxygenError(), proxygen::kErrorStreamUnacknowledged, string, and proxygen::Exception::what().

                                                   {
  // Test that we handle receiving two goaways correctly

  InSequence enforceOrder;
  auto req = getGetRequest();

  // Open 2 txns but doesn't send headers yet
  auto handler1 = openTransaction();
  auto handler2 = openTransaction();

  // Get first goaway acking many un-started txns
  handler1->expectGoaway();
  handler2->expectGoaway();
  codecCb_->onGoaway(101, ErrorCode::NO_ERROR);

  // This txn should be alive since it was ack'd by the above goaway
  handler1->txn_->sendHeaders(req);

  // Second goaway acks the only the current outstanding transaction
  handler1->expectGoaway();
  handler2->expectGoaway();
  handler2->expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      EXPECT_EQ(err.getProxygenError(), kErrorStreamUnacknowledged);
      ASSERT_EQ(
        folly::to<std::string>("StreamUnacknowledged on transaction id: ",
                               handler2->txn_->getID()),
        std::string(err.what()));
    });
  handler2->expectDetachTransaction();
  codecCb_->onGoaway(handler1->txn_->getID(), ErrorCode::NO_ERROR);

  // Clean up
  httpSession_->drain();
  EXPECT_CALL(*codecPtr_, generateRstStream(_, handler1->txn_->getID(), _));
  handler1->expectDetachTransaction();
  handler1->txn_->sendAbort();
  eventBase_.loop();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ServerPushInvalidAssoc
	)

Definition at line 2364 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::getGetRequest(), handler(), proxygen::makeResponse(), folly::gen::move, and streamID.

                                                      {
  // Test that protocol error is generated on server push
  // with invalid assoc stream id
  InSequence enforceOrder;
  auto req = getGetRequest();
  auto handler = openTransaction();

  int streamID = handler->txn_->getID();
  int pushID = streamID + 1;
  int badAssocID = streamID + 2;

  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::PROTOCOL_ERROR));
  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::_SPDY_INVALID_STREAM))
    .Times(2);

  auto resp = makeResponse(200);
  codecCb_->onPushMessageBegin(pushID, badAssocID, resp.get());
  codecCb_->onHeadersComplete(pushID, std::move(resp));
  codecCb_->onMessageComplete(pushID, false);

  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();

  resp = makeResponse(200);
  codecCb_->onMessageBegin(streamID, resp.get());
  codecCb_->onHeadersComplete(streamID, std::move(resp));
  codecCb_->onMessageComplete(streamID, false);

  // Cleanup
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID, _));
  EXPECT_CALL(*handler, detachTransaction());
  handler->terminate();

  EXPECT_TRUE(!httpSession_->hasActiveTransactions());
  httpSession_->destroy();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ServerPushAfterFin
	)

Definition at line 2406 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::getGetRequest(), handler(), testing::InvokeWithoutArgs(), proxygen::makeResponse(), folly::gen::move, and streamID.

                                                  {
  // Test that protocol error is generated on server push
  // after FIN is received on regular response on the stream
  InSequence enforceOrder;
  auto req = getGetRequest();
  auto handler = openTransaction();

  int streamID = handler->txn_->getID();
  int pushID = streamID + 1;

  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();

  auto resp = makeResponse(200);
  codecCb_->onMessageBegin(streamID, resp.get());
  codecCb_->onHeadersComplete(streamID, std::move(resp));
  codecCb_->onMessageComplete(streamID, false);

  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::PROTOCOL_ERROR))
    .WillOnce(InvokeWithoutArgs([this] {
            // Verify that the assoc txn is still present
            EXPECT_TRUE(httpSession_->hasActiveTransactions());
            return 1;
          }));
  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::_SPDY_INVALID_STREAM))
    .Times(2);

  resp = makeResponse(200);
  codecCb_->onPushMessageBegin(pushID, streamID, resp.get());
  codecCb_->onHeadersComplete(pushID, std::move(resp));
  codecCb_->onMessageComplete(pushID, false);

  // Cleanup
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID, _));
  EXPECT_CALL(*handler, detachTransaction());
  handler->terminate();

  EXPECT_TRUE(!httpSession_->hasActiveTransactions());
  httpSession_->destroy();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ServerPushHandlerInstallFail
	)

Definition at line 2452 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::getGetRequest(), handler(), testing::Invoke(), folly::gen::move, proxygen::HTTPTransaction::setHandler(), and streamID.

                                                            {
  // Test that REFUSED_STREAM error is generated when the session
  // fails to install the server push handler
  InSequence enforceOrder;
  auto req = getGetRequest();
  auto handler = openTransaction();

  int streamID = handler->txn_->getID();
  int pushID = streamID + 1;

  EXPECT_CALL(*handler, onPushedTransaction(_))
    .WillOnce(Invoke([] (HTTPTransaction* txn) {
            // Intentionally unset the handler on the upstream push txn
            txn->setHandler(nullptr);
          }));
  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::REFUSED_STREAM));
  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::_SPDY_INVALID_STREAM))
    .Times(2);

  auto resp = std::make_unique<HTTPMessage>();
  resp->setStatusCode(200);
  resp->setStatusMessage("OK");
  codecCb_->onPushMessageBegin(pushID, streamID, resp.get());
  codecCb_->onHeadersComplete(pushID, std::move(resp));
  codecCb_->onMessageComplete(pushID, false);

  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ(200, msg->getStatusCode());
    });
  handler->expectEOM();

  resp = std::make_unique<HTTPMessage>();
  resp->setStatusCode(200);
  resp->setStatusMessage("OK");
  codecCb_->onMessageBegin(streamID, resp.get());
  codecCb_->onHeadersComplete(streamID, std::move(resp));
  codecCb_->onMessageComplete(streamID, false);

  // Cleanup
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID, _));
  EXPECT_CALL(*handler, detachTransaction());
  handler->terminate();

  EXPECT_TRUE(!httpSession_->hasActiveTransactions());
  httpSession_->destroy();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		ServerPushUnhandledAssoc
	)

Definition at line 2502 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_TRUE, proxygen::getGetRequest(), handler(), folly::gen::move, and streamID.

                                                        {
  // Test that REFUSED_STREAM error is generated when the assoc txn
  // is unhandled
  InSequence enforceOrder;
  auto req = getGetRequest();
  auto handler = openTransaction();

  int streamID = handler->txn_->getID();
  int pushID = streamID + 1;

  // Forcefully unset the handler on the assoc txn
  handler->txn_->setHandler(nullptr);

  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::REFUSED_STREAM));
  EXPECT_CALL(*codecPtr_,
              generateRstStream(_, pushID, ErrorCode::_SPDY_INVALID_STREAM))
    .Times(2);

  auto resp = std::make_unique<HTTPMessage>();
  resp->setStatusCode(200);
  resp->setStatusMessage("OK");
  codecCb_->onPushMessageBegin(pushID, streamID, resp.get());
  codecCb_->onHeadersComplete(pushID, std::move(resp));
  codecCb_->onMessageComplete(pushID, false);

  // Cleanup
  EXPECT_CALL(*codecPtr_, generateRstStream(_, streamID, _));
  handler->terminate();

  EXPECT_TRUE(!httpSession_->hasActiveTransactions());
  httpSession_->destroy();
}

TEST_F	(	MockHTTPUpstreamTest	,
		HeadersThenBodyThenHeaders
	)

Definition at line 2536 of file HTTPUpstreamSessionTest.cpp.

References testing::_, ASSERT_EQ, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorIngressStateTransition, makeBuf(), proxygen::makeResponse(), folly::gen::move, string, and proxygen::Exception::what().

                                                         {
  HTTPMessage req = getGetRequest();
  auto handler = openTransaction();
  handler->txn_->sendHeaders(req);

  handler->expectHeaders();
  EXPECT_CALL(*handler, onBody(_));
  // After getting the second headers, transaction will detach the handler
  handler->expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      EXPECT_EQ(err.getProxygenError(), kErrorIngressStateTransition);
      ASSERT_EQ("Invalid ingress state transition, state=RegularBodyReceived, "
                "event=onHeaders, streamID=1",
                std::string(err.what()));
    });
  handler->expectDetachTransaction();
  auto resp = makeResponse(200);
  codecCb_->onMessageBegin(1, resp.get());
  codecCb_->onHeadersComplete(1, std::move(resp));
  codecCb_->onBody(1, makeBuf(20), 0);
  // Now receive headers again, on the same stream (illegal!)
  codecCb_->onHeadersComplete(1, makeResponse(200));
  eventBase_.loop();
}

TEST_F	(	MockHTTP2UpstreamTest	,
		DelayUpstreamWindowUpdate
	)

Definition at line 2561 of file HTTPUpstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::getGetRequest(), handler(), and testing::Return().

                                                         {
  EXPECT_CALL(*codecPtr_, supportsStreamFlowControl())
    .WillRepeatedly(Return(true));

  auto handler = openTransaction();
  handler->txn_->setReceiveWindow(1000000); // One miiiillion

  InSequence enforceOrder;
  EXPECT_CALL(*codecPtr_, generateHeader(_, _, _, _, _));
  EXPECT_CALL(*codecPtr_, generateWindowUpdate(_, _, _));

  HTTPMessage req = getGetRequest();
  handler->txn_->sendHeaders(req);
  handler->expectDetachTransaction();
  handler->txn_->sendAbort();
  httpSession_->destroy();
}

TEST_F	(	MockHTTPUpstreamTest	,
		ForceShutdownInSetTransaction
	)

Definition at line 2579 of file HTTPUpstreamSessionTest.cpp.

References ASSERT_EQ, EXPECT_EQ, EXPECT_TRUE, proxygen::Exception::getProxygenError(), handler(), proxygen::Exception::hasProxygenError(), proxygen::kErrorDropped, string, and proxygen::Exception::what().

                                                            {
  StrictMock<MockHTTPHandler> handler;
  handler.expectTransaction([&] (HTTPTransaction* txn) {
      handler.txn_ = txn;
      httpSession_->dropConnection();
    });
  handler.expectError([&] (const HTTPException& err) {
      EXPECT_TRUE(err.hasProxygenError());
      EXPECT_EQ(err.getProxygenError(), kErrorDropped);
      ASSERT_EQ(folly::to<std::string>("Dropped on transaction id: ",
                                       handler.txn_->getID()),
        std::string(err.what()));
    });
  handler.expectDetachTransaction();
  (void)httpSession_->newTransaction(&handler);
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestReplaySafetyCallback
	)

Definition at line 2596 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_CALL, ON_CALL, testing::Return(), and transport_.

                                                           {
  auto sock = dynamic_cast<HTTPTransaction::Transport*>(httpSession_);

  StrictMock<folly::test::MockReplaySafetyCallback> cb1;
  StrictMock<folly::test::MockReplaySafetyCallback> cb2;
  StrictMock<folly::test::MockReplaySafetyCallback> cb3;

  EXPECT_CALL(*transport_, isReplaySafe())
    .WillRepeatedly(Return(false));
  sock->addWaitingForReplaySafety(&cb1);
  sock->addWaitingForReplaySafety(&cb2);
  sock->addWaitingForReplaySafety(&cb3);
  sock->removeWaitingForReplaySafety(&cb2);

  ON_CALL(*transport_, isReplaySafe())
    .WillByDefault(Return(true));
  EXPECT_CALL(cb1, onReplaySafe_());
  EXPECT_CALL(cb3, onReplaySafe_());
  replaySafetyCallback_->onReplaySafe();

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestAlreadyReplaySafe
	)

Definition at line 2619 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_CALL, testing::Return(), and transport_.

                                                        {
  auto sock = dynamic_cast<HTTPTransaction::Transport*>(httpSession_);

  StrictMock<folly::test::MockReplaySafetyCallback> cb;

  EXPECT_CALL(*transport_, isReplaySafe())
    .WillRepeatedly(Return(true));
  EXPECT_CALL(cb, onReplaySafe_());
  sock->addWaitingForReplaySafety(&cb);

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		TestChainedBufIngress
	)

Definition at line 2632 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, and folly::gen::move.

                                                        {
  auto buf = folly::IOBuf::copyBuffer("hi");
  buf->prependChain(folly::IOBuf::copyBuffer("hello"));

  MockHTTPSessionInfoCallback infoCb;
  this->httpSession_->setInfoCallback(&infoCb);

  EXPECT_CALL(infoCb, onRead(_, 7));
  readCallback_->readBufferAvailable(std::move(buf));

  httpSession_->destroy();
}

TEST_F	(	HTTP2UpstreamSessionTest	,
		AttachDetach
	)

Definition at line 2645 of file HTTPUpstreamSessionTest.cpp.

References folly::IOBufQueue::cacheChainLength(), folly::HHWheelTimer::DEFAULT_TICK_INTERVAL, EXPECT_EQ, handler(), i, folly::TimeoutManager::INTERNAL, folly::EventBase::loopOnce(), makeBuf(), makeServerCodec(), folly::IOBufQueue::move(), folly::HHWheelTimer::newTimer(), gmock_output_test::output, REGISTER_TYPED_TEST_CASE_P(), proxygen::HTTPMessage::setStatusCode(), and uint64_t.

                                               {
  folly::EventBase base;
  auto timer =
    folly::HHWheelTimer::newTimer(
      &base,
      std::chrono::milliseconds(folly::HHWheelTimer::DEFAULT_TICK_INTERVAL),
      TimeoutManager::InternalEnum::INTERNAL, std::chrono::milliseconds(500));
  WheelTimerInstance timerInstance(timer.get());
  uint64_t filterCount = 0;
  auto fn = [&filterCount](HTTPCodecFilter* /*filter*/) { filterCount++; };

  InSequence enforceOrder;
  auto egressCodec = makeServerCodec();
  folly::IOBufQueue output(folly::IOBufQueue::cacheChainLength());
  egressCodec->generateConnectionPreface(output);
  egressCodec->generateSettings(output);

  for (auto i = 0; i < 2; i++) {
    auto handler = openTransaction();
    handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
        EXPECT_EQ(200, msg->getStatusCode());
      });
    handler->expectBody();
    handler->expectEOM();
    handler->expectDetachTransaction();

    HTTPMessage resp;
    resp.setStatusCode(200);
    egressCodec->generateHeader(output, handler->txn_->getID(), resp);
    egressCodec->generateBody(output, handler->txn_->getID(), makeBuf(20),
                              HTTPCodec::NoPadding, true /* eom */);

    handler->sendRequest();
    auto buf = output.move();
    buf->coalesce();
    readAndLoop(buf.get());

    httpSession_->detachThreadLocals();
    httpSession_->attachThreadLocals(&base, nullptr, timerInstance, nullptr, fn,
                                     nullptr, nullptr);
    EXPECT_EQ(filterCount, 2);
    filterCount = 0;
    base.loopOnce();
  }
  httpSession_->destroy();
}

TYPED_TEST_CASE_P

(

HTTPUpstreamTest

)

TYPED_TEST_P	(	HTTPUpstreamTest	,
		ImmediateEof
	)

Definition at line 1020 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ.

                                             {
  // Receive an EOF without any request data
  this->readCallback_->readEOF();
  this->eventBase_.loop();
  EXPECT_EQ(this->sessionDestroyed_, true);
}