HPACKCodecTests.cpp File Reference

#include <folly/Range.h>
#include <folly/io/Cursor.h>
#include <folly/io/IOBuf.h>
#include <glog/logging.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/codec/compress/HPACKCodec.h>
#include <proxygen/lib/http/codec/compress/HPACKQueue.h>
#include <proxygen/lib/http/codec/compress/Header.h>
#include <proxygen/lib/http/codec/compress/HeaderCodec.h>
#include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
#include <proxygen/lib/http/codec/compress/test/TestUtil.h>
#include <vector>

Go to the source code of this file.

Classes
class	HPACKCodecTests
class	HPACKQueueTests

Functions
bool	isLowercase (StringPiece str)
	TEST_F (HPACKCodecTests, Request)
	TEST_F (HPACKCodecTests, Response)
	TEST_F (HPACKCodecTests, Headroom)
	TEST_F (HPACKCodecTests, LowercasingHeaderNames)
	TEST_F (HPACKCodecTests, MultivalueHeaders)
	TEST_F (HPACKCodecTests, DecodeError)
	TEST_F (HPACKCodecTests, HeaderCodecStats)
	TEST_F (HPACKCodecTests, UncompressedSizeLimit)
	TEST_F (HPACKCodecTests, SizeLimitStats)
	TEST_F (HPACKCodecTests, DefaultHeaderIndexingStrategy)
	TEST_F (HPACKQueueTests, QueueInline)
	TEST_F (HPACKQueueTests, QueueReorder)
	TEST_F (HPACKQueueTests, QueueReorderOoo)
	TEST_F (HPACKQueueTests, QueueError)
	TEST_P (HPACKQueueTests, QueueDeleted)
	INSTANTIATE_TEST_CASE_P (Queue, HPACKQueueTests,::testing::Values(0, 1, 2, 3))

Function Documentation

INSTANTIATE_TEST_CASE_P	(	Queue	,
		HPACKQueueTests	,
		::testing::Values(0, 1, 2, 3)
	)

Referenced by TEST_P().

bool isLowercase

(

StringPiece

str

)

Definition at line 31 of file HPACKCodecTests.cpp.

References c, ch, codec, folly::IOBuf::computeChainDataLength(), fizz::decode(), proxygen::HPACKCodec::decodeStreaming(), proxygen::HPACKCodec::encode(), encodeDecode(), proxygen::ERROR, proxygen::TestStreamingCallback::error, proxygen::TestStreamingCallback::getResult(), proxygen::TestStreamingCallback::hasError(), folly::makeUnexpected(), folly::gen::move, folly::pushmi::__adl::noexcept(), uint32_t, and uint64_t.

Referenced by TEST_F().

                                  {
  for (auto ch : str) {
    if (isalpha(ch) && !islower(ch)) {
      return false;
    }
  }
  return true;
}

TEST_F	(	HPACKCodecTests	,
		Request
	)

Definition at line 83 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), encodeDecode(), EXPECT_EQ, EXPECT_TRUE, and i.

                                 {
  for (int i = 0; i < 3; i++) {
    auto result = encodeDecode(client, server, basicHeaders());
    EXPECT_TRUE(!result.hasError());
    EXPECT_EQ(result->headers.size(), 12);
  }
}

TEST_F	(	HPACKCodecTests	,
		Response
	)

Definition at line 91 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), encodeDecode(), EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), and i.

                                  {
  vector<vector<string>> headers = {
    {"content-length", "80"},
    {"content-encoding", "gzip"},
    {"x-fb-debug", "sdfgrwer"}
  };
  vector<Header> req = headersFromArray(headers);

  for (int i = 0; i < 3; i++) {
    auto result = encodeDecode(server, client, basicHeaders());
    EXPECT_TRUE(!result.hasError());
    EXPECT_EQ(result->headers.size(), 12);
  }
}

TEST_F	(	HPACKCodecTests	,
		Headroom
	)

Definition at line 106 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), fizz::decode(), EXPECT_EQ, EXPECT_TRUE, folly::IOBuf::headroom(), and uint32_t.

                                  {
  vector<Header> req = basicHeaders();

  uint32_t headroom = 20;
  client.setEncodeHeadroom(headroom);
  unique_ptr<IOBuf> encodedReq = client.encode(req);
  EXPECT_EQ(encodedReq->headroom(), headroom);
  Cursor cursor(encodedReq.get());
  auto result = decode(server, cursor, cursor.totalLength());
  EXPECT_TRUE(!result.hasError());
  EXPECT_EQ(result->headers.size(), 12);
}

TEST_F	(	HPACKCodecTests	,
		LowercasingHeaderNames
	)

makes sure that the encoder will lowercase the header names

Definition at line 122 of file HPACKCodecTests.cpp.

References encodeDecode(), EXPECT_TRUE, proxygen::hpack::headersFromArray(), i, and isLowercase().

                                                {
  vector<vector<string>> headers = {
    {"Content-Length", "80"},
    {"Content-Encoding", "gzip"},
    {"X-FB-Debug", "bleah"}
  };
  auto result = encodeDecode(server, client, headersFromArray(headers));
  EXPECT_TRUE(!result.hasError());
  auto& decoded = result->headers;
  CHECK_EQ(decoded.size(), 6);
  for (int i = 0; i < 6; i += 2) {
    EXPECT_TRUE(isLowercase(decoded[i].str));
  }
}

TEST_F	(	HPACKCodecTests	,
		MultivalueHeaders
	)

make sure we mark multi-valued headers appropriately, as expected by the SPDY codec.

Definition at line 141 of file HPACKCodecTests.cpp.

References count, encodeDecode(), EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), i, and uint32_t.

                                           {
  vector<vector<string>> headers = {
    {"Content-Length", "80"},
    {"Content-Encoding", "gzip"},
    {"X-FB-Dup", "bleah"},
    {"X-FB-Dup", "hahaha"}
  };
  auto result = encodeDecode(server, client, headersFromArray(headers));
  EXPECT_TRUE(!result.hasError());
  auto& decoded = result->headers;
  CHECK_EQ(decoded.size(), 8);
  uint32_t count = 0;
  for (int i = 0; i < 8; i += 2) {
    if (decoded[i].str == "x-fb-dup") {
      count++;
    }
  }
  EXPECT_EQ(count, 2);
}

TEST_F	(	HPACKCodecTests	,
		DecodeError
	)

test that we're propagating the error correctly in the decoder

Definition at line 164 of file HPACKCodecTests.cpp.

References fizz::decode(), EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), and folly::IOBuf::writableData().

                                     {
  vector<vector<string>> headers = {
    {"Content-Length", "80"}
  };
  vector<Header> req = headersFromArray(headers);

  unique_ptr<IOBuf> encodedReq = server.encode(req);
  encodedReq->writableData()[0] = 0xFF;
  Cursor cursor(encodedReq.get());

  TestHeaderCodecStats stats(HeaderCodec::Type::HPACK);
  client.setStats(&stats);
  auto result = decode(client, cursor, cursor.totalLength());
  // this means there was an error
  EXPECT_TRUE(result.hasError());
  EXPECT_EQ(result.error(), HPACK::DecodeError::INVALID_INDEX);
  EXPECT_EQ(stats.errors, 1);
  client.setStats(nullptr);
}

TEST_F	(	HPACKCodecTests	,
		HeaderCodecStats
	)

testing that we're calling the stats callbacks appropriately

Definition at line 187 of file HPACKCodecTests.cpp.

References fizz::decode(), proxygen::hpack::TestHeaderCodecStats::decodedBytesCompr, proxygen::hpack::TestHeaderCodecStats::decodedBytesUncompr, proxygen::hpack::TestHeaderCodecStats::decodes, proxygen::hpack::TestHeaderCodecStats::encodedBytesCompr, proxygen::hpack::TestHeaderCodecStats::encodedBytesUncompr, proxygen::hpack::TestHeaderCodecStats::encodes, proxygen::hpack::TestHeaderCodecStats::errors, EXPECT_EQ, EXPECT_GT, EXPECT_TRUE, proxygen::hpack::headersFromArray(), and proxygen::hpack::TestHeaderCodecStats::reset().

                                          {
  vector<vector<string>> headers = {
    {"Content-Length", "80"},
    {"Content-Encoding", "gzip"},
    {"X-FB-Debug", "eirtijvdgtccffkutnbttcgbfieghgev"}
  };
  vector<Header> resp = headersFromArray(headers);

  TestHeaderCodecStats stats(HeaderCodec::Type::HPACK);
  // encode
  server.setStats(&stats);
  unique_ptr<IOBuf> encodedResp = server.encode(resp);
  EXPECT_EQ(stats.encodes, 1);
  EXPECT_EQ(stats.decodes, 0);
  EXPECT_EQ(stats.errors, 0);
  EXPECT_TRUE(stats.encodedBytesCompr > 0);
  EXPECT_TRUE(stats.encodedBytesUncompr > 0);
  EXPECT_EQ(stats.decodedBytesCompr, 0);
  EXPECT_EQ(stats.decodedBytesUncompr, 0);
  server.setStats(nullptr);

  // decode
  Cursor cursor(encodedResp.get());
  stats.reset();
  client.setStats(&stats);
  auto result = decode(client, cursor, cursor.totalLength());
  EXPECT_TRUE(!result.hasError());
  auto& decoded = result->headers;
  CHECK_EQ(decoded.size(), 3 * 2);
  EXPECT_EQ(stats.decodes, 1);
  EXPECT_EQ(stats.encodes, 0);
  EXPECT_GT(stats.decodedBytesCompr, 0);
  EXPECT_GT(stats.decodedBytesUncompr, 0);
  EXPECT_EQ(stats.encodedBytesCompr, 0);
  EXPECT_EQ(stats.encodedBytesUncompr, 0);
  client.setStats(nullptr);
}

TEST_F	(	HPACKCodecTests	,
		UncompressedSizeLimit
	)

check that we're enforcing the limit on total uncompressed size

Definition at line 228 of file HPACKCodecTests.cpp.

References encodeDecode(), EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), i, and folly::value().

                                               {
  vector<vector<string>> headers;
  // generate lots of small headers
  string contentLength = "Content-Length";
  for (int i = 0; i < 10000; i++) {
    string value = folly::to<string>(i);
    vector<string> header = {contentLength, value};
    headers.push_back(header);
  }
  auto result = encodeDecode(server, client, headersFromArray(headers));
  EXPECT_TRUE(result.hasError());
  EXPECT_EQ(result.error(), HPACK::DecodeError::HEADERS_TOO_LARGE);
}

TEST_F	(	HPACKCodecTests	,
		SizeLimitStats
	)

Size limit stats

Definition at line 246 of file HPACKCodecTests.cpp.

References EXPECT_EQ, EXPECT_TRUE, proxygen::hpack::headersFromArray(), i, proxygen::hpack::TestHeaderCodecStats::tooLarge, and folly::value().

                                        {
  vector<vector<string>> headers;
  // generate lots of small headers
  string contentLength = "Content-Length";
  for (int i = 0; i < 10000; i++) {
    string value = folly::to<string>(i);
    vector<string> header = {contentLength, value};
    headers.push_back(header);
  }
  auto encHeaders = headersFromArray(headers);
  unique_ptr<IOBuf> encoded = client.encode(encHeaders);
  Cursor cursor(encoded.get());
  TestStreamingCallback cb;
  TestHeaderCodecStats stats(HeaderCodec::Type::HPACK);
  server.setStats(&stats);
  server.decodeStreaming(cursor, cursor.totalLength(), &cb);
  auto result = cb.getResult();
  EXPECT_TRUE(result.hasError());
  EXPECT_EQ(result.error(), HPACK::DecodeError::HEADERS_TOO_LARGE);
  EXPECT_EQ(stats.tooLarge, 1);
}

TEST_F	(	HPACKCodecTests	,
		DefaultHeaderIndexingStrategy
	)

Definition at line 268 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), proxygen::HPACKCodec::encode(), EXPECT_EQ, and proxygen::hpack::headersFromArray().

                                                       {
  vector<Header> headers = basicHeaders();
  size_t headersIndexableSize = 4;

  // Control equality check; all basic headers were indexed
  client.encode(headers);
  EXPECT_EQ(client.getHPACKTableInfo().egressHeadersStored_,
            headersIndexableSize);

  // Verify HPACKCodec by default utilizes the default header indexing strategy
  // by ensuring that it does not index any of the added headers below
  // The below is quite verbose but that is because Header constructors use
  // references and so we need the actual strings to not go out of scope
  vector<vector<string>> noIndexHeadersStrings = {
    {"content-length", "80"},
    {":path", "/some/random/file.jpg"},
    {":path", "checks_for_="},
    {"if-modified-since", "some_value"},
    {"last-modified", "some_value"}
  };
  vector<Header> noIndexHeaders = headersFromArray(noIndexHeadersStrings);
  headers.insert(headers.end(), noIndexHeaders.begin(), noIndexHeaders.end());
  HPACKCodec testCodec{TransportDirection::UPSTREAM};
  testCodec.encode(headers);
  EXPECT_EQ(
    testCodec.getHPACKTableInfo().egressHeadersStored_, headersIndexableSize);
}

TEST_F	(	HPACKQueueTests	,
		QueueInline
	)

Definition at line 309 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), EXPECT_EQ, EXPECT_TRUE, proxygen::TestStreamingCallback::getResult(), i, folly::gen::move, and proxygen::TestStreamingCallback::reset().

                                     {
  vector<Header> req = basicHeaders();
  TestStreamingCallback cb;

  for (int i = 0; i < 3; i++) {
    unique_ptr<IOBuf> encodedReq = client.encode(req);
    auto len = bufLen(encodedReq);
    cb.reset();
    queue->enqueueHeaderBlock(i, std::move(encodedReq), len, &cb, false);
    auto result = cb.getResult();
    EXPECT_TRUE(!result.hasError());
    EXPECT_EQ(result->headers.size(), 12);
  }
}

TEST_F	(	HPACKQueueTests	,
		QueueReorder
	)

Definition at line 324 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), folly::data(), EXPECT_EQ, EXPECT_TRUE, i, and folly::gen::move.

                                      {
  vector<Header> req = basicHeaders();
  vector<std::pair<unique_ptr<IOBuf>, TestStreamingCallback>> data;

  for (int i = 0; i < 4; i++) {
    data.emplace_back(client.encode(req), TestStreamingCallback());
  }

  std::vector<int> insertOrder{1, 3, 2, 0};
  for (auto i: insertOrder) {
    auto& encodedReq = data[i].first;
    auto len = bufLen(encodedReq);
    queue->enqueueHeaderBlock(i, std::move(encodedReq), len, &data[i].second,
                             false);
  }
  for (auto& d: data) {
    auto result = d.second.getResult();
    EXPECT_TRUE(!result.hasError());
    EXPECT_EQ(result->headers.size(), 12);
  }
  EXPECT_EQ(queue->getHolBlockCount(), 3);
}

TEST_F	(	HPACKQueueTests	,
		QueueReorderOoo
	)

Definition at line 347 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), folly::data(), EXPECT_EQ, EXPECT_TRUE, i, and folly::gen::move.

                                         {
  vector<Header> req = basicHeaders();
  vector<std::pair<unique_ptr<IOBuf>, TestStreamingCallback>> data;

  for (int i = 0; i < 4; i++) {
    data.emplace_back(client.encode(req), TestStreamingCallback());
  }

  std::vector<int> insertOrder{0, 3, 2, 1};
  for (auto i: insertOrder) {
    auto& encodedReq = data[i].first;
    auto len = bufLen(encodedReq);
    // Allow idx 3 to be decoded out of order
    queue->enqueueHeaderBlock(i, std::move(encodedReq), len, &data[i].second,
                              i == 3);
  }
  for (auto& d: data) {
    auto result = d.second.getResult();
    EXPECT_TRUE(!result.hasError());
    EXPECT_EQ(result->headers.size(), 12);
  }
  EXPECT_EQ(queue->getHolBlockCount(), 1);
}

TEST_F	(	HPACKQueueTests	,
		QueueError
	)

Definition at line 371 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), EXPECT_EQ, EXPECT_TRUE, proxygen::TestStreamingCallback::getResult(), i, folly::gen::move, and proxygen::TestStreamingCallback::reset().

                                    {
  vector<Header> req = basicHeaders();
  TestStreamingCallback cb;

  bool expectOk = true;
  // ok, dup, ok, lower
  for (auto i: std::vector<int>({0, 0, 1, 0, 3, 3, 2})) {
    unique_ptr<IOBuf> encodedReq = client.encode(req);
    auto len = bufLen(encodedReq);
    cb.reset();
    queue->enqueueHeaderBlock(i, std::move(encodedReq), len, &cb, true);
    auto result = cb.getResult();
    if (expectOk) {
      EXPECT_TRUE(!result.hasError());
      EXPECT_EQ(result->headers.size(), 12);
    } else {
      EXPECT_TRUE(result.hasError());
      EXPECT_EQ(result.error(), HPACK::DecodeError::BAD_SEQUENCE_NUMBER);
    }
    expectOk = !expectOk;
  }
}

TEST_P	(	HPACKQueueTests	,
		QueueDeleted
	)

Definition at line 394 of file HPACKCodecTests.cpp.

References proxygen::hpack::basicHeaders(), folly::data(), i, INSTANTIATE_TEST_CASE_P(), and folly::gen::move.

                                      {
  vector<Header> req = basicHeaders();
  vector<std::pair<unique_ptr<IOBuf>, TestStreamingCallback>> data;

  for (int i = 0; i < 4; i++) {
    data.emplace_back(client.encode(req), TestStreamingCallback());
    if (i == GetParam()) {
      data.back().second.headersCompleteCb = [&] { queue.reset(); };
    }
  }

  std::vector<int> insertOrder{0, 3, 2, 1};
  for (auto i: insertOrder) {
    auto& encodedReq = data[i].first;
    auto len = bufLen(encodedReq);

    // Allow idx 3 to be decoded out of order
    queue->enqueueHeaderBlock(i, std::move(encodedReq), len, &data[i].second,
                             i == 3);
    if (!queue) {
      break;
    }
  }
}