proxygen: proxygen/lib/http/codec/test/HTTP2CodecTest.cpp File Reference

TEST	(	HTTP2CodecConstantsTest	,
		HTTPContantsAreCommonHeaders
	)

Definition at line 29 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::HTTPCommonHeaders::hash(), proxygen::HTTP_HEADER_COLON_AUTHORITY, proxygen::HTTP_HEADER_COLON_METHOD, proxygen::HTTP_HEADER_COLON_PATH, proxygen::HTTP_HEADER_COLON_SCHEME, proxygen::HTTP_HEADER_COLON_STATUS, proxygen::headers::kAuthority, proxygen::headers::kMethod, proxygen::headers::kPath, proxygen::headers::kScheme, and proxygen::headers::kStatus.

                                                             {
   // The purpose of this test is to verify some basic assumptions that should
   // never change but to make clear that the following http2 header constants
   // map to the respective common headers.  Should this test ever fail, the
   // H2Codec would need to be updated in the corresponding places when creating
   // compress/Header objects.
   EXPECT_EQ(HTTPCommonHeaders::hash(headers::kMethod),
             HTTP_HEADER_COLON_METHOD);
   EXPECT_EQ(HTTPCommonHeaders::hash(headers::kScheme),
             HTTP_HEADER_COLON_SCHEME);
   EXPECT_EQ(HTTPCommonHeaders::hash(headers::kPath),
             HTTP_HEADER_COLON_PATH);
   EXPECT_EQ(
     HTTPCommonHeaders::hash(headers::kAuthority),
     HTTP_HEADER_COLON_AUTHORITY);
   EXPECT_EQ(HTTPCommonHeaders::hash(headers::kStatus),
             HTTP_HEADER_COLON_STATUS);
 }

TEST_F	(	HTTP2CodecTest	,
		IgnoreUnknownSettings
	)

Definition at line 65 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, i, proxygen::parse(), settings, uint32_t, and proxygen::http2::writeSettings().

                                               {
   auto numSettings = downstreamCodec_.getIngressSettings()->getNumSettings();
   std::deque<SettingPair> settings;
   for (uint32_t i = 200; i < (200 + 1024); i++) {
     settings.push_back(SettingPair(SettingsId(i), i));
   }
   http2::writeSettings(output_, settings);
   parse();
 
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_EQ(numSettings,
             downstreamCodec_.getIngressSettings()->getNumSettings());
 }

TEST_F	(	HTTP2CodecTest	,
		NoExHeaders
	)

Definition at line 80 of file HTTP2CodecTest.cpp.

References EXPECT_EQ.

                                     {
   // do not emit ENABLE_EX_HEADERS setting, if disabled
   SetUpUpstreamTest();
 
   EXPECT_EQ(callbacks_.settings, 0);
   EXPECT_EQ(callbacks_.numSettings, 0);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 
   parseUpstream();
 
   EXPECT_EQ(callbacks_.settings, 1);
   // only 3 standard settings: HEADER_TABLE_SIZE, ENABLE_PUSH, MAX_FRAME_SIZE.
   EXPECT_EQ(callbacks_.numSettings, 3);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 }

TEST_F	(	HTTP2CodecTest	,
		IgnoreExHeadersSetting
	)

Definition at line 96 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, proxygen::parse(), ptr, and proxygen::http2::writeSettings().

                                                {
   // disable EX_HEADERS on egress
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 0);
   auto ptr = downstreamCodec_.getEgressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(0, ptr->value);
 
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(nullptr, ptr);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 
   // attempt to enable EX_HEADERS on ingress
   http2::writeSettings(output_,
                       {SettingPair(SettingsId::ENABLE_EX_HEADERS, 1)});
   parse();
 
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(nullptr, ptr);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 
   // attempt to disable EX_HEADERS on ingress
   callbacks_.reset();
   http2::writeSettings(output_,
                       {SettingPair(SettingsId::ENABLE_EX_HEADERS, 0)});
   parse();
 
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(nullptr, ptr);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 }

TEST_F	(	HTTP2CodecTest	,
		EnableExHeadersSetting
	)

Definition at line 135 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, proxygen::parse(), ptr, and proxygen::http2::writeSettings().

                                                {
   // enable EX_HEADERS on egress
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 1);
 
   auto ptr = downstreamCodec_.getEgressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(1, ptr->value);
 
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(nullptr, ptr);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 
   // attempt to enable EX_HEADERS on ingress
   http2::writeSettings(output_,
                       {SettingPair(SettingsId::ENABLE_EX_HEADERS, 1)});
   parse();
 
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(1, ptr->value);
   EXPECT_EQ(true, downstreamCodec_.supportsExTransactions());
 
   // attempt to disable EX_HEADERS on ingress
   callbacks_.reset();
   http2::writeSettings(output_,
                       {SettingPair(SettingsId::ENABLE_EX_HEADERS, 0)});
   parse();
 
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   ptr = downstreamCodec_.getIngressSettings()->getSetting(
       SettingsId::ENABLE_EX_HEADERS);
   EXPECT_EQ(0, ptr->value);
   EXPECT_EQ(false, downstreamCodec_.supportsExTransactions());
 }

TEST_F	(	HTTP2CodecTest	,
		InvalidExHeadersSetting
	)

Definition at line 175 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, proxygen::parse(), and proxygen::http2::writeSettings().

                                                 {
   // enable EX_HEADERS on egress
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 1);
 
   // attempt to set a invalid ENABLE_EX_HEADERS value
   http2::writeSettings(output_,
                       {SettingPair(SettingsId::ENABLE_EX_HEADERS, 110)});
   parse();
 
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicHeader
	)

Definition at line 188 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_USER_AGENT, proxygen::parse(), and proxygen::HTTPMessage::setSecure().

                                     {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   req.getHeaders().add("tab-hdr", "coolio\tv2");
   // Connection header will get dropped
   req.getHeaders().add(HTTP_HEADER_CONNECTION, "Love");
   req.setSecure(true);
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
 
   parse();
   callbacks_.expectMessage(true, 3, "/guacamole");
   EXPECT_TRUE(callbacks_.msg->isSecure());
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ("coolio", headers.getSingleOrEmpty(HTTP_HEADER_USER_AGENT));
   EXPECT_EQ("coolio\tv2", headers.getSingleOrEmpty("tab-hdr"));
   EXPECT_EQ("www.foo.com", headers.getSingleOrEmpty(HTTP_HEADER_HOST));
 }

TEST_F	(	HTTP2CodecTest	,
		RequestFromServer
	)

Definition at line 206 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_USER_AGENT, folly::Random::rand32(), and proxygen::http2::writeSettings().

                                           {
   // this is to test EX_HEADERS frame, which carrys the HTTP request initiated
   // by server side
   upstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 1);
   SetUpUpstreamTest();
   proxygen::http2::writeSettings(
       output_, {{proxygen::SettingsId::ENABLE_EX_HEADERS, 1}});
 
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   req.getHeaders().add("tab-hdr", "coolio\tv2");
   // Connection header will get dropped
   req.getHeaders().add(HTTP_HEADER_CONNECTION, "Love");
   req.setSecure(true);
 
   HTTPCodec::StreamID stream = folly::Random::rand32(10, 1024) * 2;
   HTTPCodec::StreamID controlStream = folly::Random::rand32(10, 1024) * 2 + 1;
   upstreamCodec_.generateExHeader(output_, stream, req,
                                   HTTPCodec::ExAttributes(controlStream, true),
                                   true);
 
   parseUpstream();
   EXPECT_EQ(controlStream, callbacks_.controlStreamId);
   EXPECT_TRUE(callbacks_.isUnidirectional);
   callbacks_.expectMessage(true, 3, "/guacamole");
   EXPECT_TRUE(callbacks_.msg->isSecure());
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ("coolio", headers.getSingleOrEmpty(HTTP_HEADER_USER_AGENT));
   EXPECT_EQ("coolio\tv2", headers.getSingleOrEmpty("tab-hdr"));
   EXPECT_EQ("www.foo.com", headers.getSingleOrEmpty(HTTP_HEADER_HOST));
 }

TEST_F	(	HTTP2CodecTest	,
		ResponseFromClient
	)

Definition at line 239 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, EXPECT_TRUE, proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, proxygen::parse(), folly::Random::rand32(), proxygen::HTTPMessage::setStatusCode(), and proxygen::http2::writeSettings().

                                            {
   // this is to test EX_HEADERS frame, which carrys the HTTP response replied by
   // client side
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 1);
   proxygen::http2::writeSettings(
       output_, {{proxygen::SettingsId::ENABLE_EX_HEADERS, 1}});
 
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
 
   HTTPCodec::StreamID stream = folly::Random::rand32(10, 1024) * 2;
   HTTPCodec::StreamID controlStream = folly::Random::rand32(10, 1024) * 2 + 1;
   downstreamCodec_.generateExHeader(output_, stream, resp,
     HTTPCodec::ExAttributes(controlStream, true), true);
 
   parse();
   EXPECT_EQ(controlStream, callbacks_.controlStreamId);
   EXPECT_TRUE(callbacks_.isUnidirectional);
   EXPECT_EQ("OK", callbacks_.msg->getStatusMessage());
   callbacks_.expectMessage(true, 2, 200);
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ("OK", callbacks_.msg->getStatusMessage());
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
   EXPECT_EQ("x-coolio", headers.getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE));
 }

TEST_F	(	HTTP2CodecTest	,
		ExHeadersWithPriority
	)

Definition at line 268 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, proxygen::getGetRequest(), proxygen::parse(), and proxygen::http2::writeSettings().

                                               {
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 1);
   proxygen::http2::writeSettings(
       output_, {{proxygen::SettingsId::ENABLE_EX_HEADERS, 1}});
 
   auto req = getGetRequest();
   auto pri = HTTPMessage::HTTPPriority(0, false, 7);
   req.setHTTP2Priority(pri);
   upstreamCodec_.generateExHeader(output_, 3, req,
                                   HTTPCodec::ExAttributes(1, true));
 
   parse();
   EXPECT_EQ(callbacks_.msg->getHTTP2Priority(), pri);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		IgnoreExHeadersIfNotEnabled
	)

Definition at line 286 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_EX_HEADERS, EXPECT_EQ, proxygen::getGetRequest(), and proxygen::parse().

                                                     {
   downstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_EX_HEADERS, 0);
 
   HTTPMessage req = getGetRequest("/guacamole");
   downstreamCodec_.generateExHeader(output_, 3, req,
                                     HTTPCodec::ExAttributes(1, true));
 
   parse();
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadHeaders
	)

Definition at line 299 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, h, i, proxygen::headers::kAuthority, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kScheme, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, v, and proxygen::http2::writeHeaders().

                                    {
   static const std::string v1("GET");
   static const std::string v2("/");
   static const std::string v3("http");
   static const std::string v4("foo.com");
   static const vector<proxygen::compress::Header> reqHeaders = {
     Header::makeHeaderForTest(headers::kMethod, v1),
     Header::makeHeaderForTest(headers::kPath, v2),
     Header::makeHeaderForTest(headers::kScheme, v3),
     Header::makeHeaderForTest(headers::kAuthority, v4),
   };
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   HTTPCodec::StreamID stream = 1;
   // missing fields (missing authority is OK)
   for (size_t i = 0; i < reqHeaders.size(); i++, stream += 2) {
     std::vector<proxygen::compress::Header> allHeaders = reqHeaders;
     allHeaders.erase(allHeaders.begin() + i);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
   // dup fields
   std::string v("foomonkey");
   for (size_t i = 0; i < reqHeaders.size(); i++, stream += 2) {
     std::vector<proxygen::compress::Header> allHeaders = reqHeaders;
     auto h = allHeaders[i];
     h.value = &v;
     allHeaders.push_back(h);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 7);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadPseudoHeaders
	)

Definition at line 351 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kScheme, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                          {
   static const std::string v1("POST");
   static const std::string v2("http");
   static const std::string n3("foo");
   static const std::string v3("bar");
   static const std::string v4("/");
   static const vector<proxygen::compress::Header> reqHeaders = {
     Header::makeHeaderForTest(headers::kMethod, v1),
     Header::makeHeaderForTest(headers::kScheme, v2),
     Header::makeHeaderForTest(n3, v3),
     Header::makeHeaderForTest(headers::kPath, v4),
   };
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   HTTPCodec::StreamID stream = 1;
   std::vector<proxygen::compress::Header> allHeaders = reqHeaders;
   auto encodedHeaders = headerCodec.encode(allHeaders);
   http2::writeHeaders(output_,
                       std::move(encodedHeaders),
                       stream,
                       folly::none,
                       http2::kNoPadding,
                       true,
                       true);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadHeaderValues
	)

Definition at line 384 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, i, proxygen::headers::kAuthority, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kScheme, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                         {
   static const std::string v1("--1");
   static const std::string v2("\13\10protocol-attack");
   static const std::string v3("\13");
   static const std::string v4("abc.com\\13\\10");
   static const vector<proxygen::compress::Header> reqHeaders = {
     Header::makeHeaderForTest(headers::kMethod, v1),
     Header::makeHeaderForTest(headers::kPath, v2),
     Header::makeHeaderForTest(headers::kScheme, v3),
     Header::makeHeaderForTest(headers::kAuthority, v4),
   };
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   HTTPCodec::StreamID stream = 1;
   for (size_t i = 0; i < reqHeaders.size(); i++, stream += 2) {
     std::vector<proxygen::compress::Header> allHeaders;
     allHeaders.push_back(reqHeaders[i]);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 4);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		EmptyHeaderName
	)

Definition at line 429 of file HTTP2CodecTest.cpp.

References fizz::test::copyBuffer(), EXPECT_EQ, kBufEmptyHeader, and proxygen::parse().

                                         {
   output_.append(IOBuf::copyBuffer(kBufEmptyHeader, sizeof(kBufEmptyHeader)));
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicConnect
	)

Definition at line 439 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::CONNECT, EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_HOST, proxygen::parse(), proxygen::HTTPMessage::setMethod(), and string.

                                      {
   std::string authority = "myhost:1234";
   HTTPMessage request;
   request.setMethod(HTTPMethod::CONNECT);
   request.getHeaders().add(proxygen::HTTP_HEADER_HOST, authority);
   upstreamCodec_.generateHeader(output_, 1, request, false /* eom */);
 
   parse();
   callbacks_.expectMessage(false, 1, "");
   EXPECT_EQ(HTTPMethod::CONNECT, callbacks_.msg->getMethod());
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ(authority, headers.getSingleOrEmpty(proxygen::HTTP_HEADER_HOST));
 }

TEST_F	(	HTTP2CodecTest	,
		BadConnect
	)

Definition at line 453 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, i, proxygen::headers::kAuthority, proxygen::headers::kHttp, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kScheme, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                    {
   std::string v1 = "CONNECT";
   std::string v2 = "somehost:576";
   std::vector<proxygen::compress::Header> goodHeaders = {
     Header::makeHeaderForTest(headers::kMethod, v1),
     Header::makeHeaderForTest(headers::kAuthority, v2),
   };
 
   // See https://tools.ietf.org/html/rfc7540#section-8.3
   std::string v3 = "/foobar";
   std::vector<proxygen::compress::Header> badHeaders = {
     Header::makeHeaderForTest(headers::kScheme, headers::kHttp),
     Header::makeHeaderForTest(headers::kPath, v3),
   };
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   HTTPCodec::StreamID stream = 1;
 
   for (size_t i = 0; i < badHeaders.size(); i++, stream += 2) {
     auto allHeaders = goodHeaders;
     allHeaders.push_back(badHeaders[i]);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, badHeaders.size());
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		NormalSizeHeader
	)

Definition at line 539 of file HTTP2CodecTest.cpp.

                                          {
   testHeaderListSize(false);
 }

TEST_F	(	HTTP2CodecTest	,
		OversizedHeader
	)

Definition at line 543 of file HTTP2CodecTest.cpp.

                                         {
   testHeaderListSize(true);
 }

TEST_F	(	HTTP2CodecTest	,
		NormalSizeFrame
	)

Definition at line 547 of file HTTP2CodecTest.cpp.

                                         {
   testFrameSizeLimit(false);
 }

TEST_F	(	HTTP2CodecTest	,
		OversizedFrame
	)

Definition at line 551 of file HTTP2CodecTest.cpp.

                                        {
   testFrameSizeLimit(true);
 }

TEST_F	(	HTTP2CodecTest	,
		BigHeaderCompressed
	)

Definition at line 555 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_USER_AGENT, proxygen::MAX_HEADER_LIST_SIZE, proxygen::parse(), and settings.

                                             {
   SetUpUpstreamTest();
   auto settings = downstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::MAX_HEADER_LIST_SIZE, 37);
   downstreamCodec_.generateSettings(output_);
   parseUpstream();
 
   SetUp();
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
 
   parse();
   // session error
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicHeaderReply
	)

Definition at line 577 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setStatusMessage().

                                          {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   downstreamCodec_.generateHeader(output_, 1, resp);
   downstreamCodec_.generateEOM(output_, 1);
 
   parseUpstream();
   callbacks_.expectMessage(true, 2, 200);
   const auto& headers = callbacks_.msg->getHeaders();
   // HTTP/2 doesnt support serialization - instead you get the default
   EXPECT_EQ("OK", callbacks_.msg->getStatusMessage());
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
   EXPECT_EQ("x-coolio", headers.getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE));
 }

TEST_F	(	HTTP2CodecTest	,
		BadHeadersReply
	)

Definition at line 595 of file HTTP2CodecTest.cpp.

References proxygen::DOWNSTREAM, proxygen::HPACKCodec::encode(), EXPECT_EQ, h, i, proxygen::http2::kNoPadding, proxygen::headers::kStatus, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, v, and proxygen::http2::writeHeaders().

                                         {
   static const std::string v1("200");
   static const vector<proxygen::compress::Header> respHeaders = {
     Header::makeHeaderForTest(headers::kStatus, v1),
   };
 
   HPACKCodec headerCodec(TransportDirection::DOWNSTREAM);
   HTTPCodec::StreamID stream = 1;
   // missing fields (missing authority is OK)
   for (size_t i = 0; i < respHeaders.size(); i++, stream += 2) {
     std::vector<proxygen::compress::Header> allHeaders = respHeaders;
     allHeaders.erase(allHeaders.begin() + i);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
   // dup fields
   std::string v("foomonkey");
   for (size_t i = 0; i < respHeaders.size(); i++, stream += 2) {
     std::vector<proxygen::compress::Header> allHeaders = respHeaders;
     auto h = allHeaders[i];
     h.value = &v;
     allHeaders.push_back(h);
     auto encodedHeaders = headerCodec.encode(allHeaders);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         true,
                         true);
   }
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 2);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		Cookies
	)

Definition at line 641 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::parse(), and proxygen::HTTPMessage::setSecure().

                                 {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add("Cookie", "chocolate-chip=1");
   req.getHeaders().add("Cookie", "rainbow-chip=2");
   req.getHeaders().add("Cookie", "butterscotch=3");
   req.getHeaders().add("Cookie", "oatmeal-raisin=4");
   req.setSecure(true);
   upstreamCodec_.generateHeader(output_, 1, req);
 
   parse();
   callbacks_.expectMessage(false, 2, "/guacamole");
   EXPECT_EQ(callbacks_.msg->getCookie("chocolate-chip"), "1");
   EXPECT_EQ(callbacks_.msg->getCookie("rainbow-chip"), "2");
   EXPECT_EQ(callbacks_.msg->getCookie("butterscotch"), "3");
   EXPECT_EQ(callbacks_.msg->getCookie("oatmeal-raisin"), "4");
 }

TEST_F	(	HTTP2CodecTest	,
		BasicContinuation
	)

Definition at line 658 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_GT, proxygen::getBigGetRequest(), proxygen::HTTP_HEADER_USER_AGENT, and proxygen::parse().

                                           {
   HTTPMessage req = getBigGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req);
 
   parse();
   callbacks_.expectMessage(false, -1, "/");
 #ifndef NDEBUG
   EXPECT_GT(downstreamCodec_.getReceivedFrameCount(), 1);
 #endif
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ("coolio", headers.getSingleOrEmpty(HTTP_HEADER_USER_AGENT));
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicContinuationEndStream
	)

Definition at line 676 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_GT, proxygen::getBigGetRequest(), proxygen::HTTP_HEADER_USER_AGENT, and proxygen::parse().

                                                    {
   // CONTINUATION with END_STREAM flag set on the preceding HEADERS frame
   HTTPMessage req = getBigGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
 
   parse();
   callbacks_.expectMessage(true, -1, "/");
 #ifndef NDEBUG
   EXPECT_GT(downstreamCodec_.getReceivedFrameCount(), 1);
 #endif
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ("coolio", headers.getSingleOrEmpty(HTTP_HEADER_USER_AGENT));
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadContinuation
	)

Definition at line 695 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::makeBuf(), folly::gen::move, proxygen::parse(), and proxygen::http2::writeContinuation().

                                         {
   // CONTINUATION with no preceding HEADERS
   auto fakeHeaders = makeBuf(5);
   http2::writeContinuation(output_, 3, true, std::move(fakeHeaders));
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		MissingContinuation
	)

Definition at line 708 of file HTTP2CodecTest.cpp.

References proxygen::ENHANCE_YOUR_CALM, EXPECT_EQ, proxygen::getBigGetRequest(), proxygen::http2::kFrameHeaderSize, gmock_output_test::output, proxygen::parse(), and proxygen::http2::writeGoaway().

                                             {
   IOBufQueue output(IOBufQueue::cacheChainLength());
   HTTPMessage req = getBigGetRequest();
 
   upstreamCodec_.generateHeader(output_, 1, req);
   // empirically determined the size of continuation frame, and strip it
   output_.trimEnd(http2::kFrameHeaderSize + 4134);
 
   // insert a non-continuation (but otherwise valid) frame
   http2::writeGoaway(output_, 17, ErrorCode::ENHANCE_YOUR_CALM);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 2);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		MissingContinuationBadFrame
	)

Definition at line 730 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::getBigGetRequest(), proxygen::http2::kFrameHeaderSize, proxygen::makeBuf(), folly::gen::move, gmock_output_test::output, proxygen::parse(), and uint32_t.

                                                     {
   IOBufQueue output(IOBufQueue::cacheChainLength());
   HTTPMessage req = getBigGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req);
 
   // empirically determined the size of continuation frame, and fake it
   output_.trimEnd(http2::kFrameHeaderSize + 4134);
 
   // insert an invalid frame
   auto frame = makeBuf(http2::kFrameHeaderSize + 4134);
   *((uint32_t *)frame->writableData()) = 0xfa000000;
   output_.append(std::move(frame));
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 2);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		BadContinuationStream
	)

Definition at line 754 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::getBigGetRequest(), proxygen::http2::kFrameHeaderSize, proxygen::makeBuf(), folly::gen::move, proxygen::parse(), and proxygen::http2::writeContinuation().

                                               {
   HTTPMessage req = getBigGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req);
 
   // empirically determined the size of continuation frame, and fake it
   output_.trimEnd(http2::kFrameHeaderSize + 4134);
   auto fakeHeaders = makeBuf(4134);
   http2::writeContinuation(output_, 3, true, std::move(fakeHeaders));
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 2);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		FrameTooLarge
	)

Definition at line 774 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, proxygen::FRAME_SIZE_ERROR, proxygen::parse(), and writeFrameHeaderManual().

                                       {
   writeFrameHeaderManual(output_, 1 << 15, 0, 0, 1);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
   EXPECT_TRUE(callbacks_.lastParseError->hasCodecStatusCode());
   EXPECT_EQ(callbacks_.lastParseError->getCodecStatusCode(),
             ErrorCode::FRAME_SIZE_ERROR);
 }

TEST_F	(	HTTP2CodecTest	,
		UnknownFrameType
	)

Definition at line 788 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_USER_AGENT, proxygen::parse(), and writeFrameHeaderManual().

                                          {
   HTTPMessage req = getGetRequest();
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
 
   // unknown frame type 17
   writeFrameHeaderManual(output_, 17, 37, 0, 1);
   output_.append("wicked awesome!!!");
   upstreamCodec_.generateHeader(output_, 1, req);
 
   parse();
   callbacks_.expectMessage(false, 2, ""); // + host
 }

TEST_F	(	HTTP2CodecTest	,
		JunkAfterConnError
	)

Definition at line 801 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::http2::HEADERS, proxygen::HTTP_HEADER_USER_AGENT, proxygen::parse(), uint8_t, and writeFrameHeaderManual().

                                            {
   HTTPMessage req = getGetRequest();
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
 
   // write headers frame for stream 0
   writeFrameHeaderManual(output_, 0, (uint8_t)http2::FrameType::HEADERS, 0, 0);
   // now write a valid headers frame, should never be parsed
   upstreamCodec_.generateHeader(output_, 1, req);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicData
	)

Definition at line 818 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), data, EXPECT_EQ, folly::gen::move, proxygen::HTTPCodec::NoPadding, and proxygen::parse().

                                   {
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   upstreamCodec_.generateBody(output_, 2, std::move(buf),
                               HTTPCodec::NoPadding, true);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, 5);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), data);
 }

TEST_F	(	HTTP2CodecTest	,
		LongData
	)

Definition at line 835 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::makeBuf(), proxygen::MAX_FRAME_SIZE, proxygen::HTTPCodec::NoPadding, proxygen::parse(), proxygen::HTTPSettings::setSetting(), and settings.

                                  {
   // Hack the max frame size artificially low
   HTTPSettings* settings = (HTTPSettings*)upstreamCodec_.getIngressSettings();
   settings->setSetting(SettingsId::MAX_FRAME_SIZE, 16);
   auto buf = makeBuf(100);
   upstreamCodec_.generateBody(output_, 1, buf->clone(), HTTPCodec::NoPadding,
                               true);
 
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 7);
   EXPECT_EQ(callbacks_.bodyLength, 100);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), buf->moveToFbString());
 }

TEST_F	(	HTTP2CodecTest	,
		MalformedPaddingLength
	)

Definition at line 854 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, proxygen::parse(), and uint8_t.

                                                {
   const uint8_t badInput[] = {0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54,
                               0x54, 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x0d, 0x0a,
                               0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a, 0x0d, 0x0a,
                               0x00, 0x00, 0x7e, 0x00, 0x6f, 0x6f, 0x6f, 0x6f,
                               // The padding length byte below is 0x82 (130
                               // in decimal) which is greater than the length
                               // specified by the header's length field, 126
                               0x01, 0x82, 0x87, 0x44, 0x87, 0x92, 0x97, 0x92,
                               0x92, 0x92, 0x7a, 0x0b, 0x41, 0x89, 0xf1, 0xe3,
                               0xc0, 0xf2, 0x9c, 0xdd, 0x90, 0xf4, 0xff, 0x40,
                               0x80, 0x84, 0x2d, 0x35, 0xa7, 0xd7};
   output_.clear();
   output_.append(badInput, sizeof(badInput));
   EXPECT_EQ(output_.chainLength(), sizeof(badInput));
 
   EXPECT_FALSE(parse());
 }

TEST_F	(	HTTP2CodecTest	,
		MalformedPadding
	)

Definition at line 873 of file HTTP2CodecTest.cpp.

References EXPECT_FALSE, proxygen::parse(), and uint8_t.

                                          {
   const uint8_t badInput[] = {
     0x00, 0x00, 0x0d, 0x01, 0xbe, 0x63, 0x0d, 0x0a, 0x0d, 0x0a, 0x00, 0x73,
     0x00, 0x00, 0x06, 0x08, 0x72, 0x00, 0x24, 0x00, 0xfa, 0x4d, 0x0d
   };
   output_.append(badInput, sizeof(badInput));
 
   EXPECT_FALSE(parse());
 }

TEST_F	(	HTTP2CodecTest	,
		NoAppByte
	)

Definition at line 883 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, proxygen::parse(), and uint8_t.

                                   {
   const uint8_t noAppByte[] = {0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54,
                                0x54, 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x0d, 0x0a,
                                0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a, 0x0d, 0x0a,
                                0x00, 0x00, 0x56, 0x00, 0x5d, 0x00, 0x00, 0x00,
                                0x01, 0x55, 0x00};
   output_.clear();
   output_.append(noAppByte, sizeof(noAppByte));
   EXPECT_EQ(output_.chainLength(), sizeof(noAppByte));
 
   EXPECT_TRUE(parse());
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		DataFramePartialDataOnFrameHeaderCall
	)

Definition at line 903 of file HTTP2CodecTest.cpp.

References testing::_, fizz::test::copyBuffer(), EXPECT_CALL, EXPECT_EQ, and proxygen::makeBuf().

                                                               {
   using namespace testing;
   NiceMock<MockHTTPCodecCallback> mockCallback;
   EXPECT_CALL(mockCallback, onFrameHeader(_, _, _, _, _));
 
   const size_t bufSize = 10;
   auto buf = makeBuf(bufSize);
   const size_t padding = 10;
   upstreamCodec_.generateBody(output_, 1, buf->clone(), padding, true);
   EXPECT_EQ(output_.chainLength(), 54);
 
   downstreamCodec_.setCallback(&mockCallback);
 
   auto ingress = output_.move();
   ingress->coalesce();
   // Copy partial byte to a new buffer
   auto ingress1 = IOBuf::copyBuffer(ingress->data(), 34);
   downstreamCodec_.onIngress(*ingress1);
 }

TEST_F	(	HTTP2CodecTest	,
		DataFramePartialDataWithNoAppByte
	)

Definition at line 923 of file HTTP2CodecTest.cpp.

References fizz::test::copyBuffer(), EXPECT_EQ, and proxygen::makeBuf().

                                                           {
   const size_t bufSize = 10;
   auto buf = makeBuf(bufSize);
   const size_t padding = 10;
   upstreamCodec_.generateBody(output_, 1, buf->clone(), padding, true);
   EXPECT_EQ(output_.chainLength(), 54);
 
   auto ingress = output_.move();
   ingress->coalesce();
   // Copy up to the padding length byte to a new buffer
   auto ingress1 = IOBuf::copyBuffer(ingress->data(), 34);
   size_t parsed = downstreamCodec_.onIngress(*ingress1);
   // The 34th byte is the padding length byte which should not be parsed
   EXPECT_EQ(parsed, 33);
   // Copy from the padding length byte to the end
   auto ingress2 = IOBuf::copyBuffer(ingress->data() + 33, 21);
   parsed = downstreamCodec_.onIngress(*ingress2);
   // The padding length byte should be parsed this time along with 10 bytes of
   // application data and 10 bytes of padding
   EXPECT_EQ(parsed, 21);
 
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, bufSize);
   // Total padding is the padding length byte and the padding bytes
   EXPECT_EQ(callbacks_.paddingBytes, padding + 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), buf->moveToFbString());
 }

TEST_F	(	HTTP2CodecTest	,
		BasicRst
	)

Definition at line 956 of file HTTP2CodecTest.cpp.

References proxygen::ENHANCE_YOUR_CALM, EXPECT_EQ, and proxygen::parse().

                                  {
   upstreamCodec_.generateRstStream(output_, 2, ErrorCode::ENHANCE_YOUR_CALM);
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.bodyCalls, 0);
   EXPECT_EQ(callbacks_.aborts, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicRstInvalidCode
	)

Definition at line 968 of file HTTP2CodecTest.cpp.

References proxygen::_SPDY_INVALID_STREAM, EXPECT_EQ, and proxygen::parse().

                                             {
   upstreamCodec_.generateRstStream(output_, 2, ErrorCode::_SPDY_INVALID_STREAM);
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.bodyCalls, 0);
   EXPECT_EQ(callbacks_.aborts, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicPing
	)

Definition at line 980 of file HTTP2CodecTest.cpp.

References c, EXPECT_EQ, proxygen::http2::kConnectionPreface, proxygen::http2::kFrameHeaderSize, proxygen::parse(), folly::io::detail::CursorBase< Derived, BufType >::read(), folly::io::detail::CursorBase< Derived, BufType >::skip(), and uint64_t.

                                   {
   upstreamCodec_.generatePingRequest(output_);
   upstreamCodec_.generatePingReply(output_, 17);
 
   uint64_t pingReq;
   parse([&] (IOBuf* ingress) {
       folly::io::Cursor c(ingress);
       c.skip(http2::kFrameHeaderSize + http2::kConnectionPreface.length());
       pingReq = c.read<uint64_t>();
     });
 
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.bodyCalls, 0);
   EXPECT_EQ(callbacks_.recvPingRequest, pingReq);
   EXPECT_EQ(callbacks_.recvPingReply, 17);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicWindow
	)

Definition at line 1001 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::http2::kMaxWindowUpdateSize, and proxygen::parse().

                                     {
   // This test would fail if the codec had window state
   upstreamCodec_.generateWindowUpdate(output_, 0, 10);
   upstreamCodec_.generateWindowUpdate(output_, 0, http2::kMaxWindowUpdateSize);
   upstreamCodec_.generateWindowUpdate(output_, 1, 12);
   upstreamCodec_.generateWindowUpdate(output_, 1, http2::kMaxWindowUpdateSize);
 
   parse();
   EXPECT_EQ(callbacks_.windowUpdateCalls, 4);
   EXPECT_EQ(callbacks_.windowUpdates[0],
             std::vector<uint32_t>({10, http2::kMaxWindowUpdateSize}));
   EXPECT_EQ(callbacks_.windowUpdates[1],
             std::vector<uint32_t>({12, http2::kMaxWindowUpdateSize}));
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		ZeroWindow
	)

Definition at line 1018 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::http2::kFrameWindowUpdateSize, proxygen::parse(), proxygen::PROTOCOL_ERROR, streamID, uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

                                    {
   auto streamID = HTTPCodec::StreamID(1);
   // 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
   upstreamCodec_.generateWindowUpdate(output_, streamID, 1);
   output_.trimEnd(http2::kFrameWindowUpdateSize);
   QueueAppender appender(&output_, http2::kFrameWindowUpdateSize);
   appender.writeBE<uint32_t>(0);
 
   parse();
   // This test doesn't ensure that RST_STREAM is generated
   EXPECT_EQ(callbacks_.windowUpdateCalls, 0);
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.lastParseError->getCodecStatusCode(),
       ErrorCode::PROTOCOL_ERROR);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicGoaway
	)

Definition at line 1035 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), proxygen::ENHANCE_YOUR_CALM, EXPECT_EQ, folly::gen::move, and proxygen::parse().

                                     {
   std::unique_ptr<folly::IOBuf> debugData =
     folly::IOBuf::copyBuffer("debugData");
   upstreamCodec_.generateGoaway(output_, 17, ErrorCode::ENHANCE_YOUR_CALM,
                                 std::move(debugData));
 
   parse();
   EXPECT_EQ(callbacks_.goaways, 1);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), "debugData");
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadGoaway
	)

Definition at line 1048 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), proxygen::ENHANCE_YOUR_CALM, EXPECT_DEATH_NO_CORE, and folly::gen::move.

                                   {
   std::unique_ptr<folly::IOBuf> debugData =
     folly::IOBuf::copyBuffer("debugData");
   upstreamCodec_.generateGoaway(output_, 17, ErrorCode::ENHANCE_YOUR_CALM,
                                 std::move(debugData));
   EXPECT_DEATH_NO_CORE(upstreamCodec_.generateGoaway(
                          output_, 27, ErrorCode::ENHANCE_YOUR_CALM), ".*");
 }

TEST_F	(	HTTP2CodecTest	,
		DoubleGoaway
	)

Definition at line 1057 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, max, proxygen::NO_ERROR, and proxygen::parse().

                                      {
   parse();
   SetUpUpstreamTest();
   downstreamCodec_.generateGoaway(output_, std::numeric_limits<int32_t>::max(),
                                   ErrorCode::NO_ERROR);
   EXPECT_TRUE(downstreamCodec_.isWaitingToDrain());
   EXPECT_TRUE(downstreamCodec_.isReusable());
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(2));
   downstreamCodec_.generateGoaway(output_, 0, ErrorCode::NO_ERROR);
   EXPECT_FALSE(downstreamCodec_.isWaitingToDrain());
   EXPECT_FALSE(downstreamCodec_.isReusable());
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_FALSE(downstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(2));
 
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(2));
   parseUpstream();
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_FALSE(upstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(2));
   EXPECT_EQ(callbacks_.goaways, 2);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 
   upstreamCodec_.generateGoaway(output_, 0, ErrorCode::NO_ERROR);
   EXPECT_TRUE(upstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_FALSE(upstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_FALSE(upstreamCodec_.isStreamIngressEgressAllowed(2));
   parse();
   EXPECT_TRUE(downstreamCodec_.isStreamIngressEgressAllowed(0));
   EXPECT_FALSE(downstreamCodec_.isStreamIngressEgressAllowed(1));
   EXPECT_FALSE(downstreamCodec_.isStreamIngressEgressAllowed(2));
 }

TEST_F	(	HTTP2CodecTest	,
		DoubleGoawayWithError
	)

Definition at line 1095 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), proxygen::ENHANCE_YOUR_CALM, EXPECT_EQ, EXPECT_FALSE, max, folly::gen::move, and proxygen::NO_ERROR.

                                               {
   SetUpUpstreamTest();
   std::unique_ptr<folly::IOBuf> debugData =
     folly::IOBuf::copyBuffer("debugData");
   downstreamCodec_.generateGoaway(output_, std::numeric_limits<int32_t>::max(),
                                   ErrorCode::ENHANCE_YOUR_CALM,
                                   std::move(debugData));
   EXPECT_FALSE(downstreamCodec_.isWaitingToDrain());
   EXPECT_FALSE(downstreamCodec_.isReusable());
   auto ret = downstreamCodec_.generateGoaway(output_, 0,
                                              ErrorCode::NO_ERROR);
   EXPECT_EQ(ret, 0);
 
   parseUpstream();
   EXPECT_EQ(callbacks_.goaways, 1);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), "debugData");
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		GoawayHandling
	)

Definition at line 1115 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::CANCEL, wangle::HTTPHeaderSize::compressed, proxygen::http2::DATA, dummy(), proxygen::ENABLE_PUSH, EXPECT_EQ, EXPECT_GT, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::makeBuf(), proxygen::NO_ERROR, proxygen::HTTPCodec::NoPadding, proxygen::parse(), proxygen::HTTPMessage::setStatusCode(), settings, folly::size(), uint8_t, wangle::HTTPHeaderSize::uncompressed, and writeFrameHeaderManual().

                                        {
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::ENABLE_PUSH, 1);
   upstreamCodec_.generateSettings(output_);
 
   // send request
   HTTPMessage req = getGetRequest();
   HTTPHeaderSize size;
   size.uncompressed = size.compressed = 0;
   upstreamCodec_.generateHeader(output_, 1, req, true, &size);
   EXPECT_GT(size.uncompressed, 0);
   parse();
   callbacks_.expectMessage(true, 1, "/");
   callbacks_.reset();
 
   SetUpUpstreamTest();
   // drain after this message
   downstreamCodec_.generateGoaway(output_, 1, ErrorCode::NO_ERROR);
   parseUpstream();
   // upstream cannot generate id > 1
   upstreamCodec_.generateHeader(output_, 3, req, false, &size);
   EXPECT_EQ(size.uncompressed, 0);
   upstreamCodec_.generateWindowUpdate(output_, 3, 100);
   upstreamCodec_.generateBody(output_, 3, makeBuf(10), HTTPCodec::NoPadding,
                               false);
   upstreamCodec_.generatePriority(output_, 3,
                                   HTTPMessage::HTTPPriority(0, true, 1));
   upstreamCodec_.generateEOM(output_, 3);
   upstreamCodec_.generateRstStream(output_, 3, ErrorCode::CANCEL);
   EXPECT_EQ(output_.chainLength(), 0);
 
   // send a push promise that will be rejected by downstream
   req.getHeaders().add("foomonkey", "george");
   downstreamCodec_.generatePushPromise(output_, 2, req, 1, false, &size);
   EXPECT_GT(size.uncompressed, 0);
   HTTPMessage resp;
   resp.setStatusCode(200);
   // send a push response that will be ignored
   downstreamCodec_.generateHeader(output_, 2, resp, false, &size);
   // window update for push doesn't make any sense, but whatever
   downstreamCodec_.generateWindowUpdate(output_, 2, 100);
   downstreamCodec_.generateBody(output_, 2, makeBuf(10), HTTPCodec::NoPadding,
                                 false);
   writeFrameHeaderManual(output_, 20, (uint8_t)http2::FrameType::DATA, 0, 2);
   output_.append(makeBuf(10));
 
   // tell the upstream no pushing, and parse the first batch
   IOBufQueue dummy;
   upstreamCodec_.generateGoaway(dummy, 0, ErrorCode::NO_ERROR);
   parseUpstream();
 
   output_.append(makeBuf(10));
   downstreamCodec_.generatePriority(output_, 2,
                                     HTTPMessage::HTTPPriority(0, true, 1));
   downstreamCodec_.generateEOM(output_, 2);
   downstreamCodec_.generateRstStream(output_, 2, ErrorCode::CANCEL);
 
   // send a response that will be accepted, headers should be ok
   downstreamCodec_.generateHeader(output_, 1, resp, true, &size);
   EXPECT_GT(size.uncompressed, 0);
 
   // parse the remainder
   parseUpstream();
   callbacks_.expectMessage(true, 1, 200);
 }

TEST_F	(	HTTP2CodecTest	,
		GoawayReply
	)

Definition at line 1181 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, proxygen::HTTP_HEADER_DATE, proxygen::NO_ERROR, proxygen::parse(), proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setStatusMessage().

                                     {
   upstreamCodec_.generateGoaway(output_, 0, ErrorCode::NO_ERROR);
 
   parse();
   EXPECT_EQ(callbacks_.goaways, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   downstreamCodec_.generateHeader(output_, 1, resp);
   downstreamCodec_.generateEOM(output_, 1);
   parseUpstream();
   callbacks_.expectMessage(true, 1, 200);
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
 }

TEST_F	(	HTTP2CodecTest	,
		BasicSetting
	)

Definition at line 1200 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::INITIAL_WINDOW_SIZE, proxygen::MAX_CONCURRENT_STREAMS, proxygen::parse(), and settings.

                                      {
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::MAX_CONCURRENT_STREAMS, 37);
   settings->setSetting(SettingsId::INITIAL_WINDOW_SIZE, 12345);
   upstreamCodec_.generateSettings(output_);
 
   parse();
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.maxStreams, 37);
   EXPECT_EQ(callbacks_.windowSize, 12345);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		SettingsAck
	)

Definition at line 1214 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, and proxygen::parse().

                                     {
   upstreamCodec_.generateSettingsAck(output_);
 
   parse();
   EXPECT_EQ(callbacks_.settings, 0);
   EXPECT_EQ(callbacks_.settingsAcks, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadSettings
	)

Definition at line 1224 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::INITIAL_WINDOW_SIZE, proxygen::parse(), and settings.

                                     {
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::INITIAL_WINDOW_SIZE, 0xffffffff);
   upstreamCodec_.generateSettings(output_);
 
   parse();
   EXPECT_EQ(callbacks_.settings, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		BadPushSettings
	)

Definition at line 1235 of file HTTP2CodecTest.cpp.

References folly::IOBuf::computeChainDataLength(), proxygen::ENABLE_PUSH, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::http2::kFrameHeaderSize, and settings.

                                         {
   auto settings = downstreamCodec_.getEgressSettings();
   settings->clearSettings();
   settings->setSetting(SettingsId::ENABLE_PUSH, 0);
   SetUpUpstreamTest();
 
   parseUpstream([&] (IOBuf* ingress) {
       EXPECT_EQ(ingress->computeChainDataLength(), http2::kFrameHeaderSize);
     });
   EXPECT_FALSE(upstreamCodec_.supportsPushTransactions());
   // Only way to disable push for downstreamCodec_ is to read
   // ENABLE_PUSH:0 from client
   EXPECT_TRUE(downstreamCodec_.supportsPushTransactions());
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		SettingsTableSize
	)

Definition at line 1254 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::HEADER_TABLE_SIZE, proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, proxygen::parse(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), and settings.

                                           {
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::HEADER_TABLE_SIZE, 8192);
   upstreamCodec_.generateSettings(output_);
 
   parse();
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 
   callbacks_.reset();
 
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   SetUpUpstreamTest();
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   parseUpstream();
   callbacks_.expectMessage(false, 2, 200);
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
   EXPECT_EQ("x-coolio", headers.getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE));
 }

TEST_F	(	HTTP2CodecTest	,
		BadSettingsTableSize
	)

Definition at line 1280 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HEADER_TABLE_SIZE, proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::parse(), proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), and settings.

                                              {
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::HEADER_TABLE_SIZE, 8192);
   // This sets the max decoder table size to 8k
   upstreamCodec_.generateSettings(output_);
 
   parse();
   EXPECT_EQ(callbacks_.settings, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 
   callbacks_.reset();
 
   // Set max decoder table size back to 4k, but don't parse it.  The
   // upstream encoder will up the table size to 8k per the first settings frame
   // and the HPACK codec will send a code to update the decoder.
   settings->setSetting(SettingsId::HEADER_TABLE_SIZE, 4096);
   upstreamCodec_.generateSettings(output_);
 
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   SetUpUpstreamTest();
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   parseUpstream();
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicPriority
	)

Definition at line 1313 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and proxygen::parse().

                                       {
   auto pri = HTTPMessage::HTTPPriority(0, true, 1);
   upstreamCodec_.generatePriority(output_, 1, pri);
 
   EXPECT_TRUE(parse());
   EXPECT_EQ(callbacks_.priority, pri);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadHeaderPriority
	)

Definition at line 1323 of file HTTP2CodecTest.cpp.

References c, EXPECT_EQ, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::http2::kConnectionPreface, proxygen::http2::kFrameHeaderSize, proxygen::parse(), proxygen::HTTPMessage::setHTTP2Priority(), folly::io::detail::CursorBase< Derived, BufType >::skip(), uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

                                           {
   HTTPMessage req = getGetRequest();
   req.setHTTP2Priority(HTTPMessage::HTTPPriority(0, false, 7));
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
 
   // hack ingress with cirular dep
   EXPECT_TRUE(parse([&] (IOBuf* ingress) {
         folly::io::RWPrivateCursor c(ingress);
         c.skip(http2::kFrameHeaderSize + http2::kConnectionPreface.length());
         c.writeBE<uint32_t>(1);
       }));
 
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadPriority
	)

Definition at line 1339 of file HTTP2CodecTest.cpp.

References c, EXPECT_EQ, EXPECT_TRUE, proxygen::http2::kConnectionPreface, proxygen::http2::kFrameHeaderSize, proxygen::parse(), folly::io::detail::CursorBase< Derived, BufType >::skip(), uint32_t, and folly::io::detail::Writable< Derived >::writeBE().

                                     {
   auto pri = HTTPMessage::HTTPPriority(0, true, 1);
   upstreamCodec_.generatePriority(output_, 1, pri);
 
   // hack ingress with cirular dep
   EXPECT_TRUE(parse([&] (IOBuf* ingress) {
         folly::io::RWPrivateCursor c(ingress);
         c.skip(http2::kFrameHeaderSize + http2::kConnectionPreface.length());
         c.writeBE<uint32_t>(1);
       }));
 
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		VirtualNodes
	)

Definition at line 1365 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, i, DummyQueue::nodes_, proxygen::parse(), and uint8_t.

                                      {
   DummyQueue queue;
   uint8_t level = 30;
   upstreamCodec_.addPriorityNodes(queue, output_, level);
 
   EXPECT_TRUE(parse());
   for (int i = 0; i < level; i++) {
     EXPECT_EQ(queue.nodes_[i], upstreamCodec_.mapPriorityToDependency(i));
   }
 
   // Out-of-range priorites are mapped to the lowest level of virtual nodes.
   EXPECT_EQ(queue.nodes_[level - 1],
             upstreamCodec_.mapPriorityToDependency(level));
   EXPECT_EQ(queue.nodes_[level - 1],
             upstreamCodec_.mapPriorityToDependency(level + 1));
 }

TEST_F	(	HTTP2CodecTest	,
		BasicPushPromise
	)

Definition at line 1382 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::ENABLE_PUSH, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, proxygen::HTTP_HEADER_USER_AGENT, i, proxygen::parse(), proxygen::HTTPMessage::setStatusCode(), and settings.

                                          {
   upstreamCodec_.generateSettings(output_);
   parse();
   EXPECT_FALSE(upstreamCodec_.supportsPushTransactions());
   EXPECT_FALSE(downstreamCodec_.supportsPushTransactions());
 
   auto settings = upstreamCodec_.getEgressSettings();
   settings->setSetting(SettingsId::ENABLE_PUSH, 1);
   upstreamCodec_.generateSettings(output_);
   parse();
   EXPECT_TRUE(upstreamCodec_.supportsPushTransactions());
   EXPECT_TRUE(downstreamCodec_.supportsPushTransactions());
 
   SetUpUpstreamTest();
 
   HTTPCodec::StreamID assocStream = 7;
   for (auto i = 0; i < 2; i++) {
     // Push promise
     HTTPCodec::StreamID pushStream = downstreamCodec_.createStream();
     HTTPMessage req = getGetRequest();
     req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
     downstreamCodec_.generatePushPromise(output_, pushStream, req, assocStream);
 
     parseUpstream();
     callbacks_.expectMessage(false, 2, "/"); // + host
     EXPECT_EQ(callbacks_.assocStreamId, assocStream);
     EXPECT_EQ(callbacks_.headersCompleteId, pushStream);
     auto& headers = callbacks_.msg->getHeaders();
     EXPECT_EQ("coolio", headers.getSingleOrEmpty(HTTP_HEADER_USER_AGENT));
     callbacks_.reset();
 
     // Actual reply headers
     HTTPMessage resp;
     resp.setStatusCode(200);
     resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "text/plain");
     downstreamCodec_.generateHeader(output_, pushStream, resp);
 
     parseUpstream();
     callbacks_.expectMessage(false, 2, 200);
     EXPECT_EQ(callbacks_.headersCompleteId, pushStream);
     EXPECT_EQ(callbacks_.assocStreamId, 0);
     EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
     EXPECT_EQ("text/plain", callbacks_.msg->getHeaders().getSingleOrEmpty(
                   HTTP_HEADER_CONTENT_TYPE));
     callbacks_.reset();
   }
 }

TEST_F	(	HTTP2CodecTest	,
		BadPushPromise
	)

Definition at line 1430 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), and proxygen::HTTP_HEADER_USER_AGENT.

                                        {
   // ENABLE_PUSH is now 0 by default
   SetUpUpstreamTest();
   HTTPMessage req = getGetRequest();
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   downstreamCodec_.generatePushPromise(output_, 2, req, 1);
 
   parseUpstream();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.assocStreamId, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicCertificateRequest
	)

Definition at line 1446 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, folly::gen::move, proxygen::parse(), and uint16_t.

                                                 {
   uint16_t requestId = 17;
   std::unique_ptr<folly::IOBuf> authRequest =
       folly::IOBuf::copyBuffer("authRequestData");
   upstreamCodec_.generateCertificateRequest(
       output_, requestId, std::move(authRequest));
 
   parse();
   EXPECT_EQ(callbacks_.certificateRequests, 1);
   EXPECT_EQ(callbacks_.lastCertRequestId, requestId);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), "authRequestData");
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BasicCertificate
	)

Definition at line 1461 of file HTTP2CodecTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, folly::gen::move, proxygen::parse(), and uint16_t.

                                          {
   uint16_t certId = 17;
   std::unique_ptr<folly::IOBuf> authenticator =
       folly::IOBuf::copyBuffer("authenticatorData");
   upstreamCodec_.generateCertificate(output_, certId, std::move(authenticator));
 
   parse();
   EXPECT_EQ(callbacks_.certificates, 1);
   EXPECT_EQ(callbacks_.lastCertId, certId);
   EXPECT_EQ(callbacks_.data.move()->moveToFbString(), "authenticatorData");
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		BadServerPreface
	)

Definition at line 1475 of file HTTP2CodecTest.cpp.

References EXPECT_EQ.

                                          {
   output_.move();
   downstreamCodec_.generateWindowUpdate(output_, 0, 10);
   parseUpstream();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.assocStreamId, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		Normal1024Continuation
	)

Definition at line 1487 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::parse(), and proxygen::HTTPMessage::setHTTP2Priority().

                                                {
   HTTPMessage req = getGetRequest();
   string bigval(8691, '!');
   bigval.append(8691, ' ');
   req.getHeaders().add("x-headr", bigval);
   req.setHTTP2Priority(HTTPMessage::HTTPPriority(0, false, 7));
   upstreamCodec_.generateHeader(output_, 1, req);
 
   parse();
   callbacks_.expectMessage(false, -1, "/");
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_EQ(bigval, headers.getSingleOrEmpty("x-headr"));
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 
   upstreamCodec_.generateSettingsAck(output_);
   parse();
   EXPECT_EQ(callbacks_.settingsAcks, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		StreamIdOverflow
	)

Definition at line 1510 of file HTTP2CodecTest.cpp.

References codec, proxygen::HTTPParallelCodec::createStream(), EXPECT_EQ, proxygen::HTTPParallelCodec::isReusable(), max, proxygen::HTTPParallelCodec::setNextEgressStreamId(), and proxygen::UPSTREAM.

                                          {
   HTTP2Codec codec(TransportDirection::UPSTREAM);
 
   HTTPCodec::StreamID streamId;
   codec.setNextEgressStreamId(std::numeric_limits<int32_t>::max() - 10);
   while (codec.isReusable()) {
     streamId = codec.createStream();
   }
   EXPECT_EQ(streamId, std::numeric_limits<int32_t>::max() - 2);
 }

TEST_F	(	HTTP2CodecTest	,
		TestMultipleDifferentContentLengthHeaders
	)

Definition at line 1521 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::getPostRequest(), proxygen::HTTP_HEADER_CONTENT_LENGTH, and proxygen::parse().

                                                                   {
   // Generate a POST request with two Content-Length headers
   // NOTE: getPostRequest already adds the content-length
   HTTPMessage req = getPostRequest();
   req.getHeaders().add(HTTP_HEADER_CONTENT_LENGTH, "300");
   EXPECT_EQ(req.getHeaders().getNumberOfValues(HTTP_HEADER_CONTENT_LENGTH), 2);
 
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
   parse();
 
   // Check that the request fails before the codec finishes parsing the headers
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.lastParseError->getHttpStatusCode(), 400);
 }

TEST_F	(	HTTP2CodecTest	,
		TestMultipleIdenticalContentLengthHeaders
	)

Definition at line 1537 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::getPostRequest(), and proxygen::parse().

                                                                   {
   // Generate a POST request with two Content-Length headers
   // NOTE: getPostRequest already adds the content-length
   HTTPMessage req = getPostRequest();
   req.getHeaders().add("content-length", "200");
   EXPECT_EQ(req.getHeaders().getNumberOfValues("content-length"), 2);
 
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
   parse();
 
   // Check that the headers parsing completes correctly
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.headersComplete, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		CleartextUpgrade
	)

Definition at line 1552 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPMessage::checkForHeaderToken(), EXPECT_EQ, EXPECT_GT, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_UPGRADE, proxygen::HTTP_HEADER_USER_AGENT, proxygen::http2::kProtocolSettingsHeader, and proxygen::HTTP2Codec::requestUpgrade().

                                          {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   HTTP2Codec::requestUpgrade(req);
   EXPECT_EQ(req.getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE), "h2c");
   EXPECT_TRUE(req.checkForHeaderToken(HTTP_HEADER_CONNECTION,
                                       "Upgrade", false));
   EXPECT_TRUE(req.checkForHeaderToken(
                 HTTP_HEADER_CONNECTION,
                 http2::kProtocolSettingsHeader.c_str(), false));
   EXPECT_GT(
     req.getHeaders().getSingleOrEmpty(http2::kProtocolSettingsHeader).length(),
     0);
 }

TEST_F	(	HTTP2CodecTest	,
		HTTP2SettingsSuccess
	)

Definition at line 1567 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_TRUE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::http2::kProtocolSettingsHeader, and proxygen::HTTP2Codec::requestUpgrade().

                                              {
   HTTPMessage req = getGetRequest("/guacamole");
 
   // empty settings
   req.getHeaders().add(http2::kProtocolSettingsHeader, "");
   EXPECT_TRUE(downstreamCodec_.onIngressUpgradeMessage(req));
 
   // real settings (overwrites empty)
   HTTP2Codec::requestUpgrade(req);
   EXPECT_TRUE(downstreamCodec_.onIngressUpgradeMessage(req));
 }

TEST_F	(	HTTP2CodecTest	,
		HTTP2SettingsFailure
	)

Definition at line 1579 of file HTTP2CodecTest.cpp.

References EXPECT_FALSE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::http2::kMaxFramePayloadLength, proxygen::http2::kProtocolSettingsHeader, and proxygen::HTTPHeaders::set().

                                              {
   HTTPMessage req = getGetRequest("/guacamole");
   // no settings
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
 
   HTTPHeaders& headers = req.getHeaders();
 
   // Not base64_url settings
   headers.set(http2::kProtocolSettingsHeader, "????");
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
   headers.set(http2::kProtocolSettingsHeader, "AAA");
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
 
   // Too big
   string bigSettings((http2::kMaxFramePayloadLength + 1) * 4 / 3, 'A');
   headers.set(http2::kProtocolSettingsHeader, bigSettings);
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
 
   // Malformed (not a multiple of 6)
   headers.set(http2::kProtocolSettingsHeader, "AAAA");
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
 
   // Two headers
   headers.set(http2::kProtocolSettingsHeader, "AAAAAAAA");
   headers.add(http2::kProtocolSettingsHeader, "AAAAAAAA");
   EXPECT_FALSE(downstreamCodec_.onIngressUpgradeMessage(req));
 }

TEST_F	(	HTTP2CodecTest	,
		HTTP2EnableConnect
	)

Definition at line 1607 of file HTTP2CodecTest.cpp.

References proxygen::ENABLE_CONNECT_PROTOCOL, and EXPECT_EQ.

                                            {
   SetUpUpstreamTest();
   // egress settings have no connect settings.
   auto ws_enable = upstreamCodec_.getEgressSettings()->getSetting(
       SettingsId::ENABLE_CONNECT_PROTOCOL);
   // enable connect settings, and check.
   upstreamCodec_.getEgressSettings()->setSetting(
       SettingsId::ENABLE_CONNECT_PROTOCOL, 1);
   ws_enable = upstreamCodec_.getEgressSettings()->getSetting(
       SettingsId::ENABLE_CONNECT_PROTOCOL);
   EXPECT_EQ(ws_enable->value, 1);
   // generateSettings.
   // pass the buffer to be parsed by the codec and check for ingress settings.
   upstreamCodec_.generateSettings(output_);
   parseUpstream();
   EXPECT_EQ(1, upstreamCodec_.peerHasWebsockets());
 }

TEST_F	(	HTTP2CodecTest	,
		WebsocketUpgrade
	)

Definition at line 1625 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, proxygen::getGetRequest(), proxygen::headers::kWebsocketString, proxygen::parse(), proxygen::HTTPMessage::setEgressWebsocketUpgrade(), and proxygen::HTTPMessage::setSecure().

                                          {
   HTTPMessage req = getGetRequest("/apples");
   req.setSecure(true);
   req.setEgressWebsocketUpgrade();
 
   upstreamCodec_.generateHeader(output_, 1, req, false);
   parse();
 
   EXPECT_TRUE(callbacks_.msg->isIngressWebsocketUpgrade());
   EXPECT_NE(nullptr, callbacks_.msg->getUpgradeProtocol());
   EXPECT_EQ(headers::kWebsocketString, *callbacks_.msg->getUpgradeProtocol());
 }

TEST_F	(	HTTP2CodecTest	,
		WebsocketBadHeader
	)

Definition at line 1638 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, i, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kProtocol, proxygen::headers::kScheme, proxygen::headers::kWebsocketString, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                            {
   const std::string kConnect{"CONNECT"};
   const std::string kWebsocketPath{"/websocket"};
   const std::string kSchemeHttps{"https"};
   vector<proxygen::compress::Header> reqHeaders = {
     Header::makeHeaderForTest(headers::kMethod, kConnect),
     Header::makeHeaderForTest(headers::kProtocol, headers::kWebsocketString),
   };
   vector<proxygen::compress::Header> optionalHeaders = {
     Header::makeHeaderForTest(headers::kPath, kWebsocketPath),
     Header::makeHeaderForTest(headers::kScheme, kSchemeHttps),
   };
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   int stream = 1;
   for (size_t i = 0; i < optionalHeaders.size(); ++i, stream += 2) {
     auto headers = reqHeaders;
     headers.push_back(optionalHeaders[i]);
     auto encodedHeaders = headerCodec.encode(headers);
     http2::writeHeaders(output_,
                         std::move(encodedHeaders),
                         stream,
                         folly::none,
                         http2::kNoPadding,
                         false,
                         true);
     parse();
   }
 
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, optionalHeaders.size());
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		WebsocketDupProtocol
	)

Definition at line 1674 of file HTTP2CodecTest.cpp.

References proxygen::HPACKCodec::encode(), EXPECT_EQ, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::headers::kPath, proxygen::headers::kProtocol, proxygen::headers::kScheme, proxygen::headers::kWebsocketString, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                              {
   const std::string kConnect{"CONNECT"};
   const std::string kWebsocketPath{"/websocket"};
   const std::string kSchemeHttps{"https"};
   vector<proxygen::compress::Header> headers = {
     Header::makeHeaderForTest(headers::kMethod, kConnect),
     Header::makeHeaderForTest(headers::kProtocol, headers::kWebsocketString),
     Header::makeHeaderForTest(headers::kProtocol, headers::kWebsocketString),
     Header::makeHeaderForTest(headers::kPath, kWebsocketPath),
     Header::makeHeaderForTest(headers::kScheme, kSchemeHttps),
   };
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   auto encodedHeaders = headerCodec.encode(headers);
   http2::writeHeaders(output_,
                       std::move(encodedHeaders),
                       1,
                       folly::none,
                       http2::kNoPadding,
                       false,
                       true);
   parse();
   EXPECT_EQ(callbacks_.messageBegin, 0);
   EXPECT_EQ(callbacks_.headersComplete, 0);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		WebsocketIncorrectResponse
	)

Definition at line 1702 of file HTTP2CodecTest.cpp.

References EXPECT_EQ, proxygen::getGetRequest(), proxygen::parse(), proxygen::HTTPMessage::setEgressWebsocketUpgrade(), proxygen::HTTPMessage::setSecure(), proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setStatusMessage().

                                                    {
   parse();
   SetUpUpstreamTest();
   parseUpstream();
 
   output_.clear();
   HTTPMessage req = getGetRequest("/apples");
   req.setSecure(true);
   req.setEgressWebsocketUpgrade();
   upstreamCodec_.generateHeader(output_, 1, req, false);
   parse();
 
   output_.clear();
   HTTPMessage resp;
   resp.setStatusCode(201);
   resp.setStatusMessage("OK");
   downstreamCodec_.generateHeader(output_, 1, resp);
   parseUpstream();
   EXPECT_EQ(callbacks_.streamErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		TestAllEgressFrameTypeCallbacks
	)

Definition at line 1723 of file HTTP2CodecTest.cpp.

References testing::_, add, wangle::HTTPHeaderSize::compressed, proxygen::http2::CONTINUATION, folly::IOBuf::copyBuffer(), proxygen::http2::DATA, data, proxygen::ENHANCE_YOUR_CALM, proxygen::http2::EX_HEADERS, EXPECT_CALL, EXPECT_TRUE, proxygen::getBigGetRequest(), proxygen::getGetRequest(), proxygen::http2::GOAWAY, proxygen::http2::HEADERS, testing::Invoke(), folly::gen::move, proxygen::HTTPCodec::NoPadding, proxygen::http2::PING, proxygen::http2::PRIORITY, proxygen::http2::PUSH_PROMISE, folly::Random::rand32(), proxygen::http2::RST_STREAM, proxygen::http2::SETTINGS, folly::size(), type, uint16_t, uint64_t, uint8_t, wangle::HTTPHeaderSize::uncompressed, and proxygen::http2::WINDOW_UPDATE.

                                                         {
   class CallbackTypeTracker {
     std::set<uint8_t> types;
   public:
     void add(uint8_t, uint8_t type, uint64_t, uint16_t) {
       types.insert(type);
     }
 
     bool isAllFrameTypesReceived() {
       http2::FrameType expectedTypes[] = {
         http2::FrameType::DATA,
         http2::FrameType::HEADERS,
         http2::FrameType::PRIORITY,
         http2::FrameType::RST_STREAM,
         http2::FrameType::SETTINGS,
         http2::FrameType::PUSH_PROMISE,
         http2::FrameType::PING,
         http2::FrameType::GOAWAY,
         http2::FrameType::WINDOW_UPDATE,
         http2::FrameType::CONTINUATION,
         http2::FrameType::EX_HEADERS,
       };
 
       for(http2::FrameType type: expectedTypes) {
         EXPECT_TRUE(types.find(static_cast<uint8_t>(type)) != types.end())
           << "callback missing for type " << static_cast<uint8_t>(type);
       }
       return types.size() == (sizeof(expectedTypes)/sizeof(http2::FrameType));
     }
   };
 
   CallbackTypeTracker callbackTypeTracker;
 
   NiceMock<MockHTTPCodecCallback> mockCallback;
   upstreamCodec_.setCallback(&mockCallback);
   downstreamCodec_.setCallback(&mockCallback);
   EXPECT_CALL(mockCallback, onGenerateFrameHeader(_, _, _, _)).
     WillRepeatedly(Invoke(&callbackTypeTracker, &CallbackTypeTracker::add));
 
   // DATA frame
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   upstreamCodec_.generateBody(output_, 2, std::move(buf),
                               HTTPCodec::NoPadding, true);
 
   HTTPHeaderSize size;
   size.uncompressed = size.compressed = 0;
   HTTPMessage req = getGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req, true, &size);
 
   upstreamCodec_.generatePriority(output_, 3,
                                   HTTPMessage::HTTPPriority(0, true, 1));
   upstreamCodec_.generateRstStream(output_, 2, ErrorCode::ENHANCE_YOUR_CALM);
   upstreamCodec_.generateSettings(output_);
   downstreamCodec_.generatePushPromise(output_, 2, req, 1);
   upstreamCodec_.generatePingRequest(output_);
 
   std::unique_ptr<folly::IOBuf> debugData =
       folly::IOBuf::copyBuffer("debugData");
   upstreamCodec_.generateGoaway(output_, 17, ErrorCode::ENHANCE_YOUR_CALM,
                                 std::move(debugData));
 
   upstreamCodec_.generateWindowUpdate(output_, 0, 10);
 
   HTTPCodec::StreamID stream = folly::Random::rand32(10, 1024) * 2;
   HTTPCodec::StreamID controlStream = folly::Random::rand32(10, 1024) * 2 + 1;
   downstreamCodec_.generateExHeader(output_, stream, req,
     HTTPCodec::ExAttributes(controlStream, true));
 
   // Tests the continuation frame
   req = getBigGetRequest();
   upstreamCodec_.generateHeader(output_, 1, req, true /* eom */);
 
   EXPECT_TRUE(callbackTypeTracker.isAllFrameTypesReceived());
 }

TEST_F	(	HTTP2CodecTest	,
		Trailers
	)

Definition at line 1799 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBuf::copyBuffer(), data, EXPECT_EQ, EXPECT_NE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_USER_AGENT, folly::gen::move, proxygen::HTTPCodec::NoPadding, and proxygen::parse().

                                  {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   upstreamCodec_.generateHeader(output_, 1, req);
 
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   upstreamCodec_.generateBody(
       output_, 1, std::move(buf), HTTPCodec::NoPadding, false /* eom */);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   upstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parse();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, 5);
   EXPECT_EQ(callbacks_.trailers, 1);
   EXPECT_NE(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 3);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersWithPseudoHeaders
	)

Definition at line 1831 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBuf::copyBuffer(), data, proxygen::HPACKCodec::encode(), EXPECT_EQ, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_USER_AGENT, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::HTTPCodec::NoPadding, proxygen::parse(), string, proxygen::UPSTREAM, and proxygen::http2::writeHeaders().

                                                   {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   upstreamCodec_.generateHeader(output_, 1, req);
 
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   upstreamCodec_.generateBody(
       output_, 1, std::move(buf), HTTPCodec::NoPadding, false /* eom */);
 
   HPACKCodec headerCodec(TransportDirection::UPSTREAM);
   std::string post("POST");
   std::vector<proxygen::compress::Header> trailers = {
       Header::makeHeaderForTest(headers::kMethod, post)};
   auto encodedTrailers = headerCodec.encode(trailers);
   http2::writeHeaders(output_,
                       std::move(encodedTrailers),
                       1,
                       folly::none,
                       http2::kNoPadding,
                       true,
                       true);
 
   parse();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, 5);
   EXPECT_EQ(callbacks_.trailers, 0);
   EXPECT_EQ(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 1);
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersNoBody
	)

Definition at line 1866 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_NE, proxygen::getGetRequest(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_USER_AGENT, and proxygen::parse().

                                        {
   HTTPMessage req = getGetRequest("/guacamole");
   req.getHeaders().add(HTTP_HEADER_USER_AGENT, "coolio");
   upstreamCodec_.generateHeader(output_, 1, req);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   upstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parse();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.bodyCalls, 0);
   EXPECT_EQ(callbacks_.bodyLength, 0);
   EXPECT_EQ(callbacks_.trailers, 1);
   EXPECT_NE(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 2);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersContinuation
	)

Definition at line 1893 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_NE, proxygen::getGetRequest(), proxygen::http2::kMaxFramePayloadLengthMin, proxygen::parse(), and string.

                                              {
   HTTPMessage req = getGetRequest("/guacamole");
   upstreamCodec_.generateHeader(output_, 1, req);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   trailers.add("x-huge-trailer",
                std::string(http2::kMaxFramePayloadLengthMin, '!'));
   upstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parse();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_NE(callbacks_.msg, nullptr);
   EXPECT_EQ(callbacks_.trailers, 1);
   EXPECT_NE(callbacks_.msg->getTrailers(), nullptr);
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
   EXPECT_EQ(std::string(http2::kMaxFramePayloadLengthMin, '!'),
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-huge-trailer"));
 #ifndef NDEBUG
   EXPECT_EQ(downstreamCodec_.getReceivedFrameCount(), 3);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersReply
	)

Definition at line 1922 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBuf::copyBuffer(), data, EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, folly::gen::move, proxygen::HTTPCodec::NoPadding, proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setStatusMessage().

                                       {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   downstreamCodec_.generateBody(
       output_, 1, std::move(buf), HTTPCodec::NoPadding, false);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   trailers.add("x-trailer-2", "chicken-kyiv");
   downstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parseUpstream();
 
   callbacks_.expectMessage(true, 2, 200);
   EXPECT_EQ(callbacks_.bodyCalls, 1);
   EXPECT_EQ(callbacks_.bodyLength, 5);
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
   EXPECT_EQ("x-coolio", headers.getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE));
   EXPECT_EQ(1, callbacks_.trailers);
   EXPECT_NE(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
   EXPECT_EQ("chicken-kyiv",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-2"));
 #ifndef NDEBUG
   EXPECT_EQ(upstreamCodec_.getReceivedFrameCount(), 4);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersReplyWithNoData
	)

Definition at line 1959 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::HTTP_HEADER_DATE, proxygen::HTTPMessage::setStatusCode(), and proxygen::HTTPMessage::setStatusMessage().

                                                 {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   downstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parseUpstream();
 
   callbacks_.expectMessage(true, 2, 200);
   EXPECT_EQ(callbacks_.bodyCalls, 0);
   EXPECT_EQ(callbacks_.bodyLength, 0);
   const auto& headers = callbacks_.msg->getHeaders();
   EXPECT_TRUE(callbacks_.msg->getHeaders().exists(HTTP_HEADER_DATE));
   EXPECT_EQ("x-coolio", headers.getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE));
   EXPECT_EQ(1, callbacks_.trailers);
   EXPECT_NE(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
 #ifndef NDEBUG
   EXPECT_EQ(upstreamCodec_.getReceivedFrameCount(), 3);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersReplyWithPseudoHeaders
	)

Definition at line 1988 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBuf::copyBuffer(), data, proxygen::DOWNSTREAM, proxygen::HPACKCodec::encode(), EXPECT_EQ, proxygen::HTTPMessage::getHeaders(), proxygen::HTTP_HEADER_CONTENT_TYPE, proxygen::headers::kMethod, proxygen::http2::kNoPadding, proxygen::compress::Header::makeHeaderForTest(), folly::gen::move, folly::none, proxygen::HTTPCodec::NoPadding, proxygen::HTTPMessage::setStatusCode(), proxygen::HTTPMessage::setStatusMessage(), string, and proxygen::http2::writeHeaders().

                                                        {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   resp.setStatusMessage("nifty-nice");
   resp.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, "x-coolio");
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   string data("abcde");
   auto buf = folly::IOBuf::copyBuffer(data.data(), data.length());
   downstreamCodec_.generateBody(
       output_, 1, std::move(buf), HTTPCodec::NoPadding, false);
 
   HPACKCodec headerCodec(TransportDirection::DOWNSTREAM);
   std::string post("POST");
   std::vector<proxygen::compress::Header> trailers = {
       Header::makeHeaderForTest(headers::kMethod, post)};
   auto encodedTrailers = headerCodec.encode(trailers);
   http2::writeHeaders(output_,
                       std::move(encodedTrailers),
                       1,
                       folly::none,
                       http2::kNoPadding,
                       true,
                       true);
   parseUpstream();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.trailers, 0);
   EXPECT_EQ(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ(callbacks_.streamErrors, 1);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersReplyContinuation
	)

Definition at line 2023 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), EXPECT_EQ, EXPECT_NE, proxygen::http2::kMaxFramePayloadLengthMin, proxygen::HTTPMessage::setStatusCode(), and string.

                                                   {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   trailers.add("x-huge-trailer",
                std::string(http2::kMaxFramePayloadLengthMin, '!'));
   downstreamCodec_.generateTrailers(output_, 1, trailers);
 
   parseUpstream();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 1);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 0);
   EXPECT_NE(callbacks_.msg, nullptr);
   EXPECT_EQ(callbacks_.msg->getStatusCode(), 200);
   EXPECT_EQ(1, callbacks_.trailers);
   EXPECT_NE(nullptr, callbacks_.msg->getTrailers());
   EXPECT_EQ("pico-de-gallo",
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-trailer-1"));
   EXPECT_EQ(std::string(http2::kMaxFramePayloadLengthMin, '!'),
             callbacks_.msg->getTrailers()->getSingleOrEmpty("x-huge-trailer"));
 #ifndef NDEBUG
   EXPECT_EQ(upstreamCodec_.getReceivedFrameCount(), 4);
 #endif
 }

TEST_F	(	HTTP2CodecTest	,
		TrailersReplyMissingContinuation
	)

Definition at line 2055 of file HTTP2CodecTest.cpp.

References proxygen::HTTPHeaders::add(), proxygen::ENHANCE_YOUR_CALM, EXPECT_EQ, proxygen::http2::kFrameHeaderSize, proxygen::http2::kMaxFramePayloadLengthMin, proxygen::HTTPMessage::setStatusCode(), string, and proxygen::http2::writeGoaway().

                                                          {
   SetUpUpstreamTest();
   HTTPMessage resp;
   resp.setStatusCode(200);
   downstreamCodec_.generateHeader(output_, 1, resp);
 
   HTTPHeaders trailers;
   trailers.add("x-trailer-1", "pico-de-gallo");
   trailers.add("x-huge-trailer",
                std::string(http2::kMaxFramePayloadLengthMin, '!'));
   downstreamCodec_.generateTrailers(output_, 1, trailers);
   // empirically determined the size of continuation frame, and strip it
   output_.trimEnd(http2::kFrameHeaderSize + 4132);
 
   // insert a non-continuation (but otherwise valid) frame
   http2::writeGoaway(output_, 17, ErrorCode::ENHANCE_YOUR_CALM);
 
   parseUpstream();
 
   EXPECT_EQ(callbacks_.messageBegin, 1);
   EXPECT_EQ(callbacks_.headersComplete, 1);
   EXPECT_EQ(callbacks_.messageComplete, 0);
   EXPECT_EQ(callbacks_.streamErrors, 0);
   EXPECT_EQ(callbacks_.sessionErrors, 1);
 #ifndef NDEBUG
   EXPECT_EQ(upstreamCodec_.getReceivedFrameCount(), 4);
 #endif
 }

const uint8_t kBufEmptyHeader[]

Initial value:

= {
  0x00, 0x00, 0x1d, 0x01, 0x04, 0x00, 0x00, 0x00, 0x01, 0x82,
  0x87, 0x44, 0x87, 0x62, 0x6b, 0x46, 0x41, 0xd2, 0x7a, 0x0b,
  0x41, 0x89, 0xf1, 0xe3, 0xc2, 0xf2, 0x9c, 0xeb, 0x90, 0xf4,
  0xff, 0x40, 0x80, 0x84, 0x2d, 0x35, 0xa7, 0xd7
}

Ingress bytes with an empty header name

Definition at line 422 of file HTTP2CodecTest.cpp.

Referenced by TEST_F().

Functions
	TEST (HTTP2CodecConstantsTest, HTTPContantsAreCommonHeaders)

	TEST_F (HTTP2CodecTest, IgnoreUnknownSettings)

	TEST_F (HTTP2CodecTest, NoExHeaders)

	TEST_F (HTTP2CodecTest, IgnoreExHeadersSetting)

	TEST_F (HTTP2CodecTest, EnableExHeadersSetting)

	TEST_F (HTTP2CodecTest, InvalidExHeadersSetting)

	TEST_F (HTTP2CodecTest, BasicHeader)

	TEST_F (HTTP2CodecTest, RequestFromServer)

	TEST_F (HTTP2CodecTest, ResponseFromClient)

	TEST_F (HTTP2CodecTest, ExHeadersWithPriority)

	TEST_F (HTTP2CodecTest, IgnoreExHeadersIfNotEnabled)

	TEST_F (HTTP2CodecTest, BadHeaders)

	TEST_F (HTTP2CodecTest, BadPseudoHeaders)

	TEST_F (HTTP2CodecTest, BadHeaderValues)

	TEST_F (HTTP2CodecTest, EmptyHeaderName)

	TEST_F (HTTP2CodecTest, BasicConnect)

	TEST_F (HTTP2CodecTest, BadConnect)

	TEST_F (HTTP2CodecTest, NormalSizeHeader)

	TEST_F (HTTP2CodecTest, OversizedHeader)

	TEST_F (HTTP2CodecTest, NormalSizeFrame)

	TEST_F (HTTP2CodecTest, OversizedFrame)

	TEST_F (HTTP2CodecTest, BigHeaderCompressed)

	TEST_F (HTTP2CodecTest, BasicHeaderReply)

	TEST_F (HTTP2CodecTest, BadHeadersReply)

	TEST_F (HTTP2CodecTest, Cookies)

	TEST_F (HTTP2CodecTest, BasicContinuation)

	TEST_F (HTTP2CodecTest, BasicContinuationEndStream)

	TEST_F (HTTP2CodecTest, BadContinuation)

	TEST_F (HTTP2CodecTest, MissingContinuation)

	TEST_F (HTTP2CodecTest, MissingContinuationBadFrame)

	TEST_F (HTTP2CodecTest, BadContinuationStream)

	TEST_F (HTTP2CodecTest, FrameTooLarge)

	TEST_F (HTTP2CodecTest, UnknownFrameType)

	TEST_F (HTTP2CodecTest, JunkAfterConnError)

	TEST_F (HTTP2CodecTest, BasicData)

	TEST_F (HTTP2CodecTest, LongData)

	TEST_F (HTTP2CodecTest, MalformedPaddingLength)

	TEST_F (HTTP2CodecTest, MalformedPadding)

	TEST_F (HTTP2CodecTest, NoAppByte)

	TEST_F (HTTP2CodecTest, DataFramePartialDataOnFrameHeaderCall)

	TEST_F (HTTP2CodecTest, DataFramePartialDataWithNoAppByte)

	TEST_F (HTTP2CodecTest, BasicRst)

	TEST_F (HTTP2CodecTest, BasicRstInvalidCode)

	TEST_F (HTTP2CodecTest, BasicPing)

	TEST_F (HTTP2CodecTest, BasicWindow)

	TEST_F (HTTP2CodecTest, ZeroWindow)

	TEST_F (HTTP2CodecTest, BasicGoaway)

	TEST_F (HTTP2CodecTest, BadGoaway)

	TEST_F (HTTP2CodecTest, DoubleGoaway)

	TEST_F (HTTP2CodecTest, DoubleGoawayWithError)

	TEST_F (HTTP2CodecTest, GoawayHandling)

	TEST_F (HTTP2CodecTest, GoawayReply)

	TEST_F (HTTP2CodecTest, BasicSetting)

	TEST_F (HTTP2CodecTest, SettingsAck)

	TEST_F (HTTP2CodecTest, BadSettings)

	TEST_F (HTTP2CodecTest, BadPushSettings)

	TEST_F (HTTP2CodecTest, SettingsTableSize)

	TEST_F (HTTP2CodecTest, BadSettingsTableSize)

	TEST_F (HTTP2CodecTest, BasicPriority)

	TEST_F (HTTP2CodecTest, BadHeaderPriority)

	TEST_F (HTTP2CodecTest, BadPriority)

	TEST_F (HTTP2CodecTest, VirtualNodes)

	TEST_F (HTTP2CodecTest, BasicPushPromise)

	TEST_F (HTTP2CodecTest, BadPushPromise)

	TEST_F (HTTP2CodecTest, BasicCertificateRequest)

	TEST_F (HTTP2CodecTest, BasicCertificate)

	TEST_F (HTTP2CodecTest, BadServerPreface)

	TEST_F (HTTP2CodecTest, Normal1024Continuation)

	TEST_F (HTTP2CodecTest, StreamIdOverflow)

	TEST_F (HTTP2CodecTest, TestMultipleDifferentContentLengthHeaders)

	TEST_F (HTTP2CodecTest, TestMultipleIdenticalContentLengthHeaders)

	TEST_F (HTTP2CodecTest, CleartextUpgrade)

	TEST_F (HTTP2CodecTest, HTTP2SettingsSuccess)

	TEST_F (HTTP2CodecTest, HTTP2SettingsFailure)

	TEST_F (HTTP2CodecTest, HTTP2EnableConnect)

	TEST_F (HTTP2CodecTest, WebsocketUpgrade)

	TEST_F (HTTP2CodecTest, WebsocketBadHeader)

	TEST_F (HTTP2CodecTest, WebsocketDupProtocol)

	TEST_F (HTTP2CodecTest, WebsocketIncorrectResponse)

	TEST_F (HTTP2CodecTest, TestAllEgressFrameTypeCallbacks)

	TEST_F (HTTP2CodecTest, Trailers)

	TEST_F (HTTP2CodecTest, TrailersWithPseudoHeaders)

	TEST_F (HTTP2CodecTest, TrailersNoBody)

	TEST_F (HTTP2CodecTest, TrailersContinuation)

	TEST_F (HTTP2CodecTest, TrailersReply)

	TEST_F (HTTP2CodecTest, TrailersReplyWithNoData)

	TEST_F (HTTP2CodecTest, TrailersReplyWithPseudoHeaders)

	TEST_F (HTTP2CodecTest, TrailersReplyContinuation)

	TEST_F (HTTP2CodecTest, TrailersReplyMissingContinuation)

Classes

Functions

Variables

Function Documentation

Variable Documentation