net/spdy/spdy_headers_block_parser_test.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/spdy/spdy_headers_block_parser.h"
   6
   7 #include <string>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/sys_byteorder.h"
  12 #include "net/test/gtest_util.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace net {
  17
  18 using base::IntToString;
  19 using base::StringPiece;
  20 using std::string;
  21
  22 // A mock the handler class to check that we parse out the correct headers
  23 // and call the callback methods when we should.
  24 class MockSpdyHeadersHandler : public SpdyHeadersHandlerInterface {
  25  public:
  26   MOCK_METHOD1(OnHeaderBlock, void(uint32_t num_of_headers));
  27   MOCK_METHOD1(OnHeaderBlockEnd, void(size_t bytes));
  28   MOCK_METHOD2(OnHeader, void(StringPiece key, StringPiece value));
  29 };
  30
  31 class SpdyHeadersBlockParserTest :
  32     public ::testing::TestWithParam<SpdyMajorVersion> {
  33  public:
  34   virtual ~SpdyHeadersBlockParserTest() {}
  35
  36  protected:
  37   void SetUp() override {
  38     // Create a parser using the mock handler.
  39     spdy_version_ = GetParam();
  40
  41     parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_));
  42     length_field_size_ =
  43         SpdyHeadersBlockParser::LengthFieldSizeForVersion(spdy_version_);
  44   }
  45
  46   // Create a header block with a specified number of headers.
  47   string CreateHeaders(uint32_t num_headers, bool insert_nulls) {
  48     string headers;
  49
  50     // First, write the number of headers in the header block.
  51     headers += EncodeLength(num_headers);
  52
  53     // Second, write the key-value pairs.
  54     for (uint32_t i = 0; i < num_headers; i++) {
  55       // Build the key.
  56       string key;
  57       if (insert_nulls) {
  58         key = string(kBaseKey) + string("\0", 1) + IntToString(i);
  59       } else {
  60         key = string(kBaseKey) + IntToString(i);
  61       }
  62       // Encode the key as SPDY header.
  63       headers += EncodeLength(key.length());
  64       headers += key;
  65
  66       // Build the value.
  67       string value;
  68       if (insert_nulls) {
  69         value = string(kBaseValue) + string("\0", 1) + IntToString(i);
  70       } else {
  71         value = string(kBaseValue) + IntToString(i);
  72       }
  73       // Encode the value as SPDY header.
  74       headers += EncodeLength(value.length());
  75       headers += value;
  76     }
  77     return headers;
  78   }
  79
  80   string EncodeLength(uint32_t len) {
  81     char buffer[4];
  82     if (length_field_size_ == sizeof(uint32_t)) {
  83       uint32_t net_order_len = htonl(len);
  84       memcpy(buffer, &net_order_len, length_field_size_);
  85     } else if (length_field_size_ == sizeof(uint16_t)) {
  86       uint16_t net_order_len = htons(len);
  87       memcpy(buffer, &net_order_len, length_field_size_);
  88     } else {
  89       CHECK(false) << "Invalid length field size";
  90     }
  91     return string(buffer, length_field_size_);
  92   }
  93
  94   size_t length_field_size_;
  95   SpdyMajorVersion spdy_version_;
  96
  97   MockSpdyHeadersHandler handler_;
  98   scoped_ptr<SpdyHeadersBlockParser> parser_;
  99
 100   static const char *const kBaseKey;
 101   static const char *const kBaseValue;
 102
 103   // Number of headers and header blocks used in the tests.
 104   static const int kNumHeadersInBlock = 10;
 105   static const int kNumHeaderBlocks = 10;
 106 };
 107
 108 const char *const SpdyHeadersBlockParserTest::kBaseKey = "test_key";
 109 const char *const SpdyHeadersBlockParserTest::kBaseValue = "test_value";
 110
 111 // All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
 112 INSTANTIATE_TEST_CASE_P(SpdyHeadersBlockParserTests,
 113                         SpdyHeadersBlockParserTest,
 114                         ::testing::Values(SPDY2, SPDY3, SPDY4));
 115
 116 TEST_P(SpdyHeadersBlockParserTest, BasicTest) {
 117   // Sanity test, verify that we parse out correctly a block with
 118   // a single key-value pair and that we notify when we start and finish
 119   // handling a headers block.
 120   string headers(CreateHeaders(1, false));
 121
 122   EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
 123
 124   std::string expect_key = kBaseKey + IntToString(0);
 125   std::string expect_value = kBaseValue + IntToString(0);
 126   EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
 127                                  StringPiece(expect_value))).Times(1);
 128   EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
 129
 130   EXPECT_TRUE(parser_->
 131       HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
 132   EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
 133 }
 134
 135 TEST_P(SpdyHeadersBlockParserTest, NullsSupportedTest) {
 136   // Sanity test, verify that we parse out correctly a block with
 137   // a single key-value pair when the key and value contain null charecters.
 138   string headers(CreateHeaders(1, true));
 139
 140   EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
 141
 142   std::string expect_key = kBaseKey + string("\0", 1) + IntToString(0);
 143   std::string expect_value = kBaseValue + string("\0", 1) + IntToString(0);
 144   EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
 145                                  StringPiece(expect_value))).Times(1);
 146   EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
 147
 148   EXPECT_TRUE(parser_->
 149       HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
 150   EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
 151 }
 152
 153 TEST_P(SpdyHeadersBlockParserTest, MultipleBlocksAndHeadersWithPartialData) {
 154   testing::InSequence s;
 155
 156   // CreateHeaders is deterministic; we can call it once for the whole test.
 157   string headers(CreateHeaders(kNumHeadersInBlock, false));
 158
 159   // The mock doesn't retain storage of arguments, so keep them in scope.
 160   std::vector<string> retained_arguments;
 161   for (int i = 0; i < kNumHeadersInBlock; i++) {
 162     retained_arguments.push_back(kBaseKey + IntToString(i));
 163     retained_arguments.push_back(kBaseValue + IntToString(i));
 164   }
 165   // For each block we expect to parse out the headers in order.
 166   for (int i = 0; i < kNumHeaderBlocks; i++) {
 167     EXPECT_CALL(handler_, OnHeaderBlock(kNumHeadersInBlock)).Times(1);
 168     for (int j = 0; j < kNumHeadersInBlock; j++) {
 169       EXPECT_CALL(handler_, OnHeader(
 170           StringPiece(retained_arguments[2 * j]),
 171           StringPiece(retained_arguments[2 * j + 1]))).Times(1);
 172     }
 173     EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
 174   }
 175   // Parse the header blocks, feeding the parser one byte at a time.
 176   for (int i = 1; i <= kNumHeaderBlocks; i++) {
 177     for (string::iterator it = headers.begin(); it != headers.end(); ++it) {
 178       if ((it + 1) == headers.end()) {
 179         // Last byte completes the block.
 180         EXPECT_TRUE(parser_->HandleControlFrameHeadersData(i, &(*it), 1));
 181         EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR,
 182                   parser_->get_error());
 183       } else {
 184         EXPECT_FALSE(parser_->HandleControlFrameHeadersData(i, &(*it), 1));
 185         EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
 186       }
 187     }
 188   }
 189 }
 190
 191 TEST_P(SpdyHeadersBlockParserTest, HandlesEmptyCallsTest) {
 192   EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
 193
 194   string headers(CreateHeaders(1, false));
 195
 196   string expect_key = kBaseKey + IntToString(0);
 197   string expect_value = kBaseValue + IntToString(0);
 198   EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
 199                                  StringPiece(expect_value))).Times(1);
 200   EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
 201
 202   // Send a header in pieces with intermediate empty calls.
 203   for (string::iterator it = headers.begin(); it != headers.end(); ++it) {
 204     if ((it + 1) == headers.end()) {
 205       // Last byte completes the block.
 206       EXPECT_TRUE(parser_->HandleControlFrameHeadersData(1, &(*it), 1));
 207       EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error());
 208     } else {
 209       EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, &(*it), 1));
 210       EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
 211       EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, NULL, 0));
 212     }
 213   }
 214 }
 215
 216 TEST_P(SpdyHeadersBlockParserTest, LargeBlocksDiscardedTest) {
 217   // Header block with too many headers.
 218   {
 219     string headers = EncodeLength(
 220         parser_->MaxNumberOfHeadersForVersion(spdy_version_) + 1);
 221     EXPECT_FALSE(parser_->
 222         HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
 223     EXPECT_EQ(SpdyHeadersBlockParser::HEADER_BLOCK_TOO_LARGE,
 224               parser_->get_error());
 225   }
 226   parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_));
 227   // Header block with one header, which has a too-long key.
 228   {
 229     EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
 230
 231     string headers = EncodeLength(1) + EncodeLength(
 232         SpdyHeadersBlockParser::kMaximumFieldLength + 1);
 233     EXPECT_FALSE(parser_->
 234         HandleControlFrameHeadersData(1, headers.c_str(), headers.length()));
 235     EXPECT_EQ(SpdyHeadersBlockParser::HEADER_FIELD_TOO_LARGE,
 236               parser_->get_error());
 237   }
 238 }
 239
 240 TEST_P(SpdyHeadersBlockParserTest, ExtraDataTest) {
 241   string headers = CreateHeaders(1, false) + "foobar";
 242
 243   EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
 244   EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1);
 245
 246   string expect_key = kBaseKey + IntToString(0);
 247   string expect_value = kBaseValue + IntToString(0);
 248   EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key),
 249                                  StringPiece(expect_value))).Times(1);
 250
 251   EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.c_str(),
 252                                                       headers.length()));
 253   EXPECT_EQ(SpdyHeadersBlockParser::TOO_MUCH_DATA, parser_->get_error());
 254 }
 255
 256 TEST_P(SpdyHeadersBlockParserTest, WrongStreamIdTest) {
 257   string headers(CreateHeaders(kNumHeadersInBlock, false));
 258   EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.data(), 1));
 259   EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error());
 260   bool result;
 261   EXPECT_DFATAL(
 262       result = parser_->HandleControlFrameHeadersData(2, headers.data() + 1, 1),
 263       "Unexpected stream id: 2 \\(expected 1\\)");
 264   EXPECT_FALSE(result);
 265   EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error());
 266 }
 267
 268 TEST_P(SpdyHeadersBlockParserTest, InvalidStreamIdTest) {
 269   string headers(CreateHeaders(kNumHeadersInBlock, false));
 270   bool result;
 271   EXPECT_DFATAL(
 272       result = parser_->HandleControlFrameHeadersData(0, headers.data(), 1),
 273       "Expected nonzero stream id, saw: 0");
 274   EXPECT_FALSE(result);
 275   EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error());
 276 }
 277
 278 }  // namespace net