HTTPDownstreamSessionTest.cpp File Reference

#include <string>
#include <vector>
#include <folly/Conv.h>
#include <folly/Range.h>
#include <folly/futures/Promise.h>
#include <folly/io/Cursor.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/io/async/TimeoutManager.h>
#include <folly/io/async/test/MockAsyncTransport.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/codec/HTTPCodecFactory.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <proxygen/lib/http/session/HTTPDirectResponseHandler.h>
#include <proxygen/lib/http/session/HTTPDownstreamSession.h>
#include <proxygen/lib/http/session/HTTPSession.h>
#include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
#include <proxygen/lib/http/session/test/HTTPSessionTest.h>
#include <proxygen/lib/http/session/test/MockByteEventTracker.h>
#include <proxygen/lib/http/session/test/TestUtils.h>
#include <proxygen/lib/test/TestAsyncTransport.h>
#include <wangle/acceptor/ConnectionManager.h>

Go to the source code of this file.

Classes
class	HTTPDownstreamTest< C >
class	HTTPDownstreamSessionUpgradeFlowControlTest
class	SPDY31DownstreamTest

Macros
#define	IF_HTTP2(X)   if (this->clientCodec_->getProtocol() == CodecProtocol::HTTP_2) { X; }

Typedefs
using	HTTPDownstreamSessionTest = HTTPDownstreamTest< HTTP1xCodecPair >
using	SPDY3DownstreamSessionTest = HTTPDownstreamTest< SPDY3CodecPair >
typedef ::testing::Types< SPDY3CodecPair, SPDY3_1CodecPair, HTTP2CodecPair >	ParallelCodecs

Functions
	TEST_F (HTTP2DownstreamSessionEarlyShutdownTest, EarlyShutdown)
	TEST_F (HTTPDownstreamSessionTest, ImmediateEof)
	TEST_F (HTTPDownstreamSessionTest, Http10NoHeaders)
	TEST_F (HTTPDownstreamSessionTest, Http10NoHeadersEof)
	TEST_F (HTTPDownstreamSessionTest, SingleBytes)
	TEST_F (HTTPDownstreamSessionTest, SingleBytesWithBody)
	TEST_F (HTTPDownstreamSessionTest, SplitBody)
	TEST_F (HTTPDownstreamSessionTest, PostChunked)
	TEST_F (HTTPDownstreamSessionTest, MultiMessage)
	TEST_F (HTTPDownstreamSessionTest, Connect)
	TEST_F (HTTPDownstreamSessionTest, ConnectRejected)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgrade)
	TEST (HTTPDownstreamTest, ParseErrorNoTxn)
	TEST (HTTPDownstreamTest, ByteEventsDrained)
	TEST_F (HTTPDownstreamSessionTest, HttpWithAckTiming)
	TEST_F (HTTPDownstreamSessionTest, TestOnContentMismatch)
	TEST_F (HTTPDownstreamSessionTest, HttpWithAckTimingPipeline)
	TEST_F (HTTP2DownstreamSessionTest, ExheaderFromServer)
	TEST_F (HTTP2DownstreamSessionTest, ExheaderFromClient)
	TEST_F (HTTP2DownstreamSessionTest, UnidirectionalExTransaction)
	TEST_F (HTTP2DownstreamSessionTest, PauseResumeControlStream)
	TEST_F (HTTP2DownstreamSessionTest, InvalidControlStream)
	TEST_F (HTTP2DownstreamSessionTest, SetByteEventTracker)
	TEST_F (HTTPDownstreamSessionTest, TestTrackedByteEventTracker)
	TEST_F (HTTP2DownstreamSessionTest, Trailers)
	TEST_F (HTTPDownstreamSessionTest, Trailers)
	TEST_F (HTTPDownstreamSessionTest, ExplicitChunks)
	TEST_F (HTTPDownstreamSessionTest, HttpDrain)
	TEST_F (HTTPDownstreamSessionTest, HttpDrainLongRunning)
	TEST_F (HTTPDownstreamSessionTest, EarlyAbort)
	TEST_F (SPDY3DownstreamSessionTest, HttpPausedBuffered)
	TEST_F (HTTPDownstreamSessionTest, HttpWritesDrainingTimeout)
	TEST_F (HTTPDownstreamSessionTest, HttpRateLimitNormal)
	TEST_F (SPDY3DownstreamSessionTest, SpdyRateLimitNormal)
	TEST_F (SPDY3DownstreamSessionTest, SpdyRateLimitRst)
	TEST_F (HTTPDownstreamSessionTest, WriteTimeout)
	TEST_F (HTTPDownstreamSessionTest, WriteTimeoutPipeline)
	TEST_F (HTTPDownstreamSessionTest, BodyPacketization)
	TEST_F (HTTPDownstreamSessionTest, HttpMalformedPkt1)
	TEST_F (HTTPDownstreamSessionTest, BigExplcitChunkWrite)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNonNative)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNonNativeIgnore)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNonNativePipeline)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNative3)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNative31)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeH2)
	TEST_F (HTTPDownstreamSessionUpgradeFlowControlTest, UpgradeH2Flowcontrol)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeUnknown)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeWhitespace)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeJunk)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeTxn2)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativePost)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativePostEarlyResp)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativePostEarlyPartialResp)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativeExtra)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativePost100)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeNativePost100Late)
	TEST_F (SPDY3DownstreamSessionTest, SpdyPrio)
	TEST_F (HTTPDownstreamSessionTest, HttpUpgradeGoawayDrain)
	TEST_F (SPDY3DownstreamSessionTest, SpdyTimeout)
	TEST_F (SPDY3DownstreamSessionTest, SpdyTimeoutWin)
	TYPED_TEST_CASE_P (HTTPDownstreamTest)
	TYPED_TEST_P (HTTPDownstreamTest, TestWritesDraining)
	TYPED_TEST_P (HTTPDownstreamTest, TestBodySizeLimit)
	TYPED_TEST_P (HTTPDownstreamTest, TestUniformPauseState)
	TYPED_TEST_P (HTTPDownstreamTest, TestMaxTxns)
	TEST_F (SPDY3DownstreamSessionTest, SpdyMaxConcurrentStreams)
	REGISTER_TYPED_TEST_CASE_P (HTTPDownstreamTest, TestWritesDraining, TestBodySizeLimit, TestUniformPauseState, TestMaxTxns)
	INSTANTIATE_TYPED_TEST_CASE_P (ParallelCodecs, HTTPDownstreamTest, ParallelCodecs)
	TEST_F (SPDY31DownstreamTest, TestSessionFlowControl)
	TEST_F (SPDY3DownstreamSessionTest, TestEOFOnBlockedStream)
	TEST_F (SPDY31DownstreamTest, TestEOFOnBlockedSession)
	TEST_F (SPDY3DownstreamSessionTest, NewTxnEgressPaused)
	TEST_F (HTTP2DownstreamSessionTest, ZeroDeltaWindowUpdate)
	TEST_F (HTTP2DownstreamSessionTest, PaddingFlowControl)
	TEST_F (HTTP2DownstreamSessionTest, GracefulDrainOnTimeout)
	TEST_F (HTTP2DownstreamSessionTest, ServerPush)
	TEST_F (HTTP2DownstreamSessionTest, ServerPushAbortPaused)
	TEST_F (HTTP2DownstreamSessionTest, TestPriorityWeightsTinyRatio)
	TEST_F (HTTP2DownstreamSessionTest, TestPriorityDependentTransactions)
	TEST_F (HTTP2DownstreamSessionTest, TestDisablePriorities)
	TEST_F (HTTP2DownstreamSessionTest, TestPriorityWeights)
	TEST_F (HTTP2DownstreamSessionTest, TestPriorityWeightsTinyWindow)
	TEST_F (HTTP2DownstreamSessionTest, TestShortContentLength)
	TEST_F (HTTP2DownstreamSessionTest, TestBadContentLengthUntieHandler)
	TEST_F (HTTP2DownstreamSessionTest, TestLongContentLength)
	TEST_F (HTTP2DownstreamSessionTest, TestMalformedContentLength)
	TEST_F (HTTP2DownstreamSessionTest, TestHeadContentLength)
	TEST_F (HTTP2DownstreamSessionTest, Test304ContentLength)
	TEST_F (HTTPDownstreamSessionTest, HttpShortContentLength)
	TEST_F (HTTP2DownstreamSessionTest, TestSessionStallByFlowControl)
	TEST_F (HTTP2DownstreamSessionTest, TestTransactionStallByFlowControl)
	TEST_F (HTTP2DownstreamSessionTest, TestTransactionNotStallByFlowControl)
	TEST_F (HTTP2DownstreamSessionTest, TestSetEgressSettings)

Macro Definition Documentation

#define IF_HTTP2

(

X

)

if (this->clientCodec_->getProtocol() == CodecProtocol::HTTP_2) { X; }

Definition at line 2359 of file HTTPDownstreamSessionTest.cpp.

Referenced by TYPED_TEST_P().

Typedef Documentation

using HTTPDownstreamSessionTest = HTTPDownstreamTest<HTTP1xCodecPair>

Definition at line 436 of file HTTPDownstreamSessionTest.cpp.

typedef ::testing::Types<SPDY3CodecPair, SPDY3_1CodecPair, HTTP2CodecPair> ParallelCodecs

Definition at line 2517 of file HTTPDownstreamSessionTest.cpp.

using SPDY3DownstreamSessionTest = HTTPDownstreamTest<SPDY3CodecPair>

Definition at line 437 of file HTTPDownstreamSessionTest.cpp.

Function Documentation

INSTANTIATE_TYPED_TEST_CASE_P	(	ParallelCodecs	,
		HTTPDownstreamTest	,
		ParallelCodecs
	)

REGISTER_TYPED_TEST_CASE_P	(	HTTPDownstreamTest	,
		TestWritesDraining	,
		TestBodySizeLimit	,
		TestUniformPauseState	,
		TestMaxTxns
	)

Referenced by TEST_F().

TEST	(	HTTPDownstreamTest	,
		ParseErrorNoTxn
	)

Definition at line 802 of file HTTPDownstreamSessionTest.cpp.

References testing::_, testing::Assign(), codec, EXPECT_CALL, testing::Invoke(), proxygen::kErrorParseHeader, proxygen::localAddr, folly::EventBase::loop(), proxygen::makeDownstreamParallelCodec(), proxygen::makeInternalTimeoutSet(), proxygen::mockTransportInfo, folly::gen::move, proxygen::newMockTransport(), proxygen::HTTPCodec::Callback::onError(), proxygen::peerAddr, proxygen::HTTPException::setCodecStatusCode(), proxygen::Exception::setProxygenError(), proxygen::HTTPDownstreamSession::startNow(), and folly::AsyncWriter::WriteCallback::writeSuccess().

                                          {
  // 1) Get a parse error on SYN_STREAM for streamID == 1
  // 2) Expect that the codec should be asked to generate an abort on
  //    streamID==1
  EventBase evb;

  // Setup the controller and its expecations.
  NiceMock<MockController> mockController;

  // Setup the codec, its callbacks, and its expectations.
  auto codec = makeDownstreamParallelCodec();
  HTTPCodec::Callback* codecCallback = nullptr;
  EXPECT_CALL(*codec, setCallback(_))
    .WillRepeatedly(SaveArg<0>(&codecCallback));
  // Expect egress abort for streamID == 1
  EXPECT_CALL(*codec, generateRstStream(_, 1, _));

  // Setup transport
  bool transportGood = true;
  auto transport = newMockTransport(&evb);
  EXPECT_CALL(*transport, good())
    .WillRepeatedly(ReturnPointee(&transportGood));
  EXPECT_CALL(*transport, closeNow())
    .WillRepeatedly(Assign(&transportGood, false));
  EXPECT_CALL(*transport, writeChain(_, _, _))
    .WillRepeatedly(
      Invoke([&] (folly::AsyncTransportWrapper::WriteCallback* callback,
                  const shared_ptr<IOBuf>&, WriteFlags) {
               callback->writeSuccess();
             }));

  // Create the downstream session, thus initializing codecCallback
  auto transactionTimeouts = makeInternalTimeoutSet(&evb);
  auto session = new HTTPDownstreamSession(
    transactionTimeouts.get(),
    AsyncTransportWrapper::UniquePtr(transport),
    localAddr, peerAddr,
    &mockController, std::move(codec),
    mockTransportInfo,
    nullptr);
  session->startNow();
  HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, "foo");
  ex.setProxygenError(kErrorParseHeader);
  ex.setCodecStatusCode(ErrorCode::REFUSED_STREAM);
  codecCallback->onError(HTTPCodec::StreamID(1), ex, true);

  // cleanup
  session->dropConnection();
  evb.loop();
}

TEST	(	HTTPDownstreamTest	,
		ByteEventsDrained
	)

Definition at line 853 of file HTTPDownstreamSessionTest.cpp.

References testing::AtLeast(), codec, EXPECT_CALL, proxygen::localAddr, folly::EventBase::loop(), proxygen::makeDownstreamParallelCodec(), proxygen::makeInternalTimeoutSet(), proxygen::mockTransportInfo, folly::gen::move, proxygen::newMockTransport(), proxygen::peerAddr, and proxygen::HTTPSession::setByteEventTracker().

                                            {
  // Test that byte events are drained before socket is closed
  EventBase evb;

  NiceMock<MockController> mockController;
  auto codec = makeDownstreamParallelCodec();
  auto byteEventTracker = new MockByteEventTracker(nullptr);
  auto transport = newMockTransport(&evb);
  auto transactionTimeouts = makeInternalTimeoutSet(&evb);

  // Create the downstream session
  auto session = new HTTPDownstreamSession(
    transactionTimeouts.get(),
    AsyncTransportWrapper::UniquePtr(transport),
    localAddr, peerAddr,
    &mockController, std::move(codec),
    mockTransportInfo,
    nullptr);
  session->setByteEventTracker(
      std::unique_ptr<ByteEventTracker>(byteEventTracker));

  InSequence enforceOrder;

  session->startNow();

  // Byte events should be drained first
  EXPECT_CALL(*byteEventTracker, drainByteEvents())
    .Times(1);
  EXPECT_CALL(*transport, closeNow())
    .Times(AtLeast(1));

  // Close the socket
  session->dropConnection();
  evb.loop();
}

TEST_F	(	HTTP2DownstreamSessionEarlyShutdownTest	,
		EarlyShutdown
	)

Definition at line 479 of file HTTPDownstreamSessionTest.cpp.

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

                                                               {
  folly::DelayedDestruction::DestructorGuard g(httpSession_);

  // Try shutting down the session and then starting it. This should be properly
  // handled by the HTTPSession such that no HTTP/2 frames are sent in the
  // wrong order.
  StrictMock<MockHTTPCodecCallback> callbacks;
  clientCodec_->setCallback(&callbacks);
  EXPECT_CALL(callbacks, onFrameHeader(_, _, _, _, _)).Times(2);
  EXPECT_CALL(callbacks, onSettings(_)).Times(1);
  EXPECT_CALL(callbacks, onGoaway(_, _, _)).Times(1);
  expectDetachSession();
  httpSession_->notifyPendingShutdown();
  httpSession_->startNow();
  eventBase_.loop();
  parseOutput(*clientCodec_);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		ImmediateEof
	)

Definition at line 497 of file HTTPDownstreamSessionTest.cpp.

References testing::_, and EXPECT_CALL.

                                                {
  // Send EOF without any request data
  EXPECT_CALL(mockController_, getRequestHandler(_, _)).Times(0);
  expectDetachSession();

  flushRequestsAndLoop(true, milliseconds(0));
}

TEST_F	(	HTTPDownstreamSessionTest	,
		Http10NoHeaders
	)

Definition at line 505 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, proxygen::getGetRequest(), and handler().

                                                   {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ("/", msg->getURL());
      EXPECT_EQ("/", msg->getPath());
      EXPECT_EQ("", msg->getQueryString());
      EXPECT_EQ(1, msg->getHTTPVersion().first);
      EXPECT_EQ(0, msg->getHTTPVersion().second);
    });
  onEOMTerminateHandlerExpectShutdown(*handler);

  auto req = getGetRequest();
  req.setHTTPVersion(1, 0);
  sendRequest(req);
  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		Http10NoHeadersEof
	)

Definition at line 526 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, and handler().

                                                      {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ("http://example.com/foo?bar", msg->getURL());
      EXPECT_EQ("/foo", msg->getPath());
      EXPECT_EQ("bar", msg->getQueryString());
      EXPECT_EQ(1, msg->getHTTPVersion().first);
      EXPECT_EQ(0, msg->getHTTPVersion().second);
    });
  onEOMTerminateHandlerExpectShutdown(*handler);

  const char *req = "GET http://example.com/foo?bar HTTP/1.0\r\n\r\n";
  requests_.append(req, strlen(req));
  flushRequestsAndLoop(true, milliseconds(0));
}

TEST_F	(	HTTPDownstreamSessionTest	,
		SingleBytes
	)

Definition at line 546 of file HTTPDownstreamSessionTest.cpp.

References proxygen::HTTPHeaders::exists(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, handler(), proxygen::HTTPHeaders::size(), and transport_.

                                               {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      const HTTPHeaders& hdrs = msg->getHeaders();
      EXPECT_EQ(2, hdrs.size());
      EXPECT_TRUE(hdrs.exists("host"));
      EXPECT_TRUE(hdrs.exists("connection"));

      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ("/somepath.php?param=foo", msg->getURL());
      EXPECT_EQ("/somepath.php", msg->getPath());
      EXPECT_EQ("param=foo", msg->getQueryString());
      EXPECT_EQ(1, msg->getHTTPVersion().first);
      EXPECT_EQ(1, msg->getHTTPVersion().second);
    });
  onEOMTerminateHandlerExpectShutdown(*handler);

  addSingleByteReads("GET /somepath.php?param=foo HTTP/1.1\r\n"
                     "Host: example.com\r\n"
                     "Connection: close\r\n"
                     "\r\n");
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		SingleBytesWithBody
	)

Definition at line 575 of file HTTPDownstreamSessionTest.cpp.

References testing::_, proxygen::HTTPHeaders::exists(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, handler(), proxygen::HTTPHeaders::size(), and transport_.

                                                       {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      const HTTPHeaders& hdrs = msg->getHeaders();
      EXPECT_EQ(3, hdrs.size());
      EXPECT_TRUE(hdrs.exists("host"));
      EXPECT_TRUE(hdrs.exists("content-length"));
      EXPECT_TRUE(hdrs.exists("myheader"));

      EXPECT_FALSE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ("/somepath.php?param=foo", msg->getURL());
      EXPECT_EQ("/somepath.php", msg->getPath());
      EXPECT_EQ("param=foo", msg->getQueryString());
      EXPECT_EQ(1, msg->getHTTPVersion().first);
      EXPECT_EQ(1, msg->getHTTPVersion().second);
    });
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("1"))
    .WillOnce(ExpectString("2"))
    .WillOnce(ExpectString("3"))
    .WillOnce(ExpectString("4"))
    .WillOnce(ExpectString("5"));
  onEOMTerminateHandlerExpectShutdown(*handler);

  addSingleByteReads("POST /somepath.php?param=foo HTTP/1.1\r\n"
                     "Host: example.com\r\n"
                     "MyHeader: FooBar\r\n"
                     "Content-Length: 5\r\n"
                     "\r\n"
                     "12345");
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		SplitBody
	)

Definition at line 613 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, handler(), proxygen::HTTPHeaders::size(), and transport_.

                                             {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      const HTTPHeaders& hdrs = msg->getHeaders();
      EXPECT_EQ(2, hdrs.size());
    });
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("12345"))
    .WillOnce(ExpectString("abcde"));
  onEOMTerminateHandlerExpectShutdown(*handler);

  transport_->addReadEvent("POST / HTTP/1.1\r\n"
                           "Host: example.com\r\n"
                           "Content-Length: 10\r\n"
                           "\r\n"
                           "12345", milliseconds(0));
  transport_->addReadEvent("abcde", milliseconds(5));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		PostChunked
	)

Definition at line 637 of file HTTPDownstreamSessionTest.cpp.

References testing::_, proxygen::HTTPHeaders::exists(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, handler(), proxygen::HTTPHeaders::size(), and transport_.

                                               {
  InSequence enforceOrder;

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&] (std::shared_ptr<HTTPMessage> msg) {
      const HTTPHeaders& hdrs = msg->getHeaders();
      EXPECT_EQ(3, hdrs.size());
      EXPECT_TRUE(hdrs.exists("host"));
      EXPECT_TRUE(hdrs.exists("content-type"));
      EXPECT_TRUE(hdrs.exists("transfer-encoding"));
      EXPECT_TRUE(msg->getIsChunked());
      EXPECT_FALSE(msg->getIsUpgraded());
      EXPECT_EQ("http://example.com/cgi-bin/foo.aspx?abc&def",
                msg->getURL());
      EXPECT_EQ("/cgi-bin/foo.aspx", msg->getPath());
      EXPECT_EQ("abc&def", msg->getQueryString());
      EXPECT_EQ(1, msg->getHTTPVersion().first);
      EXPECT_EQ(1, msg->getHTTPVersion().second);
    });
  EXPECT_CALL(*handler, onChunkHeader(3));
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("bar"));
  EXPECT_CALL(*handler, onChunkComplete());
  EXPECT_CALL(*handler, onChunkHeader(0x22));
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("0123456789abcdef\nfedcba9876543210\n"));
  EXPECT_CALL(*handler, onChunkComplete());
  EXPECT_CALL(*handler, onChunkHeader(3));
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("foo"));
  EXPECT_CALL(*handler, onChunkComplete());
  onEOMTerminateHandlerExpectShutdown(*handler);

  transport_->addReadEvent("POST http://example.com/cgi-bin/foo.aspx?abc&def "
                           "HTTP/1.1\r\n"
                           "Host: example.com\r\n"
                           "Content-Type: text/pla", milliseconds(0));
  transport_->addReadEvent("in; charset=utf-8\r\n"
                           "Transfer-encoding: chunked\r\n"
                           "\r", milliseconds(2));
  transport_->addReadEvent("\n"
                           "3\r\n"
                           "bar\r\n"
                           "22\r\n"
                           "0123456789abcdef\n"
                           "fedcba9876543210\n"
                           "\r\n"
                           "3\r", milliseconds(3));
  transport_->addReadEvent("\n"
                           "foo\r\n"
                           "0\r\n\r\n", milliseconds(1));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		MultiMessage
	)

Definition at line 692 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, and transport_.

                                                {
  InSequence enforceOrder;

  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  EXPECT_CALL(*handler1, onBody(_))
    .WillOnce(ExpectString("foo"))
    .WillOnce(ExpectString("bar9876"));
  handler1->expectEOM([&] { handler1->sendReply(); });
  handler1->expectDetachTransaction();

  auto handler2 = addSimpleNiceHandler();
  handler2->expectHeaders();
  EXPECT_CALL(*handler2, onChunkHeader(0xa));
  EXPECT_CALL(*handler2, onBody(_))
    .WillOnce(ExpectString("some "))
    .WillOnce(ExpectString("data\n"));
  EXPECT_CALL(*handler2, onChunkComplete());
  onEOMTerminateHandlerExpectShutdown(*handler2);

  transport_->addReadEvent("POST / HTTP/1.1\r\n"
                           "Host: example.com\r\n"
                           "Content-Length: 10\r\n"
                           "\r\n"
                           "foo", milliseconds(0));
  transport_->addReadEvent("bar9876"
                           "POST /foo HTTP/1.1\r\n"
                           "Host: exa", milliseconds(2));
  transport_->addReadEvent("mple.com\r\n"
                           "Connection: close\r\n"
                           "Trans", milliseconds(0));
  transport_->addReadEvent("fer-encoding: chunked\r\n"
                           "\r\n", milliseconds(2));
  transport_->addReadEvent("a\r\nsome ", milliseconds(0));
  transport_->addReadEvent("data\n\r\n0\r\n\r\n", milliseconds(2));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		Connect
	)

Definition at line 732 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, handler(), and transport_.

                                           {
  InSequence enforceOrder;

  auto handler = addSimpleStrictHandler();
  // Send HTTP 200 OK to accept the CONNECT request
  handler->expectHeaders([&handler] {
      handler->sendHeaders(200, 100);
    });

  EXPECT_CALL(*handler, onUpgrade(_));

  // Data should be received using onBody
  EXPECT_CALL(*handler, onBody(_))
    .WillOnce(ExpectString("12345"))
    .WillOnce(ExpectString("abcde"));
  onEOMTerminateHandlerExpectShutdown(*handler);

  transport_->addReadEvent("CONNECT test HTTP/1.1\r\n"
                           "\r\n"
                           "12345", milliseconds(0));
  transport_->addReadEvent("abcde", milliseconds(5));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		ConnectRejected
	)

Definition at line 758 of file HTTPDownstreamSessionTest.cpp.

References handler(), and transport_.

                                                   {
  InSequence enforceOrder;

  auto handler = addSimpleStrictHandler();
  // Send HTTP 400 to reject the CONNECT request
  handler->expectHeaders([&handler] {
      handler->sendReplyCode(400);
    });

  onEOMTerminateHandlerExpectShutdown(*handler);

  transport_->addReadEvent("CONNECT test HTTP/1.1\r\n"
                           "\r\n"
                           "12345", milliseconds(0));
  transport_->addReadEvent("abcde", milliseconds(5));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgrade
	)

Definition at line 778 of file HTTPDownstreamSessionTest.cpp.

References testing::_, proxygen::HTTPHeaders::add(), EXPECT_CALL, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_UPGRADE, and testing::Invoke().

                                               {
  InSequence enforceOrder;

  auto handler = addSimpleStrictHandler();
  // Send HTTP 101 Switching Protocls to accept the upgrade request
  handler->expectHeaders([&handler] {
      handler->sendHeaders(101, 100);
    });

  // Send the response in the new protocol after upgrade
  EXPECT_CALL(*handler, onUpgrade(_))
      .WillOnce(Invoke([&handler](UpgradeProtocol /*protocol*/) {
        handler->sendReplyCode(100);
      }));

  onEOMTerminateHandlerExpectShutdown(*handler);

  HTTPMessage req = getGetRequest();
  req.getHeaders().add(HTTP_HEADER_UPGRADE, "TEST/1.0");
  req.getHeaders().add(HTTP_HEADER_CONNECTION, "upgrade");
  sendRequest(req);
  flushRequestsAndLoop(true, milliseconds(0));
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpWithAckTiming
	)

Definition at line 889 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::HTTPTransaction::incrementPendingByteEvents(), testing::Invoke(), and uint64_t.

                                                     {
  // This is to test cases where holding a byte event to a finished HTTP/1.1
  // transaction does not masquerade as HTTP pipelining.
  auto byteEventTracker = setMockByteEventTracker();
  InSequence enforceOrder;

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] () {
      handler1->sendChunkedReplyWithBody(200, 100, 100, false);
    });
  // Hold a pending byte event
  EXPECT_CALL(*byteEventTracker, addLastByteEvent(_, _))
      .WillOnce(Invoke([] (HTTPTransaction* txn,
                           uint64_t /*byteNo*/) {
                         txn->incrementPendingByteEvents();
                       }));
  sendRequest();
  flushRequestsAndLoop();
  expectResponse();

  // Send the secode request after receiving the first response (eg: clearly
  // not pipelined)
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2] () {
      handler2->sendChunkedReplyWithBody(200, 100, 100, false);
    });
  // This txn processed and destroyed before txn1
  EXPECT_CALL(*byteEventTracker, addLastByteEvent(_, _));
  handler2->expectDetachTransaction();

  sendRequest();
  flushRequestsAndLoop();
  expectResponse();

  // Now clear the pending byte event (simulate ack) and the first txn
  // goes away too
  handler1->expectDetachTransaction();
  handler1->txn_->decrementPendingByteEvents();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		TestOnContentMismatch
	)

Definition at line 932 of file HTTPDownstreamSessionTest.cpp.

                                                         {
  // Test the behavior when the reported content-length on the header
  // is different from the actual length of the body.
  // The expectation is simply to log the behavior, such as:
  // ".. HTTPTransaction.cpp ] Content-Length/body mismatch: expected: .. "
  folly::EventBase base;
  InSequence enforceOrder;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] () {
        // over-estimate the content-length on the header
        handler1->sendHeaders(200, 105);
        handler1->sendBody(100);
        handler1->txn_->sendEOM();
      });
  sendRequest();
  flushRequestsAndLoop();

  auto handler2 = addSimpleNiceHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2] () {
        // under-estimate the content-length on the header
        handler2->sendHeaders(200, 95);
        handler2->sendBody(100);
        handler2->txn_->sendEOM();
      });
  sendRequest();
  flushRequestsAndLoop();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpWithAckTimingPipeline
	)

Definition at line 963 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::HTTPTransaction::incrementPendingByteEvents(), testing::Invoke(), and uint64_t.

                                                             {
  // Test a real pipelining case as well.  First request is done waiting for
  // ack, then receive two pipelined requests.
  auto byteEventTracker = setMockByteEventTracker();
  InSequence enforceOrder;

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] () {
      handler1->sendChunkedReplyWithBody(200, 100, 100, false);
    });
  EXPECT_CALL(*byteEventTracker, addLastByteEvent(_, _))
      .WillOnce(Invoke([] (HTTPTransaction* txn,
                           uint64_t /*byteNo*/) {
                         txn->incrementPendingByteEvents();
                       }));
  sendRequest();
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2] () {
      handler2->sendChunkedReplyWithBody(200, 100, 100, false);
    });
  EXPECT_CALL(*byteEventTracker, addLastByteEvent(_, _));
  handler2->expectDetachTransaction();

  sendRequest();
  sendRequest();
  auto handler3 = addSimpleStrictHandler();
  handler3->expectHeaders();
  handler3->expectEOM([&handler3] () {
      handler3->sendChunkedReplyWithBody(200, 100, 100, false);
    });
  EXPECT_CALL(*byteEventTracker, addLastByteEvent(_, _));
  handler3->expectDetachTransaction();
  flushRequestsAndLoop();
  expectResponses(3);
  handler1->expectDetachTransaction();
  handler1->txn_->decrementPendingByteEvents();
  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		ExheaderFromServer
	)

Definition at line 1012 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, g(), proxygen::getGetRequest(), proxygen::getResponse(), std::tr1::make_tuple(), makeBuf(), and transport_.

                                                       {
  auto cStreamId = HTTPCodec::StreamID(1);
  SetupControlStream(cStreamId);

  // Create a dummy request and a dummy response messages
  auto pub = getGetRequest("/sub/fyi");
  // set up the priority for fun
  pub.setHTTP2Priority(std::make_tuple(0, false, 7));

  InSequence handlerSequence;
  auto cHandler = addSimpleStrictHandler();
  StrictMock<MockHTTPHandler> pubHandler;

  cHandler->expectHeaders([&] {
      cHandler->txn_->pauseIngress();
      // Generate response for the control stream
      cHandler->txn_->sendHeaders(getResponse(200, 0));
      cHandler->txn_->sendBody(makeBuf(100));

      auto* pubTxn = cHandler->txn_->newExTransaction(&pubHandler);
      // Generate a pub request (encapsulated in EX_HEADERS frame)
      pubTxn->sendHeaders(pub);
      pubTxn->sendBody(makeBuf(200));
      pubTxn->sendEOM();
    });

  EXPECT_CALL(pubHandler, setTransaction(_));
  EXPECT_CALL(callbacks_, onMessageBegin(cStreamId, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(cStreamId, _));
  EXPECT_CALL(callbacks_, onExMessageBegin(2, _, _, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(2, _));
  EXPECT_CALL(callbacks_, onMessageComplete(2, _));

  EXPECT_CALL(pubHandler, onHeadersComplete(_));
  EXPECT_CALL(pubHandler, onEOM());
  EXPECT_CALL(pubHandler, detachTransaction());

  EXPECT_CALL(*cHandler, onEOM());
  EXPECT_CALL(*cHandler, detachTransaction());

  transport_->addReadEvent(requests_, milliseconds(0));
  transport_->startReadEvents();

  eventBase_.runAfterDelay([&] {
      parseOutput(*clientCodec_);
      // send a response from client to server
      clientCodec_->generateExHeader(requests_, 2, getResponse(200, 0),
                                     HTTPCodec::ExAttributes(cStreamId, false),
                                     true, nullptr);
      transport_->addReadEvent(requests_, milliseconds(0));
      transport_->startReadEvents();
      parseOutput(*clientCodec_);
      cHandler->txn_->resumeIngress();
      cHandler->txn_->sendEOM();
      transport_->addReadEOF(milliseconds(0));
    }, 100);

  HTTPSession::DestructorGuard g(httpSession_);
  expectDetachSession();
  eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		ExheaderFromClient
	)

Definition at line 1082 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, g(), proxygen::getGetRequest(), proxygen::getResponse(), testing::Invoke(), proxygen::HTTPTransaction::setHandler(), and transport_.

                                                       {
  auto cStreamId = HTTPCodec::StreamID(1);
  SetupControlStream(cStreamId);

  // generate an EX_HEADERS
  auto exStreamId = cStreamId + 2;
  clientCodec_->generateExHeader(requests_, exStreamId, getGetRequest("/pub"),
                                 HTTPCodec::ExAttributes(cStreamId, false),
                                 true, nullptr);

  auto cHandler = addSimpleStrictHandler();
  cHandler->expectHeaders([&] {
      // send back the response for control stream, but EOM
      cHandler->txn_->sendHeaders(getResponse(200, 0));
    });
  EXPECT_CALL(*cHandler, onEOM());

  StrictMock<MockHTTPHandler> pubHandler;
  EXPECT_CALL(*cHandler, onExTransaction(_))
    .WillOnce(Invoke([&pubHandler] (HTTPTransaction* exTxn) {
          exTxn->setHandler(&pubHandler);
          pubHandler.txn_ = exTxn;
        }));

  InSequence handlerSequence;
  EXPECT_CALL(pubHandler, setTransaction(_));
  pubHandler.expectHeaders([&] {
      // send back the response for the pub request
      pubHandler.txn_->sendHeadersWithEOM(getResponse(200, 0));
    });
  EXPECT_CALL(pubHandler, onEOM());
  EXPECT_CALL(pubHandler, detachTransaction());
  cHandler->expectDetachTransaction();

  EXPECT_CALL(callbacks_, onMessageBegin(cStreamId, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(cStreamId, _));
  EXPECT_CALL(callbacks_, onExMessageBegin(exStreamId, _, _, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(exStreamId, _));
  EXPECT_CALL(callbacks_, onMessageComplete(exStreamId, _));
  EXPECT_CALL(callbacks_, onMessageComplete(cStreamId, _));

  transport_->addReadEvent(requests_, milliseconds(0));
  transport_->startReadEvents();
  transport_->addReadEOF(milliseconds(0));
  eventBase_.loop();

  HTTPSession::DestructorGuard g(httpSession_);
  expectDetachSession();
  cHandler->txn_->sendEOM();
  eventBase_.loop();
  parseOutput(*clientCodec_);
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		UnidirectionalExTransaction
	)

Definition at line 1141 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_TRUE, g(), proxygen::getGetRequest(), proxygen::getResponse(), and transport_.

                                                                {
  auto cStreamId = HTTPCodec::StreamID(1);
  SetupControlStream(cStreamId);
  InSequence handlerSequence;
  auto cHandler = addSimpleStrictHandler();
  StrictMock<MockHTTPHandler> uniHandler;

  cHandler->expectHeaders([&] {
      auto* uniTxn = cHandler->txn_->newExTransaction(&uniHandler, true);
      EXPECT_TRUE(uniTxn->isIngressComplete());
      uniTxn->sendHeaders(getGetRequest("/uni"));
      uniTxn->sendEOM();

      // close control stream
      cHandler->txn_->sendHeadersWithEOM(getResponse(200, 0));
    });

  EXPECT_CALL(uniHandler, setTransaction(_));
  EXPECT_CALL(*cHandler, onEOM());
  EXPECT_CALL(uniHandler, detachTransaction());
  EXPECT_CALL(*cHandler, detachTransaction());

  transport_->addReadEvent(requests_, milliseconds(0));
  transport_->startReadEvents();
  eventBase_.runAfterDelay([&] {
      transport_->addReadEOF(milliseconds(0));
    }, 100);

  HTTPSession::DestructorGuard g(httpSession_);
  expectDetachSession();
  eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		PauseResumeControlStream
	)

Definition at line 1174 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, g(), proxygen::getGetRequest(), proxygen::getResponse(), testing::Invoke(), proxygen::HTTPTransaction::setHandler(), and transport_.

                                                             {
  auto cStreamId = HTTPCodec::StreamID(1);
  SetupControlStream(cStreamId);

  // generate an EX_HEADERS
  clientCodec_->generateExHeader(requests_, cStreamId + 2, getGetRequest(),
                                 HTTPCodec::ExAttributes(cStreamId, false),
                                 true, nullptr);

  auto cHandler = addSimpleStrictHandler();
  cHandler->expectHeaders([&] {
      cHandler->txn_->pauseIngress();
      // send back the response for control stream, but EOM
      cHandler->txn_->sendHeaders(getResponse(200, 0));
    });
  EXPECT_CALL(*cHandler, onEOM());

  StrictMock<MockHTTPHandler> pubHandler;
  EXPECT_CALL(*cHandler, onExTransaction(_))
    .WillOnce(Invoke([&pubHandler] (HTTPTransaction* exTxn) {
          exTxn->setHandler(&pubHandler);
          pubHandler.txn_ = exTxn;
        }));

  InSequence handlerSequence;
  EXPECT_CALL(pubHandler, setTransaction(_));
  pubHandler.expectHeaders([&] {
      // send back the response for the pub request
      pubHandler.txn_->sendHeadersWithEOM(getResponse(200, 0));
    });
  EXPECT_CALL(pubHandler, onEOM());
  EXPECT_CALL(pubHandler, detachTransaction());
  cHandler->expectDetachTransaction();

  EXPECT_CALL(callbacks_, onMessageBegin(cStreamId, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(cStreamId, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(cStreamId + 2, _));
  EXPECT_CALL(callbacks_, onMessageComplete(cStreamId + 2, _));
  EXPECT_CALL(callbacks_, onMessageComplete(cStreamId, _));

  HTTPSession::DestructorGuard g(httpSession_);
  transport_->addReadEvent(requests_, milliseconds(0));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();

  cHandler->txn_->resumeIngress();
  cHandler->txn_->sendEOM();
  eventBase_.loop();

  expectDetachSession();
  parseOutput(*clientCodec_);
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		InvalidControlStream
	)

Definition at line 1228 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, g(), proxygen::getGetRequest(), proxygen::getResponse(), and transport_.

                                                         {
  auto cStreamId = HTTPCodec::StreamID(1);
  SetupControlStream(cStreamId);

  // generate an EX_HEADERS, but with a non-existing control stream
  clientCodec_->generateExHeader(requests_, cStreamId + 2, getGetRequest(),
                                 HTTPCodec::ExAttributes(cStreamId + 4, false),
                                 true, nullptr);

  auto cHandler = addSimpleStrictHandler();
  InSequence handlerSequence;
  cHandler->expectHeaders([&] {
      // send back the response for control stream, but EOM
      cHandler->txn_->sendHeaders(getResponse(200, 0));
    });
  EXPECT_CALL(*cHandler, onExTransaction(_)).Times(0);
  EXPECT_CALL(*cHandler, onEOM());
  cHandler->expectDetachTransaction();

  EXPECT_CALL(callbacks_, onMessageBegin(cStreamId, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(cStreamId, _));
  EXPECT_CALL(callbacks_, onAbort(cStreamId + 2, _));

  HTTPSession::DestructorGuard g(httpSession_);
  transport_->addReadEvent(requests_, milliseconds(0));
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();

  cHandler->txn_->sendEOM();
  eventBase_.loop();

  expectDetachSession();
  parseOutput(*clientCodec_);
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		SetByteEventTracker
	)

Definition at line 1264 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, folly::gen::move, and transport_.

                                                        {
  InSequence enforceOrder;

  // Send two requests with writes paused, which will queue several byte events,
  // including last byte events which are holding a reference to the
  // transaction.
  transport_->pauseWrites();
  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] () {
      handler1->sendReplyWithBody(200, 100);
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2] () {
      handler2->sendReplyWithBody(200, 100);
    });

  sendRequest();
  sendRequest();
  // Resume writes from the loop callback
  eventBase_.runInLoop([this] {
      transport_->resumeWrites();
    });

  // Graceful shutdown will notify of GOAWAY
  EXPECT_CALL(*handler1, onGoaway(ErrorCode::NO_ERROR));
  EXPECT_CALL(*handler2, onGoaway(ErrorCode::NO_ERROR));
  // The original byteEventTracker will process the last byte event of the
  // first transaction, and detach by deleting the event.  Swap out the tracker.
  handler1->expectDetachTransaction([this] {
      auto tracker = std::make_unique<ByteEventTracker>(httpSession_);
      httpSession_->setByteEventTracker(std::move(tracker));
    });
  // handler2 should also be detached immediately because the new
  // ByteEventTracker continues procesing where the old one left off.
  handler2->expectDetachTransaction();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		TestTrackedByteEventTracker
	)

Definition at line 1304 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, proxygen::HTTPTransaction::incrementPendingByteEvents(), testing::Invoke(), and uint64_t.

                                                               {
  auto byteEventTracker = setMockByteEventTracker();
  InSequence enforceOrder;

  auto handler1 = addSimpleStrictHandler();
  size_t bytesToSend = 200;
  size_t expectedTrackedByteOffset = bytesToSend + 99;
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, &bytesToSend] () {
    handler1->sendHeaders(200, 200);
    handler1->sendBodyWithLastByteTracking(bytesToSend);
    handler1->txn_->sendEOM();
    });

  EXPECT_CALL(*byteEventTracker,
    addTrackedByteEvent(_, expectedTrackedByteOffset))
      .WillOnce(Invoke([] (HTTPTransaction* txn,
                           uint64_t /*byteNo*/) {
                         txn->incrementPendingByteEvents();
                       }));
  sendRequest();
  flushRequestsAndLoop();
  handler1->expectDetachTransaction();
  handler1->txn_->decrementPendingByteEvents();
  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		Trailers
	)

Definition at line 1331 of file HTTPDownstreamSessionTest.cpp.

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

                                             {
  InSequence enforceOrder;

  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectEOM([&handler]() {
    handler->sendReplyWithBody(
        200, 100, true /* keepalive */, true /* sendEOM */, true /*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);
  EXPECT_CALL(callbacks_, onBody(1, _, _));
  EXPECT_CALL(callbacks_, onTrailersComplete(1, _));
  EXPECT_CALL(callbacks_, onMessageComplete(1, _));

  parseOutput(*clientCodec_);
  expectDetachSession();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		Trailers
	)

Definition at line 1356 of file HTTPDownstreamSessionTest.cpp.

                                            {
  testChunks(true);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		ExplicitChunks
	)

Definition at line 1360 of file HTTPDownstreamSessionTest.cpp.

                                                  {
  testChunks(false);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpDrain
	)

Definition at line 1397 of file HTTPDownstreamSessionTest.cpp.

                                             {
  InSequence enforceOrder;

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders([this, &handler1] {
      handler1->sendHeaders(200, 100);
      httpSession_->notifyPendingShutdown();
    });
  handler1->expectEOM([&handler1] {
      handler1->sendBody(100);
      handler1->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();

  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders([&handler2] {
      handler2->sendHeaders(200, 100);
    });
  handler2->expectEOM([&handler2] {
          handler2->sendBody(100);
          handler2->txn_->sendEOM();
    });
  handler2->expectDetachTransaction();

  expectDetachSession();

  sendRequest();
  sendRequest();
  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpDrainLongRunning
	)

Definition at line 1432 of file HTTPDownstreamSessionTest.cpp.

References handler().

                                                        {
  InSequence enforceSequence;

  auto handler = addSimpleStrictHandler();
  handler->expectHeaders([this, &handler] {
      httpSession_->notifyPendingShutdown();
      eventBase_.tryRunAfterDelay([this] {
          // simulate read timeout
          httpSession_->timeoutExpired();
        }, 100);
      eventBase_.tryRunAfterDelay([&handler] {
          handler->sendReplyWithBody(200, 100);
        }, 200);
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  expectDetachSession();

  sendRequest();
  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		EarlyAbort
	)

Definition at line 1455 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, handler(), testing::Invoke(), testing::Return(), and transport_.

                                              {
  StrictMock<MockHTTPHandler> handler;

  InSequence enforceOrder;
  EXPECT_CALL(mockController_, getRequestHandler(_, _))
    .WillOnce(Return(&handler));

  EXPECT_CALL(handler, setTransaction(_))
    .WillOnce(Invoke([&] (HTTPTransaction* txn) {
          handler.txn_ = txn;
          handler.txn_->sendAbort();
        }));
  handler.expectDetachTransaction();
  expectDetachSession();

  addSingleByteReads("GET /somepath.php?param=foo HTTP/1.1\r\n"
                     "Host: example.com\r\n"
                     "Connection: close\r\n"
                     "\r\n");
  transport_->addReadEOF(milliseconds(0));
  transport_->startReadEvents();
  eventBase_.loop();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		HttpPausedBuffered
	)

Definition at line 1479 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, folly::IOBufQueue::cacheChainLength(), proxygen::Exception::getProxygenError(), proxygen::kErrorStreamAbort, s, and transport_.

                                                       {
  IOBufQueue rst{IOBufQueue::cacheChainLength()};
  auto s = sendRequest();
  clientCodec_->generateRstStream(rst, s, ErrorCode::CANCEL);
  sendRequest();

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, this] {
      transport_->pauseWrites();
      handler1->sendHeaders(200, 65536 * 2);
      handler1->sendBody(65536 * 2);
    });
  handler1->expectEgressPaused();
  auto handler2 = addSimpleNiceHandler();
  handler2->expectEgressPaused();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      eventBase_.runInLoop([&] {
          transport_->addReadEvent(rst, milliseconds(0)); });
    });
  handler1->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorStreamAbort);
      resumeWritesInLoop();
    });
  handler1->expectDetachTransaction();
  handler2->expectEgressResumed([&] {
      handler2->sendReplyWithBody(200, 32768);
    });
  handler2->expectDetachTransaction([this] {
      eventBase_.runInLoop([&] { transport_->addReadEOF(milliseconds(0)); });
    });
  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpWritesDrainingTimeout
	)

Definition at line 1517 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, proxygen::Exception::getProxygenError(), proxygen::kErrorWriteTimeout, string, transport_, and proxygen::Exception::what().

                                                             {
  sendRequest();
  sendHeader();

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, this] {
      transport_->pauseWrites();
      handler1->sendHeaders(200, 1000);
    });
  handler1->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(
        folly::to<std::string>("WriteTimeout on transaction id: ",
                               handler1->txn_->getID()),
        std::string(ex.what()));
      handler1->txn_->sendAbort();
    });
  handler1->expectDetachTransaction();
  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpRateLimitNormal
	)

Definition at line 1542 of file HTTPDownstreamSessionTest.cpp.

References folly::ssl::cleanup(), EXPECT_GE, g(), folly::EventBaseManager::get(), int64_t, proxygen::millisecondsBetween(), folly::EventBaseManager::setEventBase(), transport_, and uint32_t.

                                                       {
  // The rate-limiting code grabs the event base from the EventBaseManager,
  // so we need to set it.
  folly::EventBaseManager::get()->setEventBase(&eventBase_, false);

  // Create a request
  sendRequest();

  InSequence handlerSequence;

  // Set a low rate-limit on the transaction
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders([&] {
      uint32_t rateLimit_kbps = 640;
      handler1->txn_->setEgressRateLimit(rateLimit_kbps * 1024);
    });
  // Send a somewhat big response that we know will get rate-limited
  handler1->expectEOM([&handler1] {
      // At 640kbps, this should take slightly over 800ms
      uint32_t rspLengthBytes = 100000;
      handler1->sendHeaders(200, rspLengthBytes);
      handler1->sendBody(rspLengthBytes);
      handler1->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();

  // Keep the session around even after the event base loop completes so we can
  // read the counters on a valid object.
  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop();

  proxygen::TimePoint timeFirstWrite =
    transport_->getWriteEvents()->front()->getTime();
  proxygen::TimePoint timeLastWrite =
    transport_->getWriteEvents()->back()->getTime();
  int64_t writeDuration =
    (int64_t)millisecondsBetween(timeLastWrite, timeFirstWrite).count();
  EXPECT_GE(writeDuration, 800);

  cleanup();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyRateLimitNormal
	)

Definition at line 1584 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_GE, g(), folly::EventBaseManager::get(), int64_t, proxygen::millisecondsBetween(), folly::EventBaseManager::setEventBase(), transport_, and uint32_t.

                                                        {
  // The rate-limiting code grabs the event base from the EventBaseManager,
  // so we need to set it.
  folly::EventBaseManager::get()->setEventBase(&eventBase_, false);

  clientCodec_->getEgressSettings()->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                                100000);
  clientCodec_->generateSettings(requests_);
  sendRequest();

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders([&] {
      uint32_t rateLimit_kbps = 640;
      handler1->txn_->setEgressRateLimit(rateLimit_kbps * 1024);
    });

  handler1->expectEOM([&handler1] {
      // At 640kbps, this should take slightly over 800ms
      uint32_t rspLengthBytes = 100000;
      handler1->sendHeaders(200, rspLengthBytes);
      handler1->sendBody(rspLengthBytes);
      handler1->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();

  // Keep the session around even after the event base loop completes so we can
  // read the counters on a valid object.
  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop(true, milliseconds(50));

  proxygen::TimePoint timeFirstWrite =
    transport_->getWriteEvents()->front()->getTime();
  proxygen::TimePoint timeLastWrite =
    transport_->getWriteEvents()->back()->getTime();
  int64_t writeDuration =
    (int64_t)millisecondsBetween(timeLastWrite, timeFirstWrite).count();
  EXPECT_GE(writeDuration, 800);
  expectDetachSession();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyRateLimitRst
	)

This test will reset the connection while the server is waiting around to send more bytes (so as to keep under the rate limit).

Definition at line 1629 of file HTTPDownstreamSessionTest.cpp.

References folly::IOBufQueue::cacheChainLength(), folly::EventBaseManager::get(), folly::EventBaseManager::setEventBase(), streamID, transport_, and uint32_t.

                                                     {
  // The rate-limiting code grabs the event base from the EventBaseManager,
  // so we need to set it.
  folly::EventBaseManager::get()->setEventBase(&eventBase_, false);

  IOBufQueue rst{IOBufQueue::cacheChainLength()};
  clientCodec_->getEgressSettings()->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                                100000);
  clientCodec_->generateSettings(requests_);
  auto streamID = sendRequest();
  clientCodec_->generateRstStream(rst, streamID, ErrorCode::CANCEL);

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders([&] {
      uint32_t rateLimit_kbps = 640;
      handler1->txn_->setEgressRateLimit(rateLimit_kbps * 1024);
    });
  handler1->expectEOM([&handler1] {
      uint32_t rspLengthBytes = 100000;
      handler1->sendHeaders(200, rspLengthBytes);
      handler1->sendBody(rspLengthBytes);
      handler1->txn_->sendEOM();
    });
  handler1->expectError();
  handler1->expectDetachTransaction();
  expectDetachSession();

  flushRequestsAndLoop(true, milliseconds(50), milliseconds(0), [&] {
      transport_->addReadEvent(rst, milliseconds(10));
    });
}

TEST_F	(	HTTPDownstreamSessionTest	,
		WriteTimeout
	)

Definition at line 1665 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, proxygen::getGetRequest(), proxygen::Exception::getProxygenError(), proxygen::kErrorWriteTimeout, proxygen::HTTPMessage::setHTTPVersion(), string, transport_, and proxygen::Exception::what().

                                                {
  HTTPMessage req = getGetRequest();
  req.setHTTPVersion(1, 0);
  sendRequest(req);

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, this] {
      handler1->sendHeaders(200, 100);
      eventBase_.tryRunAfterDelay([&handler1, this] {
          transport_->pauseWrites();
          handler1->sendBody(100);
          handler1->txn_->sendEOM();
        }, 50);
    });
  handler1->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(folly::to<std::string>("WriteTimeout on transaction id: ",
                                       handler1->txn_->getID()),
                std::string(ex.what()));
    });
  handler1->expectDetachTransaction();

  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		WriteTimeoutPipeline
	)

Definition at line 1695 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, proxygen::Exception::getProxygenError(), proxygen::kErrorWriteTimeout, string, transport_, and proxygen::Exception::what().

                                                        {
  const char* buf = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
    "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n";
  requests_.append(buf, strlen(buf));

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, this] {
      handler1->sendHeaders(200, 100);
      eventBase_.tryRunAfterDelay([&handler1, this] {
          transport_->pauseWrites();
          handler1->sendBody(100);
          handler1->txn_->sendEOM();
        }, 50);
    });
  auto handler2 = addSimpleNiceHandler();
  handler2->expectHeaders();
  handler2->expectEOM();
  handler1->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(folly::to<std::string>("WriteTimeout on transaction id: ",
                                       handler1->txn_->getID()),
                std::string(ex.what()));
      handler1->txn_->sendAbort();
    });
  handler2->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(folly::to<std::string>("WriteTimeout on transaction id: ",
                                       handler2->txn_->getID()),
                std::string(ex.what()));
      handler2->txn_->sendAbort();
    });
  handler2->expectDetachTransaction();
  handler1->expectDetachTransaction();
  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		BodyPacketization
	)

Definition at line 1735 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, g(), proxygen::getGetRequest(), proxygen::HTTPMessage::setHTTPVersion(), proxygen::HTTPMessage::setWantsKeepalive(), and transport_.

                                                     {
  HTTPMessage req = getGetRequest();
  req.setHTTPVersion(1, 0);
  req.setWantsKeepalive(false);
  sendRequest(req);

  InSequence handlerSequence;
  auto handler1 = addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendReplyWithBody(200, 32768);
    });
  handler1->expectDetachTransaction();

  expectDetachSession();

  // Keep the session around even after the event base loop completes so we can
  // read the counters on a valid object.
  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop();

  EXPECT_EQ(transport_->getWriteEvents()->size(), 1);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpMalformedPkt1
	)

Definition at line 1759 of file HTTPDownstreamSessionTest.cpp.

References folly::data(), and string.

                                                     {
  // Create a HTTP connection and keep sending just '\n' to the HTTP1xCodec.
  std::string data(90000, '\n');
  requests_.append(data.data(), data.length());

  expectDetachSession();

  flushRequestsAndLoop(true, milliseconds(0));
}

TEST_F	(	HTTPDownstreamSessionTest	,
		BigExplcitChunkWrite
	)

Definition at line 1769 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_GT, g(), handler(), makeBuf(), folly::gen::move, and transport_.

                                                        {
  // even when the handler does a massive write, the transport only gets small
  // writes
  sendRequest();

  auto handler = addSimpleNiceHandler();
  handler->expectHeaders([&handler] {
      handler->sendHeaders(200, 100, false);
      size_t len = 16 * 1024 * 1024;
      handler->txn_->sendChunkHeader(len);
      auto chunk = makeBuf(len);
      handler->txn_->sendBody(std::move(chunk));
      handler->txn_->sendChunkTerminator();
      handler->txn_->sendEOM();
    });
  handler->expectDetachTransaction();

  expectDetachSession();

  // Keep the session around even after the event base loop completes so we can
  // read the counters on a valid object.
  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop();

  EXPECT_GT(transport_->getWriteEvents()->size(), 250);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNonNative
	)

Definition at line 1800 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, proxygen::getUpgradeRequest(), and handler().

                                                        {
  auto handler = addSimpleStrictHandler();

  handler->expectHeaders([&handler] {
      handler->sendHeaders(101, 0, true, {{"Upgrade", "blarf"}});
    });
  EXPECT_CALL(*handler, onUpgrade(UpgradeProtocol::TCP));
  handler->expectEOM([&handler] {
      handler->txn_->sendEOM();
    });
  handler->expectDetachTransaction();

  sendRequest(getUpgradeRequest("blarf"));
  expectDetachSession();
  flushRequestsAndLoop(true);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNonNativeIgnore
	)

Definition at line 1819 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getUpgradeRequest(), and handler().

                                                              {
  auto handler = addSimpleStrictHandler();

  handler->expectHeaders([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectEOM();
  handler->expectDetachTransaction();

  sendRequest(getUpgradeRequest("blarf"));

  expectDetachSession();
  flushRequestsAndLoop(true);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNonNativePipeline
	)

Definition at line 1836 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::getUpgradeRequest(), proxygen::HTTP_HEADER_UPGRADE, and transport_.

                                                                {
  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders([&handler1] (std::shared_ptr<HTTPMessage> msg) {
      EXPECT_EQ(msg->getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE),
                "blarf");
      handler1->sendReplyWithBody(200, 100);
    });
  handler1->expectEOM();
  handler1->expectDetachTransaction();

  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders([&handler2] {
      handler2->sendReplyWithBody(200, 100);
    });
  handler2->expectEOM();
  handler2->expectDetachTransaction();

  sendRequest(getUpgradeRequest("blarf"));
  transport_->addReadEvent("GET / HTTP/1.1\r\n"
                           "\r\n");
  expectDetachSession();
  flushRequestsAndLoop(true);
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNative3
	)

Definition at line 1911 of file HTTPDownstreamSessionTest.cpp.

                                                      {
  testSimpleUpgrade("spdy/3", CodecProtocol::SPDY_3, "spdy/3");
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNative31
	)

Definition at line 1916 of file HTTPDownstreamSessionTest.cpp.

                                                       {
  testSimpleUpgrade("spdy/3.1", CodecProtocol::SPDY_3_1, "spdy/3.1");
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeH2
	)

Definition at line 1921 of file HTTPDownstreamSessionTest.cpp.

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

TEST_F	(	HTTPDownstreamSessionUpgradeFlowControlTest	,
		UpgradeH2Flowcontrol
	)

Definition at line 1933 of file HTTPDownstreamSessionTest.cpp.

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

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeUnknown
	)

Definition at line 1938 of file HTTPDownstreamSessionTest.cpp.

                                                            {
  // This is maybe weird, the client asked for non-native as first choice,
  // but we go native
  testSimpleUpgrade("blarf, spdy/3.1, spdy/3",
                    CodecProtocol::SPDY_3_1, "spdy/3.1");
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeWhitespace
	)

Definition at line 1946 of file HTTPDownstreamSessionTest.cpp.

                                                               {
  testSimpleUpgrade(" \tspdy/3.1\t , spdy/3",
                    CodecProtocol::SPDY_3_1, "spdy/3.1");
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeJunk
	)

Definition at line 1952 of file HTTPDownstreamSessionTest.cpp.

                                                         {
  testSimpleUpgrade(",,,,   ,,\t~^%$(*&@(@$^^*(,spdy/3",
                    CodecProtocol::SPDY_3, "spdy/3");
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeTxn2
	)

Definition at line 1958 of file HTTPDownstreamSessionTest.cpp.

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

                                                         {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendReplyWithBody(200, 100);
    });
  handler1->expectDetachTransaction();
  sendRequest(getGetRequest());
  flushRequestsAndLoop();
  expectResponse();

  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2] {
      handler2->sendReplyWithBody(200, 100);
    });
  handler2->expectDetachTransaction();

  sendRequest(getUpgradeRequest("spdy/3"));
  flushRequestsAndLoop();
  expectResponse();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativePost
	)

Definition at line 1984 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, proxygen::getUpgradeRequest(), handler(), makeBuf(), and streamID.

                                                         {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectBody();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectDetachTransaction();

  HTTPMessage req = getUpgradeRequest("spdy/3", HTTPMethod::POST, 10);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  // cheat and not sending EOM, it's a no-op
  flushRequestsAndLoop();
  expect101(CodecProtocol::SPDY_3, "spdy/3");
  expectResponse();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativePostEarlyResp
	)

Definition at line 2007 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getUpgradeRequest(), handler(), makeBuf(), and streamID.

                                                                  {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectBody();
  handler->expectEOM();
  handler->expectDetachTransaction();

  HTTPMessage req = getUpgradeRequest("spdy/3", HTTPMethod::POST, 10);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  flushRequestsAndLoop();
  expectResponse();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativePostEarlyPartialResp
	)

Definition at line 2026 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getUpgradeRequest(), handler(), makeBuf(), and streamID.

                                                                         {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders([&handler] {
      handler->sendHeaders(200, 100);
    });
  handler->expectBody();
  handler->expectEOM([&handler] {
      handler->sendBody(100);
      handler->txn_->sendEOM();
    });
  handler->expectDetachTransaction();

  HTTPMessage req = getUpgradeRequest("spdy/3", HTTPMethod::POST, 10);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  flushRequestsAndLoop();
  expectResponse();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativeExtra
	)

Definition at line 2050 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, proxygen::getUpgradeRequest(), handler(), and transport_.

                                                          {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectDetachTransaction();

  sendRequest(getUpgradeRequest("spdy/3"));
  // It's a fatal to send this out on the HTTP1xCodec, so hack it manually
  transport_->addReadEvent("GET / HTTP/1.1\r\n"
                           "Upgrade: spdy/3\r\n"
                           "\r\n");
  flushRequestsAndLoop();
  expect101(CodecProtocol::SPDY_3, "spdy/3");
  expectResponse(200, ErrorCode::_SPDY_INVALID_STREAM);
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativePost100
	)

Definition at line 2076 of file HTTPDownstreamSessionTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_CALL, proxygen::HTTPMessage::getHeaders(), proxygen::getUpgradeRequest(), handler(), proxygen::HTTP_HEADER_EXPECT, makeBuf(), and streamID.

                                                            {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders([&handler] {
      handler->sendHeaders(100, 0);
    });
  handler->expectBody();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectDetachTransaction();

  HTTPMessage req = getUpgradeRequest("spdy/3", HTTPMethod::POST, 10);
  req.getHeaders().add(HTTP_HEADER_EXPECT, "100-continue");
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  flushRequestsAndLoop();
  expect101(CodecProtocol::SPDY_3, "spdy/3", true /* expect 100 continue */);
  expectResponse();
  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeNativePost100Late
	)

Definition at line 2100 of file HTTPDownstreamSessionTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_CALL, proxygen::HTTPMessage::getHeaders(), proxygen::getUpgradeRequest(), handler(), proxygen::HTTP_HEADER_EXPECT, makeBuf(), and streamID.

                                                                {
  this->rawCodec_->setAllowedUpgradeProtocols({"spdy/3"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectBody();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM([&handler] {
      handler->sendHeaders(100, 0);
      handler->sendReplyWithBody(200, 100);
    });
  handler->expectDetachTransaction();

  HTTPMessage req = getUpgradeRequest("spdy/3", HTTPMethod::POST, 10);
  req.getHeaders().add(HTTP_HEADER_EXPECT, "100-continue");
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  flushRequestsAndLoop();
  expect101(CodecProtocol::SPDY_3, "spdy/3");
  expectResponse(200, ErrorCode::NO_ERROR, true /* expect 100 via SPDY */);
  gracefulShutdown();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyPrio
	)

Definition at line 2124 of file HTTPDownstreamSessionTest.cpp.

References folly::ssl::cleanup().

                                             {
  testPriorities(8);

  cleanup();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpUpgradeGoawayDrain
	)

Definition at line 2133 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, g(), proxygen::getUpgradeRequest(), handler(), makeBuf(), testing::Return(), and streamID.

                                                          {
  this->rawCodec_->setAllowedUpgradeProtocols({"h2c"});
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectBody();
  EXPECT_CALL(mockController_, onSessionCodecChange(httpSession_));
  handler->expectEOM();
  handler->expectGoaway();
  handler->expectDetachTransaction();

  EXPECT_CALL(mockController_, getHeaderIndexingStrategy())
    .WillOnce(
      Return(&testH2IndexingStrat_)
  );

  HTTPMessage req = getUpgradeRequest("h2c", HTTPMethod::POST, 10);
  HTTP2Codec::requestUpgrade(req);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(10),
                             HTTPCodec::NoPadding, true);
  // cheat and not sending EOM, it's a no-op

  flushRequestsAndLoop();
  expect101(CodecProtocol::HTTP_2, "h2c");
  clientCodec_->generateConnectionPreface(requests_);
  clientCodec_->generateGoaway(requests_, 0, ErrorCode::NO_ERROR);
  flushRequestsAndLoop();
  eventBase_.runInLoop([&handler] {
      handler->sendReplyWithBody(200, 100);
    });
  HTTPSession::DestructorGuard g(httpSession_);
  eventBase_.loop();
  expectResponse(200, ErrorCode::NO_ERROR, false, true);
  expectDetachSession();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyTimeout
	)

Definition at line 2225 of file HTTPDownstreamSessionTest.cpp.

References folly::ssl::cleanup(), and transport_.

                                                {
  sendRequest();
  sendRequest();

  httpSession_->setWriteBufferLimit(512);

  InSequence handlerSequence;
  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders([this] { transport_->pauseWrites(); });
  handler1->expectEOM([&] {
      handler1->sendHeaders(200, 1000);
      handler1->sendBody(1000);
    });
  handler1->expectEgressPaused();
  auto handler2 = addSimpleStrictHandler();
  // handler2 is paused before it gets headers
  handler2->expectEgressPaused();
  handler2->expectHeaders();
  handler2->expectEOM([this] {
      // This transaction should start egress paused.  We've received the
      // EOM, so the timeout shouldn't be running delay 400ms and resume
      // writes, this keeps txn1 from getting a write timeout
      resumeWritesAfterDelay(milliseconds(400));
    });
  handler1->expectEgressResumed([&handler1] { handler1->txn_->sendEOM(); });
  handler2->expectEgressResumed([&handler2, this] {
      // delay an additional 200ms.  The total 600ms delay shouldn't fire
      // onTimeout
      eventBase_.tryRunAfterDelay([&handler2] {
          handler2->sendReplyWithBody(200, 400); }, 200
        );
    });
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();

  flushRequestsAndLoop(false, milliseconds(0), milliseconds(10));

  cleanup();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyTimeoutWin
	)

Definition at line 2267 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, folly::ssl::cleanup(), proxygen::Exception::getProxygenError(), handler(), proxygen::kErrorWriteTimeout, streamID, string, TYPED_TEST_CASE_P(), and proxygen::Exception::what().

                                                   {
  clientCodec_->getEgressSettings()->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                                500);
  clientCodec_->generateSettings(requests_);
  auto streamID = sendRequest();

  InSequence handlerSequence;
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectEOM([&] {
      handler->sendReplyWithBody(200, 1000);
    });
  handler->expectEgressPaused();
  handler->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(
        folly::to<std::string>("ingress timeout, streamID=", streamID),
        std::string(ex.what()));
      handler->terminate();
    });
  handler->expectDetachTransaction();

  flushRequestsAndLoop();

  cleanup();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		SpdyMaxConcurrentStreams
	)

Definition at line 2480 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getGetRequest(), REGISTER_TYPED_TEST_CASE_P(), proxygen::HTTPMessage::setHTTPVersion(), proxygen::HTTPMessage::setWantsKeepalive(), and transport_.

                                                             {
  HTTPMessage req = getGetRequest();
  req.setHTTPVersion(1, 0);
  req.setWantsKeepalive(false);
  sendRequest(req);
  auto req2p = sendRequestLater(req, true);

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

  InSequence handlerSequence;
  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1, req, this, &req2p] {
      transport_->pauseWrites();
      handler1->sendReplyWithBody(200, 100);
      req2p.setValue();
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2, this] {
      handler2->sendReplyWithBody(200, 100);
      resumeWritesInLoop();
    });
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();

  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	SPDY31DownstreamTest	,
		TestSessionFlowControl
	)

Definition at line 2529 of file HTTPDownstreamSessionTest.cpp.

References testing::_, folly::ssl::cleanup(), EXPECT_CALL, and proxygen::http2::kInitialWindow.

                                                     {
  eventBase_.loopOnce();

  InSequence sequence;
  EXPECT_CALL(callbacks_, onSettings(_));
  EXPECT_CALL(callbacks_, onWindowUpdate(0, spdy::kInitialWindow));
  parseOutput(*clientCodec_);

  cleanup();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		TestEOFOnBlockedStream
	)

Definition at line 2540 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, and proxygen::HTTPException::getDirection().

                                                           {
  sendRequest();

  auto handler1 = addSimpleStrictHandler();

  InSequence handlerSequence;
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendReplyWithBody(200, 80000);
    });
  handler1->expectEgressPaused();

  handler1->expectError([&] (const HTTPException& ex) {
      // Not optimal to have a different error code here than the session
      // flow control case, but HTTPException direction is immutable and
      // building another one seems not future proof.
      EXPECT_EQ(ex.getDirection(), HTTPException::Direction::INGRESS);
    });
  handler1->expectDetachTransaction();

  expectDetachSession();

  flushRequestsAndLoop(true, milliseconds(10));
}

TEST_F	(	SPDY31DownstreamTest	,
		TestEOFOnBlockedSession
	)

Definition at line 2565 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::HTTPException::getDirection(), and transport_.

                                                      {
  sendRequest();
  sendRequest();

  InSequence handlerSequence;
  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendHeaders(200, 40000);
      handler1->sendBody(32769);
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&handler2, this] {
      handler2->sendHeaders(200, 40000);
      handler2->sendBody(32768);
      eventBase_.runInLoop([this] { transport_->addReadEOF(milliseconds(0)); });
    });

  handler1->expectEgressPaused();
  handler2->expectEgressPaused();
  handler1->expectEgressResumed();
  handler2->expectEgressResumed();
  handler1->expectError([&] (const HTTPException& ex) {
      EXPECT_EQ(ex.getDirection(),
                HTTPException::Direction::INGRESS_AND_EGRESS);
    });
  handler1->expectDetachTransaction();
  handler2->expectError([&] (const HTTPException& ex) {
      EXPECT_EQ(ex.getDirection(),
                HTTPException::Direction::INGRESS_AND_EGRESS);
    });
  handler2->expectDetachTransaction();

  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	SPDY3DownstreamSessionTest	,
		NewTxnEgressPaused
	)

Definition at line 2605 of file HTTPDownstreamSessionTest.cpp.

References testing::_, folly::ssl::cleanup(), EXPECT_CALL, g(), proxygen::getGetRequest(), folly::INFO, testing::Invoke(), and transport_.

                                                       {
  // Send 1 request with prio=0
  // Have egress pause while sending the first response
  // Send a second request with prio=1
  //   -- the new txn should start egress paused
  // Finish the body and eom both responses
  // Unpause egress
  // The first txn should complete first

  sendRequest("/", 0);
  auto req2 = getGetRequest();
  req2.setPriority(1);
  auto req2p = sendRequestLater(req2, true);

  unique_ptr<StrictMock<MockHTTPHandler>> handler1;
  unique_ptr<StrictMock<MockHTTPHandler>> handler2;

  httpSession_->setWriteBufferLimit(200); // lower the per session buffer limit
  {
    InSequence handlerSequence;
    handler1 = addSimpleStrictHandler();
    handler1->expectHeaders();
    handler1->expectEOM([&handler1, this, &req2p] {
        this->transport_->pauseWrites();
        handler1->sendHeaders(200, 1000);
        handler1->sendBody(100); // headers + 100 bytes - over the limit
        req2p.setValue();
      });
    handler1->expectEgressPaused([] { LOG(INFO) << "paused 1"; });

    handler2 = addSimpleStrictHandler();
    handler2->expectEgressPaused(); // starts paused
    handler2->expectHeaders();
    handler2->expectEOM([&] {
        // Technically shouldn't send while handler is egress paused, but meh.
        handler1->sendBody(900);
        handler1->txn_->sendEOM();
        handler2->sendReplyWithBody(200, 1000);
        resumeWritesInLoop();
      });
    handler1->expectDetachTransaction();
    handler2->expectDetachTransaction();
  }
  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop();

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

  cleanup();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		ZeroDeltaWindowUpdate
	)

Definition at line 2666 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, proxygen::HTTPException::getCodecStatusCode(), handler(), proxygen::http2::kFrameWindowUpdateSize, streamID, string, uint32_t, proxygen::Exception::what(), and folly::io::detail::Writable< Derived >::writeBE().

                                                          {
  // generateHeader() will create a session and a transaction
  auto streamID = sendHeader();
  // First generate a frame with delta=1 so as to pass the checks, and then
  // hack the frame so that delta=0 without modifying other checks
  clientCodec_->generateWindowUpdate(requests_, streamID, 1);
  requests_.trimEnd(http2::kFrameWindowUpdateSize);
  QueueAppender appender(&requests_, http2::kFrameWindowUpdateSize);
  appender.writeBE<uint32_t>(0);

  auto handler = addSimpleStrictHandler();

  InSequence handlerSequence;
  handler->expectHeaders();
  handler->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getCodecStatusCode(), ErrorCode::PROTOCOL_ERROR);
      ASSERT_EQ(
        "streamID=1 with HTTP2Codec stream error: window update delta=0",
        std::string(ex.what()));
    });
  handler->expectDetachTransaction();
  expectDetachSession();

  flushRequestsAndLoop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		PaddingFlowControl
	)

Definition at line 2692 of file HTTPDownstreamSessionTest.cpp.

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

                                                       {
  // generateHeader() will create a session and a transaction
  auto streamID = sendHeader();
  // This sends a total of 33kb including padding, so we should get a session
  // and stream window update
  for (auto i = 0; i < 129; i++) {
    clientCodec_->generateBody(requests_, streamID, makeBuf(1), 255, false);
  }

  auto handler = addSimpleStrictHandler();

  InSequence handlerSequence;
  handler->expectHeaders([&] {
      handler->txn_->pauseIngress();
      eventBase_.runAfterDelay([&] { handler->txn_->resumeIngress(); },
                               100);
    });
  EXPECT_CALL(*handler, onBody(_))
    .Times(129);
  handler->expectError();
  handler->expectDetachTransaction();

  HTTPSession::DestructorGuard g(httpSession_);
  flushRequestsAndLoop(false, milliseconds(0), milliseconds(0), [&] {
      clientCodec_->generateRstStream(requests_, streamID, ErrorCode::CANCEL);
      clientCodec_->generateGoaway(requests_, 0, ErrorCode::NO_ERROR);
      transport_->addReadEvent(requests_, milliseconds(110));
    });

  std::list<HTTPCodec::StreamID> streams;
  EXPECT_CALL(callbacks_, onWindowUpdate(0, _));
  EXPECT_CALL(callbacks_, onWindowUpdate(1, _));
  parseOutput(*clientCodec_);
  expectDetachSession();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		GracefulDrainOnTimeout
	)

Definition at line 2728 of file HTTPDownstreamSessionTest.cpp.

References testing::_, count, EXPECT_CALL, EXPECT_GE, g(), proxygen::getCurrentTime(), testing::InvokeWithoutArgs(), max, and start.

                                                           {
  InSequence handlerSequence;
  std::chrono::milliseconds gracefulTimeout(200);
  httpSession_->enableDoubleGoawayDrain();
  EXPECT_CALL(mockController_, getGracefulShutdownTimeout())
    .WillOnce(InvokeWithoutArgs([&] {
          // Once session asks for graceful shutdown timeout, expect the client
          // to receive the first GOAWAY
          eventBase_.runInLoop([&] {
              EXPECT_CALL(callbacks_,
                          onGoaway(std::numeric_limits<int32_t>::max(),
                                   ErrorCode::NO_ERROR, _));
              parseOutput(*clientCodec_);
            });
          return gracefulTimeout;
        }));


  // Simulate ConnectionManager idle timeout
  eventBase_.runAfterDelay([&] { httpSession_->timeoutExpired(); },
                           transactionTimeouts_->getDefaultTimeout().count());
  HTTPSession::DestructorGuard g(httpSession_);
  auto start = getCurrentTime();
  eventBase_.loop();
  auto finish = getCurrentTime();
  auto minDuration =
    gracefulTimeout + transactionTimeouts_->getDefaultTimeout();
  EXPECT_GE((finish - start).count(), minDuration.count());
  EXPECT_CALL(callbacks_, onGoaway(0, ErrorCode::NO_ERROR, _));
  parseOutput(*clientCodec_);
  expectDetachSession();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		ServerPush
	)

Definition at line 2769 of file HTTPDownstreamSessionTest.cpp.

References testing::_, ASSERT_NE, EXPECT_CALL, EXPECT_EQ, g(), proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), testing::Invoke(), std::tr1::make_tuple(), makeBuf(), proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setHTTP2Priority(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), proxygen::HTTPMessage::setURL(), and transport_.

                                               {
  // Create a dummy request and a dummy response messages
  HTTPMessage req, res;
  req.getHeaders().set("HOST", "www.foo.com");
  req.setURL("https://www.foo.com/");
  res.setStatusCode(200);
  res.setStatusMessage("Ohai");

  // enable server push
  clientCodec_->getEgressSettings()->setSetting(SettingsId::ENABLE_PUSH, 1);
  clientCodec_->generateSettings(requests_);
  // generateHeader() will create a session and a transaction
  auto assocStreamId = HTTPCodec::StreamID(1);
  clientCodec_->generateHeader(requests_, assocStreamId, getGetRequest(),
                               false, nullptr);

  auto handler = addSimpleStrictHandler();
  StrictMock<MockHTTPPushHandler> pushHandler;

  InSequence handlerSequence;
  handler->expectHeaders([&] {
      // Generate response for the associated stream
      handler->txn_->sendHeaders(res);
      handler->txn_->sendBody(makeBuf(100));
      handler->txn_->pauseIngress();

      auto* pushTxn = handler->txn_->newPushedTransaction(&pushHandler);
      ASSERT_NE(pushTxn, nullptr);
      // Generate a push request (PUSH_PROMISE)
      auto outgoingStreams = httpSession_->getNumOutgoingStreams();
      pushTxn->sendHeaders(req);
      EXPECT_EQ(httpSession_->getNumOutgoingStreams(), outgoingStreams);
      // Generate a push response
      auto pri = handler->txn_->getPriority();
      res.setHTTP2Priority(std::make_tuple(pri.streamDependency,
                                           pri.exclusive, pri.weight));
      pushTxn->sendHeaders(res);
      EXPECT_EQ(httpSession_->getNumOutgoingStreams(), outgoingStreams + 1);
      pushTxn->sendBody(makeBuf(200));
      pushTxn->sendEOM();

      eventBase_.runAfterDelay([&] { handler->txn_->resumeIngress(); },
                               100);
    });
  EXPECT_CALL(pushHandler, setTransaction(_))
    .WillOnce(Invoke([&] (HTTPTransaction* txn) {
          pushHandler.txn_ = txn; }));
  EXPECT_CALL(pushHandler, detachTransaction());
  handler->expectError();
  handler->expectDetachTransaction();

  transport_->addReadEvent(requests_, milliseconds(0));
  clientCodec_->generateRstStream(requests_, assocStreamId, ErrorCode::CANCEL);
  clientCodec_->generateGoaway(requests_, 2, ErrorCode::NO_ERROR);
  transport_->addReadEvent(requests_, milliseconds(200));
  transport_->startReadEvents();
  HTTPSession::DestructorGuard g(httpSession_);
  eventBase_.loop();

  EXPECT_CALL(callbacks_, onMessageBegin(1, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(1, _));
  EXPECT_CALL(callbacks_, onPushMessageBegin(2, 1, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(2, _));
  EXPECT_CALL(callbacks_, onMessageBegin(2, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(2, _));
  EXPECT_CALL(callbacks_, onMessageComplete(2, _));

  parseOutput(*clientCodec_);
  expectDetachSession();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		ServerPushAbortPaused
	)

Definition at line 2840 of file HTTPDownstreamSessionTest.cpp.

References testing::_, ASSERT_NE, EXPECT_CALL, g(), proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), handler(), testing::Invoke(), makeBuf(), proxygen::HTTPHeaders::set(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), proxygen::HTTPMessage::setURL(), and transport_.

                                                          {
  // Create a dummy request and a dummy response messages
  HTTPMessage req, res;
  req.getHeaders().set("HOST", "www.foo.com");
  req.setURL("https://www.foo.com/");
  res.setStatusCode(200);
  res.setStatusMessage("Ohai");

  // enable server push
  clientCodec_->getEgressSettings()->setSetting(SettingsId::ENABLE_PUSH, 1);
  clientCodec_->generateSettings(requests_);
  // generateHeader() will create a session and a transaction
  auto assocStreamId = HTTPCodec::StreamID(1);
  clientCodec_->generateHeader(requests_, assocStreamId, getGetRequest(),
                               false, nullptr);

  auto handler = addSimpleStrictHandler();
  StrictMock<MockHTTPPushHandler> pushHandler;

  InSequence handlerSequence;
  handler->expectHeaders([&] {
      // Generate response for the associated stream
      this->transport_->pauseWrites();
      handler->txn_->sendHeaders(res);
      handler->txn_->sendBody(makeBuf(100));
      handler->txn_->pauseIngress();

      auto* pushTxn = handler->txn_->newPushedTransaction(&pushHandler);
      ASSERT_NE(pushTxn, nullptr);
      // Generate a push request (PUSH_PROMISE)
      pushTxn->sendHeaders(req);
    });
  EXPECT_CALL(pushHandler, setTransaction(_))
    .WillOnce(Invoke([&] (HTTPTransaction* txn) {
          pushHandler.txn_ = txn; }));
  EXPECT_CALL(pushHandler, onError(_));
  EXPECT_CALL(pushHandler, detachTransaction());
  handler->expectError();
  handler->expectDetachTransaction();

  transport_->addReadEvent(requests_, milliseconds(0));
  // Cancels everything
  clientCodec_->generateRstStream(requests_, assocStreamId, ErrorCode::CANCEL);
  transport_->addReadEvent(requests_, milliseconds(10));
  transport_->startReadEvents();
  HTTPSession::DestructorGuard g(httpSession_);
  eventBase_.loop();

  parseOutput(*clientCodec_);
  expectDetachSession();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestPriorityWeightsTinyRatio
	)

Definition at line 2892 of file HTTPDownstreamSessionTest.cpp.

References proxygen::HTTPTransaction::PrioritySampleSummary::WeightedAverage::bySessionBytes_, proxygen::HTTPTransaction::PrioritySampleSummary::WeightedAverage::byTransactionBytes_, proxygen::HTTPTransaction::PrioritySampleSummary::contentions_, proxygen::HTTPTransaction::PrioritySampleSummary::depth_, EXPECT_EQ, EXPECT_GT, EXPECT_LT, proxygen::HTTPTransaction::PrioritySampleSummary::expected_weight_, proxygen::getGetRequest(), and proxygen::HTTPTransaction::PrioritySampleSummary::measured_weight_.

                                                                 {
  // Create a transaction with egress and a ratio small enough that
  // ratio*4096 < 1.
  //
  //     root
  //     /  \                                                 level 1
  //   256   1 (no egress)
  //        / \                                               level 2
  //      256  1  <-- has ratio (1/257)^2
  InSequence enforceOrder;
  auto req1 = getGetRequest();
  auto req2 = getGetRequest();
  req1.setHTTP2Priority(HTTPMessage::HTTPPriority{0, false, 255});
  req2.setHTTP2Priority(HTTPMessage::HTTPPriority{0, false, 0});

  sendRequest(req1);
  auto id2 = sendRequest(req2);
  req1.setHTTP2Priority(HTTPMessage::HTTPPriority{id2, false, 255});
  req2.setHTTP2Priority(HTTPMessage::HTTPPriority{id2, false, 0});
  sendRequest(req1);
  sendRequest(req2);

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendReplyWithBody(200, 4 * 1024);
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM();
  auto handler3 = addSimpleStrictHandler();
  handler3->expectHeaders();
  handler3->expectEOM([&] {
      handler3->sendReplyWithBody(200, 15);
    });
  auto handler4 = addSimpleStrictHandler();
  handler4->expectHeaders();
  handler4->expectEOM([&] {
      handler4->sendReplyWithBody(200, 1);
    });

  handler1->expectDetachTransaction([&] {
      HTTPTransaction::PrioritySampleSummary summary;
      EXPECT_EQ(handler1->txn_->getPrioritySampleSummary(summary), true);
      EXPECT_EQ(handler1->txn_->getTransport().getHTTP2PrioritiesEnabled(),
                true);
      // id1 had no egress when id2 was running, so id1 was contending only with
      // id3 and id4. Average number of contentions for id1 is 3
      EXPECT_EQ(summary.contentions_.byTransactionBytes_, 3);
      EXPECT_EQ(summary.contentions_.bySessionBytes_, 3);
      // this is a first level transaction, depth == 1
      EXPECT_EQ(summary.depth_.byTransactionBytes_, 1);
      EXPECT_EQ(summary.depth_.bySessionBytes_, 1);
      // the expected relative weight is 256/257 ~= 0.9961
      EXPECT_GT(summary.expected_weight_, 0.996);
      EXPECT_LT(summary.expected_weight_, 0.9962);
      // the measured relative weight is 4096/(4096+15) ~= 0.99635
      // This value is higher than the expected relative weight of 0.9961.
      // Due to the arithmetical rounding to the lowest integer, the measured
      // relative weight tends to be higher for transactions with high relative
      // weights and lower for transactions with the low relative weights.
      EXPECT_GT(summary.measured_weight_, 0.9963);
      EXPECT_LT(summary.measured_weight_, 0.9964);
    });
  handler3->expectDetachTransaction([&] {
      HTTPTransaction::PrioritySampleSummary summary;
      EXPECT_EQ(handler3->txn_->getPrioritySampleSummary(summary), true);
      EXPECT_EQ(handler3->txn_->getTransport().getHTTP2PrioritiesEnabled(),
                true);
      // Similarly, id3 was contenting with id1 and id4
      // Average number of contentions for id3 is 3
      EXPECT_EQ(summary.contentions_.byTransactionBytes_, 3);
      EXPECT_EQ(summary.contentions_.bySessionBytes_, 3);
      // this is a second level transaction where parent has
      // no egress, depth == 2
      EXPECT_EQ(summary.depth_.byTransactionBytes_, 2);
      EXPECT_EQ(summary.depth_.bySessionBytes_, 2);
      // the expected relative weight should be
      // 1/257 * 256/257 ~= 0.00388. However, in the calculation of the
      // allowed bytes to send we rounding to the lowest positive integer.
      // Therefore, the measured relative weight tends to be less than
      // it should be.  In this example, the allowed bytes sent is
      // 4096 * 0.00388 ~= 15.89, which is rounded to 15. Hence the measured
      // relative weight is 15/(4096+15) ~= 0.00365
      EXPECT_GT(summary.expected_weight_, 0.00388);
      EXPECT_LT(summary.expected_weight_, 0.0039);
      EXPECT_GT(summary.measured_weight_, 0.00364);
      EXPECT_LT(summary.measured_weight_, 0.00366);
    });
  handler4->expectDetachTransaction([&] {
      HTTPTransaction::PrioritySampleSummary summary;
      EXPECT_EQ(handler4->txn_->getPrioritySampleSummary(summary), true);
      EXPECT_EQ(handler4->txn_->getTransport().getHTTP2PrioritiesEnabled(),
                true);
      // This is the priority-based blocking situation. id4 was blocked by
      // higher priority transactions id1 and id3. Only when id1 and id3
      // finished, id4 had a chance to transfer its data.
      // Average contention number weighted by transaction bytes is 1, which
      // means that when id4 had a chance to transfer bytes it did not contend
      // with any other transactions.
      // id4 was waiting for id1 and id3 during transfer of 4256 bytes (encoded)
      // after which it tranferred 10 bytes (encoded) without contention.
      // Therefore, the average number contentions weighted by session bytes is
      // (4111*3 + 1*1)/(4111 + 1) = 12334/4112 ~= 2.999
      // The difference in average contentions weighted by transaction and
      // session bytes tells that id4 was mostly blocked by rather than blocking
      // other transactions.
      EXPECT_EQ(summary.contentions_.byTransactionBytes_, 1);
      EXPECT_GT(summary.contentions_.bySessionBytes_, 2.99);
      EXPECT_LT(summary.contentions_.bySessionBytes_, 3.00);
      // this is a second level transaction where parent has
      // no egress, depth == 2
      EXPECT_EQ(summary.depth_.byTransactionBytes_, 2);
      EXPECT_EQ(summary.depth_.bySessionBytes_, 2);
      // the expected relative weight should be
      // 1/257 * 1/257 ~= 0.000015.
      // Because no bytes of this transaction were sent during the previous
      // egress, the expected relative weight was calculated as:
      // (0*4111 + 1*1)/(4111 + 1) ~= 0.000243
      EXPECT_GT(summary.expected_weight_, 0.000243);
      EXPECT_LT(summary.expected_weight_, 0.000244);
      // The measured weight is (0+1)/(4111+1)  ~= 0.000243
      // The difference between the theoretical value of 0.000015 and the
      // measured one is not because of the arithmetical rounding, but because
      // all other transactions are completed and the relative waight for the
      // only survived transaction was elevated to 1.0
      EXPECT_GT(summary.measured_weight_, 0.000243);
      EXPECT_LT(summary.measured_weight_, 0.000244);
      handler2->txn_->sendAbort();
    });
  handler2->expectDetachTransaction();
  flushRequestsAndLoop();
  httpSession_->closeWhenIdle();
  expectDetachSession();
  eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestPriorityDependentTransactions
	)

Definition at line 3029 of file HTTPDownstreamSessionTest.cpp.

References proxygen::HTTPTransaction::PrioritySampleSummary::WeightedAverage::bySessionBytes_, proxygen::HTTPTransaction::PrioritySampleSummary::WeightedAverage::byTransactionBytes_, proxygen::HTTPTransaction::PrioritySampleSummary::contentions_, proxygen::HTTPTransaction::PrioritySampleSummary::depth_, EXPECT_EQ, proxygen::HTTPTransaction::PrioritySampleSummary::expected_weight_, proxygen::getGetRequest(), and proxygen::HTTPTransaction::PrioritySampleSummary::measured_weight_.

                                                                      {
  // Create a dependent transaction to test the priority blocked by dependency.
  // ratio*4096 < 1.
  //
  //     root
  //      \                                                 level 1
  //      16
  //       \                                                level 2
  //       16
  InSequence enforceOrder;
  auto req1 = getGetRequest();
  req1.setHTTP2Priority(HTTPMessage::HTTPPriority{0, false, 15});
  auto id1 = sendRequest(req1);

  auto req2 = getGetRequest();
  req2.setHTTP2Priority(HTTPMessage::HTTPPriority{id1, false, 15});
  sendRequest(req2);

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendReplyWithBody(200, 1024);
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler2->sendReplyWithBody(200, 1024);
    });

  handler1->expectDetachTransaction([&] {
      HTTPTransaction::PrioritySampleSummary summary;
      EXPECT_EQ(handler1->txn_->getPrioritySampleSummary(summary), true);
      EXPECT_EQ(handler1->txn_->getTransport().getHTTP2PrioritiesEnabled(),
                true);
      // id1 is contending with id2 during the entire transfer.
      // Average number of contentions for id1 is 2 in both cases.
      // The same number of average contentions weighted by both transaction
      // and session bytes tells that id1 was not blocked by any other
      // transaction during the entire transfer.
      EXPECT_EQ(summary.contentions_.byTransactionBytes_, 2);
      EXPECT_EQ(summary.contentions_.bySessionBytes_, 2);
      // this is a first level transaction, depth == 1
      EXPECT_EQ(summary.depth_.byTransactionBytes_, 1);
      EXPECT_EQ(summary.depth_.bySessionBytes_, 1);
      // dependent transaction is blocked, the parent is egressing on 100%
      EXPECT_EQ(summary.expected_weight_, 1);
      EXPECT_EQ(summary.measured_weight_, 1);
    });
  handler2->expectDetachTransaction([&] {
      HTTPTransaction::PrioritySampleSummary summary;
      EXPECT_EQ(handler2->txn_->getPrioritySampleSummary(summary), true);
      EXPECT_EQ(handler2->txn_->getTransport().getHTTP2PrioritiesEnabled(),
                true);
      // This is the dependency-based blocking. id2 is blocked by id1.
      // When id2 had a chance to transfer bytes, it was no longer contended
      // with any other transaction. Hence the average contention weighted by
      // transaction bytes is 1.
      // The average number of contentions weighted by the session bytes is
      // computed as (1024*2 + 1024*1)/(1024 + 1024) = 3072/2048 = 1.5
      EXPECT_EQ(summary.contentions_.byTransactionBytes_, 1);
      EXPECT_EQ(summary.contentions_.bySessionBytes_, 1.5);
      // The transaction transferred bytes only when its parent transaction
      // completed. At that time its level decreased to 1. The average depth
      // weighted by session bytes is (2*1024 + 1*1024)/(2048) = 1.5.
      EXPECT_EQ(summary.depth_.byTransactionBytes_, 1);
      EXPECT_EQ(summary.depth_.bySessionBytes_, 1.5);
      // this dependent transaction was bloted, so it was egressiong only 1/2
      // of the session bytes.
      EXPECT_EQ(summary.expected_weight_, 0.5);
      EXPECT_EQ(summary.measured_weight_, 0.5);
      handler2->txn_->sendAbort();
    });
  flushRequestsAndLoop();
  httpSession_->closeWhenIdle();
  expectDetachSession();
  eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestDisablePriorities
	)

Definition at line 3107 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getGetRequest(), and proxygen::HTTPMessage::setHTTP2Priority().

                                                          {
  // turn off HTTP2 priorities
  httpSession_->setHTTP2PrioritiesEnabled(false);

  InSequence enforceOrder;
  HTTPMessage req1 = getGetRequest();
  req1.setHTTP2Priority(HTTPMessage::HTTPPriority{0, false, 0});
  sendRequest(req1);

  HTTPMessage req2 = getGetRequest();
  req2.setHTTP2Priority(HTTPMessage::HTTPPriority{0, false, 255});
  sendRequest(req2);

  auto handler1 = addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendReplyWithBody(200, 4 * 1024);
    });

  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler2->sendReplyWithBody(200, 4 * 1024);
    });

  // expecting handler 1 to finish first irrespective of
  // request 2 having higher weight
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();

  flushRequestsAndLoop();
  httpSession_->closeWhenIdle();
  expectDetachSession();
  eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestPriorityWeights
	)

Definition at line 3143 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, and makeBuf().

                                                        {
  // virtual priority node with pri=4
  auto priGroupID = clientCodec_->createStream();
  clientCodec_->generatePriority(
    requests_, priGroupID, HTTPMessage::HTTPPriority(0, false, 3));
  // Both txn's are at equal pri=16
  auto id1 = sendRequest();
  auto id2 = sendRequest();

  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendHeaders(200, 12 * 1024);
      handler1->txn_->sendBody(makeBuf(4 * 1024));
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler2->sendHeaders(200, 12 * 1024);
      handler2->txn_->sendBody(makeBuf(4 * 1024));
    });

  // twice- once to send and once to receive
  flushRequestsAndLoopN(2);
  EXPECT_CALL(callbacks_, onSettings(_));
  EXPECT_CALL(callbacks_, onMessageBegin(id1, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(id1, _));
  EXPECT_CALL(callbacks_, onMessageBegin(id2, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(id2, _));
  EXPECT_CALL(callbacks_, onBody(id1, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024));
  EXPECT_CALL(callbacks_, onBody(id2, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024));
  parseOutput(*clientCodec_);

  // update handler2 to be in the pri-group (which has lower weight)
  clientCodec_->generatePriority(
    requests_, id2, HTTPMessage::HTTPPriority(priGroupID, false, 15));

  eventBase_.runInLoop([&] {
      handler1->txn_->sendBody(makeBuf(4 * 1024));
      handler2->txn_->sendBody(makeBuf(4 * 1024));
    });
  flushRequestsAndLoopN(2);

  EXPECT_CALL(callbacks_, onBody(id1, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024));
  EXPECT_CALL(callbacks_, onBody(id2, _, _))
    .WillOnce(ExpectBodyLen(1 * 1024))
    .WillOnce(ExpectBodyLen(3 * 1024));
  parseOutput(*clientCodec_);

  // update vnode weight to match txn1 weight
  clientCodec_->generatePriority(requests_, priGroupID,
                                 HTTPMessage::HTTPPriority(0, false, 15));
  eventBase_.runInLoop([&] {
      handler1->txn_->sendBody(makeBuf(4 * 1024));
      handler1->txn_->sendEOM();
      handler2->txn_->sendBody(makeBuf(4 * 1024));
      handler2->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();
  flushRequestsAndLoopN(2);

  // expect 32/32
  EXPECT_CALL(callbacks_, onBody(id1, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024));
  EXPECT_CALL(callbacks_, onMessageComplete(id1, _));
  EXPECT_CALL(callbacks_, onBody(id2, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024));
  EXPECT_CALL(callbacks_, onMessageComplete(id2, _));
  parseOutput(*clientCodec_);

  httpSession_->closeWhenIdle();
  expectDetachSession();
  this->eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestPriorityWeightsTinyWindow
	)

Definition at line 3223 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, and i.

                                                                  {
  httpSession_->setWriteBufferLimit(2 * 65536);
  InSequence enforceOrder;
  auto id1 = sendRequest();
  auto id2 = sendRequest();

  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendReplyWithBody(200, 32 * 1024);
    });
  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler2->sendReplyWithBody(200, 32 * 1024);
    });

  handler1->expectDetachTransaction();

  // twice- once to send and once to receive
  flushRequestsAndLoopN(2);
  EXPECT_CALL(callbacks_, onSettings(_));
  EXPECT_CALL(callbacks_, onMessageBegin(id1, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(id1, _));
  EXPECT_CALL(callbacks_, onMessageBegin(id2, _));
  EXPECT_CALL(callbacks_, onHeadersComplete(id2, _));
  for (auto i = 0; i < 7; i++) {
    EXPECT_CALL(callbacks_, onBody(id1, _, _))
      .WillOnce(ExpectBodyLen(4 * 1024));
    EXPECT_CALL(callbacks_, onBody(id2, _, _))
      .WillOnce(ExpectBodyLen(4 * 1024));
  }
  EXPECT_CALL(callbacks_, onBody(id1, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024 - 1));
  EXPECT_CALL(callbacks_, onBody(id2, _, _))
    .WillOnce(ExpectBodyLen(4 * 1024 - 1));
  EXPECT_CALL(callbacks_, onBody(id1, _, _))
    .WillOnce(ExpectBodyLen(1));
  EXPECT_CALL(callbacks_, onMessageComplete(id1, _));
  parseOutput(*clientCodec_);

  // open the window
  clientCodec_->generateWindowUpdate(requests_, 0, 100);
  handler2->expectDetachTransaction();
  flushRequestsAndLoopN(2);

  EXPECT_CALL(callbacks_, onBody(id2, _, _))
    .WillOnce(ExpectBodyLen(1));
  EXPECT_CALL(callbacks_, onMessageComplete(id2, _));
  parseOutput(*clientCodec_);

  httpSession_->closeWhenIdle();
  expectDetachSession();
  this->eventBase_.loop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestShortContentLength
	)

Definition at line 3280 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::getPostRequest(), proxygen::Exception::getProxygenError(), proxygen::kErrorParseBody, makeBuf(), and streamID.

                                                           {
  auto req = getPostRequest(10);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(20),
                             HTTPCodec::NoPadding, true);
  auto handler1 = addSimpleStrictHandler();

  InSequence enforceOrder;
  handler1->expectHeaders();
  handler1->expectError([&handler1] (const HTTPException& ex) {
      EXPECT_EQ(ex.getProxygenError(), kErrorParseBody);
      handler1->txn_->sendAbort();
    });
  handler1->expectDetachTransaction();
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestBadContentLengthUntieHandler
	)

If handler chooses to untie itself with transaction during onError, detachTransaction shouldn't be expected

Definition at line 3303 of file HTTPDownstreamSessionTest.cpp.

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

                                                                     {
  auto req = getPostRequest(10);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(
      requests_,
      streamID,
      makeBuf(20),
      HTTPCodec::NoPadding,
      true);
  auto handler1 = addSimpleStrictHandler();

  InSequence enforceOrder;
  handler1->expectHeaders();
  handler1->expectError([&] (const HTTPException&) {
      if (handler1->txn_) {
        handler1->txn_->setHandler(nullptr);
      }
      handler1->txn_ = nullptr;
    });
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestLongContentLength
	)

Definition at line 3327 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::getPostRequest(), proxygen::Exception::getProxygenError(), proxygen::kErrorParseBody, makeBuf(), and streamID.

                                                          {
  auto req = getPostRequest(30);
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(20),
                             HTTPCodec::NoPadding, true);
  auto handler1 = addSimpleStrictHandler();

  InSequence enforceOrder;
  handler1->expectHeaders();
  handler1->expectBody();
  handler1->expectError([&handler1] (const HTTPException& ex) {
      EXPECT_EQ(ex.getProxygenError(), kErrorParseBody);
      handler1->txn_->sendAbort();
    });
  handler1->expectDetachTransaction();
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestMalformedContentLength
	)

Definition at line 3347 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getPostRequest(), proxygen::HTTP_HEADER_CONTENT_LENGTH, makeBuf(), and streamID.

                                                               {
  auto req = getPostRequest();
  req.getHeaders().set(HTTP_HEADER_CONTENT_LENGTH, "malformed");
  auto streamID = sendRequest(req, false);
  clientCodec_->generateBody(requests_, streamID, makeBuf(20),
                             HTTPCodec::NoPadding, true);
  auto handler1 = addSimpleStrictHandler();

  InSequence enforceOrder;
  handler1->expectHeaders();
  handler1->expectBody();
  handler1->expectEOM([&handler1] {
      handler1->sendReplyWithBody(200, 100);
    });
  handler1->expectDetachTransaction();
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestHeadContentLength
	)

Definition at line 3367 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getGetRequest().

                                                          {
  InSequence enforceOrder;
  auto req = getGetRequest();
  req.setMethod(HTTPMethod::HEAD);
  sendRequest(req);
  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendHeaders(200, 100);
      // no body for head
      handler1->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		Test304ContentLength
	)

Definition at line 3386 of file HTTPDownstreamSessionTest.cpp.

References proxygen::getGetRequest().

                                                         {
  InSequence enforceOrder;
  auto req = getGetRequest();
  req.setMethod(HTTPMethod::HEAD);
  sendRequest(req);
  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  handler1->expectEOM([&handler1] {
      handler1->sendHeaders(304, 100);
      handler1->txn_->sendEOM();
    });
  handler1->expectDetachTransaction();
  flushRequestsAndLoop();

  gracefulShutdown();
}

TEST_F	(	HTTPDownstreamSessionTest	,
		HttpShortContentLength
	)

Definition at line 3405 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, EXPECT_EQ, proxygen::getPostRequest(), proxygen::Exception::getProxygenError(), proxygen::HTTP_HEADER_TRANSFER_ENCODING, proxygen::kErrorParseBody, makeBuf(), and streamID.

                                                          {
  InSequence enforceOrder;
  auto req = getPostRequest(10);
  req.setIsChunked(true);
  req.getHeaders().add(HTTP_HEADER_TRANSFER_ENCODING, "chunked");
  auto streamID = sendRequest(req, false);
  clientCodec_->generateChunkHeader(requests_, streamID, 20);
  clientCodec_->generateBody(requests_, streamID, makeBuf(20),
                             HTTPCodec::NoPadding, false);
  clientCodec_->generateChunkTerminator(requests_, streamID);
  clientCodec_->generateEOM(requests_, streamID);
  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  EXPECT_CALL(*handler1, onChunkHeader(20));

  handler1->expectError([&handler1] (const HTTPException& ex) {
      EXPECT_EQ(ex.getProxygenError(), kErrorParseBody);
      handler1->txn_->sendAbort();
    });
  handler1->expectDetachTransaction();
  expectDetachSession();
  flushRequestsAndLoop();

}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestSessionStallByFlowControl
	)

Definition at line 3431 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL.

                                                                  {
  NiceMock<MockHTTPSessionStats> stats;
  // By default the send and receive windows are 64K each.
  // If we use only a single transaction, that transaction
  // will be paused on reaching 64K. Therefore, to pause the session,
  // it is used 2 transactions each sending 32K.

  // Make write buffer limit exceding 64K, for example 128K
  httpSession_->setWriteBufferLimit(128 * 1024);
  httpSession_->setSessionStats(&stats);

  InSequence enforceOrder;
  sendRequest();
  sendRequest();

  auto handler1 = addSimpleStrictHandler();

  handler1->expectHeaders();
  handler1->expectEOM([&] {
      handler1->sendReplyWithBody(200, 32 * 1024);
    });

  auto handler2 = addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler2->sendReplyWithBody(200, 32 * 1024);
    });

  EXPECT_CALL(stats, recordSessionStalled()).Times(1);

  handler1->expectDetachTransaction();

  // twice- once to send and once to receive
  flushRequestsAndLoopN(2);

  // open the window
  clientCodec_->generateWindowUpdate(requests_, 0, 100);
  handler2->expectDetachTransaction();
  flushRequestsAndLoopN(2);

  httpSession_->closeWhenIdle();
  expectDetachSession();
  flushRequestsAndLoop();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestTransactionStallByFlowControl
	)

Definition at line 3476 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, EXPECT_CALL, proxygen::Exception::getProxygenError(), handler(), proxygen::kErrorWriteTimeout, streamID, string, and proxygen::Exception::what().

                                                                      {
  StrictMock<MockHTTPSessionStats> stats;

  httpSession_->setSessionStats(&stats);

  // Set the client side stream level flow control wind to 500 bytes,
  // and try to send 1000 bytes through it.
  // Then the flow control kicks in and stalls the transaction.
  clientCodec_->getEgressSettings()->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                                500);
  clientCodec_->generateSettings(requests_);

  auto streamID = sendRequest();

  EXPECT_CALL(stats, recordTransactionOpened());

  InSequence handlerSequence;
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectEOM([&] {
      handler->sendReplyWithBody(200, 1000);
    });

  EXPECT_CALL(stats, recordTransactionStalled());
  handler->expectEgressPaused();

  handler->expectError([&] (const HTTPException& ex) {
      ASSERT_EQ(ex.getProxygenError(), kErrorWriteTimeout);
      ASSERT_EQ(
        folly::to<std::string>("ingress timeout, streamID=", streamID),
        std::string(ex.what()));
      handler->terminate();
    });

  handler->expectDetachTransaction();

  EXPECT_CALL(stats, recordTransactionClosed());

  flushRequestsAndLoop();
  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestTransactionNotStallByFlowControl
	)

Definition at line 3518 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_CALL, and handler().

                                                                         {
  StrictMock<MockHTTPSessionStats> stats;

  httpSession_->setSessionStats(&stats);

  clientCodec_->getEgressSettings()->setSetting(SettingsId::INITIAL_WINDOW_SIZE,
                                                500);
  clientCodec_->generateSettings(requests_);

  sendRequest();

  EXPECT_CALL(stats, recordTransactionOpened());

  InSequence handlerSequence;
  auto handler = addSimpleStrictHandler();
  handler->expectHeaders();
  handler->expectEOM([&] {
      handler->sendReplyWithBody(200, 500);
    });

  // The egtress paused is notified due to existing logics,
  // but egress transaction should not be counted as stalled by flow control,
  // because there is nore more bytes to send
  handler->expectEgressPaused();

  handler->expectDetachTransaction();

  EXPECT_CALL(stats, recordTransactionClosed());

  flushRequestsAndLoop();
  gracefulShutdown();
}

TEST_F	(	HTTP2DownstreamSessionTest	,
		TestSetEgressSettings
	)

Definition at line 3551 of file HTTPDownstreamSessionTest.cpp.

References EXPECT_EQ, proxygen::HTTPSettings::getSetting(), settings, and proxygen::HTTPSetting::value.

                                                          {
  SettingsList settings = {{ SettingsId::HEADER_TABLE_SIZE, 5555 },
                           { SettingsId::MAX_FRAME_SIZE, 16384 },
                           { SettingsId::ENABLE_PUSH, 1 }};

  const HTTPSettings* codecSettings = rawCodec_->getEgressSettings();
  for (const auto& setting: settings) {
    const HTTPSetting* currSetting = codecSettings->getSetting(setting.id);
    if (currSetting) {
      EXPECT_EQ(setting.value, currSetting->value);
    }
  }

  flushRequestsAndLoop();
  gracefulShutdown();
}

TYPED_TEST_CASE_P

(

HTTPDownstreamTest

)

Referenced by TEST_F().

TYPED_TEST_P	(	HTTPDownstreamTest	,
		TestWritesDraining
	)

Definition at line 2296 of file HTTPDownstreamSessionTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, proxygen::getGetRequest(), proxygen::Exception::getProxygenError(), proxygen::kErrorEOF, version, and proxygen::Exception::what().

                                                     {
  auto badCodec =
    makeServerCodec<typename TypeParam::Codec>(TypeParam::version);
  this->sendRequest();
  badCodec->generatePushPromise(this->requests_, 2 /* bad */, getGetRequest(),
                                1);

  this->expectDetachSession();

  InSequence handlerSequence;
  auto handler1 = this->addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM();
  handler1->expectError([&](const HTTPException& ex) {
    ASSERT_EQ(ex.getProxygenError(), kErrorEOF);
    ASSERT_TRUE(
        folly::StringPiece(ex.what()).startsWith("Shutdown transport: EOF"))
        << ex.what();
  });
  handler1->expectDetachTransaction();

  this->flushRequestsAndLoop();
}

TYPED_TEST_P	(	HTTPDownstreamTest	,
		TestBodySizeLimit
	)

Definition at line 2320 of file HTTPDownstreamSessionTest.cpp.

References testing::_, folly::ssl::cleanup(), EXPECT_CALL, i, and uint32_t.

                                                    {
  this->clientCodec_->generateWindowUpdate(this->requests_, 0, 65536);
  this->sendRequest();
  this->sendRequest();

  InSequence handlerSequence;
  auto handler1 = this->addSimpleNiceHandler();
  handler1->expectHeaders();
  handler1->expectEOM();
  auto handler2 = this->addSimpleNiceHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler1->sendReplyWithBody(200, 33000);
      handler2->sendReplyWithBody(200, 33000);
    });
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();

  this->flushRequestsAndLoop();

  std::list<HTTPCodec::StreamID> streams;
  EXPECT_CALL(this->callbacks_, onMessageBegin(1, _));
  EXPECT_CALL(this->callbacks_, onHeadersComplete(1, _));
  EXPECT_CALL(this->callbacks_, onMessageBegin(3, _));
  EXPECT_CALL(this->callbacks_, onHeadersComplete(3, _));
  for (uint32_t i = 0; i < 8; i++) {
    EXPECT_CALL(this->callbacks_, onBody(1, _, _));
    EXPECT_CALL(this->callbacks_, onBody(3, _, _));
  }
  EXPECT_CALL(this->callbacks_, onBody(1, _, _));
  EXPECT_CALL(this->callbacks_, onMessageComplete(1, _));
  EXPECT_CALL(this->callbacks_, onBody(3, _, _));
  EXPECT_CALL(this->callbacks_, onMessageComplete(3, _));

  this->parseOutput(*this->clientCodec_);

  this->cleanup();
}

TYPED_TEST_P	(	HTTPDownstreamTest	,
		TestUniformPauseState
	)

Definition at line 2362 of file HTTPDownstreamSessionTest.cpp.

References folly::ssl::cleanup(), IF_HTTP2, makeBuf(), folly::gen::move, and transport_.

                                                        {
  this->httpSession_->setWriteBufferLimit(12000);
  this->clientCodec_->getEgressSettings()->setSetting(
    SettingsId::INITIAL_WINDOW_SIZE, 1000000);
  this->clientCodec_->generateSettings(this->requests_);
  this->clientCodec_->generateWindowUpdate(this->requests_, 0, 1000000);
  this->sendRequest("/", 1);
  this->sendRequest("/", 1);
  this->sendRequest("/", 2);

  InSequence handlerSequence;
  auto handler1 = this->addSimpleStrictHandler();
  handler1->expectHeaders();
  handler1->expectEOM();
  auto handler2 = this->addSimpleStrictHandler();
  handler2->expectHeaders();
  handler2->expectEOM([&] {
      handler1->sendHeaders(200, 24002);
      // triggers pause of all txns
      this->transport_->pauseWrites();
      handler1->txn_->sendBody(std::move(makeBuf(12001)));
      this->resumeWritesAfterDelay(milliseconds(50));
    });
  handler1->expectEgressPaused();
  handler2->expectEgressPaused();
  auto handler3 = this->addSimpleStrictHandler();
  handler3->expectEgressPaused();
  handler3->expectHeaders();
  handler3->expectEOM();

  handler1->expectEgressResumed([&] {
      // resume does not trigger another pause,
      handler1->txn_->sendBody(std::move(makeBuf(12001)));
    });
  // handler2 gets a fair shot, handler3 is not resumed
  // HTTP/2 priority is not implemented, so handler3 is like another 0 pri txn
  handler2->expectEgressResumed();
  IF_HTTP2(handler3->expectEgressResumed());
  handler1->expectEgressPaused();
  handler2->expectEgressPaused();
  IF_HTTP2(handler3->expectEgressPaused());

  handler1->expectEgressResumed();
  handler2->expectEgressResumed([&] {
      handler2->sendHeaders(200, 12001);
      handler2->txn_->sendBody(std::move(makeBuf(12001)));
      this->transport_->pauseWrites();
      this->resumeWritesAfterDelay(milliseconds(50));
    });
  // handler3 not resumed
  IF_HTTP2(handler3->expectEgressResumed());

  handler1->expectEgressPaused();
  handler2->expectEgressPaused();
  IF_HTTP2(handler3->expectEgressPaused());

  handler1->expectEgressResumed();
  handler2->expectEgressResumed([&] {
      handler1->txn_->sendEOM();
      handler2->txn_->sendEOM();
    });
  handler3->expectEgressResumed([&] {
      handler3->txn_->sendAbort();
    });

  handler3->expectDetachTransaction();
  handler1->expectDetachTransaction();
  handler2->expectDetachTransaction();

  this->flushRequestsAndLoop();

  this->cleanup();
}

TYPED_TEST_P	(	HTTPDownstreamTest	,
		TestMaxTxns
	)

Definition at line 2438 of file HTTPDownstreamSessionTest.cpp.

References testing::_, EXPECT_CALL, handler(), i, folly::gen::move, settings, and streamID.

                                              {
  auto settings = this->rawCodec_->getEgressSettings();
  auto maxTxns = settings->getSetting(SettingsId::MAX_CONCURRENT_STREAMS,
                                      100);
  std::list<unique_ptr<StrictMock<MockHTTPHandler>>> handlers;
  {
    InSequence enforceOrder;
    for (auto i = 0U; i < maxTxns; i++) {
      this->sendRequest();
      auto handler = this->addSimpleStrictHandler();
      handler->expectHeaders();
      handler->expectEOM();
      handlers.push_back(std::move(handler));
    }
    auto streamID = this->sendRequest();
    this->clientCodec_->generateGoaway(this->requests_, 0, ErrorCode::NO_ERROR);

    for (auto& handler: handlers) {
      EXPECT_CALL(*handler, onGoaway(ErrorCode::NO_ERROR));
    }

    this->flushRequestsAndLoop();

    EXPECT_CALL(this->callbacks_, onSettings(_));
    EXPECT_CALL(this->callbacks_, onAbort(streamID, ErrorCode::REFUSED_STREAM));

    this->parseOutput(*this->clientCodec_);
  }
  // handlers can finish out of order?
  for (auto& handler: handlers) {
    handler->sendReplyWithBody(200, 100);
    handler->expectDetachTransaction();
  }
  this->expectDetachSession();
  this->eventBase_.loop();
}