1 // Copyright (c) 2012 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 "quiche/common/http/http_header_block.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "quiche/common/platform/api/quiche_test.h"
11 #include "quiche/spdy/test_tools/spdy_test_utils.h"
12
13 using ::testing::ElementsAre;
14
15 namespace quiche {
16 namespace test {
17
18 class ValueProxyPeer {
19 public:
key(HttpHeaderBlock::ValueProxy * p)20 static absl::string_view key(HttpHeaderBlock::ValueProxy* p) {
21 return p->key_;
22 }
23 };
24
Pair(absl::string_view k,absl::string_view v)25 std::pair<absl::string_view, absl::string_view> Pair(absl::string_view k,
26 absl::string_view v) {
27 return std::make_pair(k, v);
28 }
29
30 // This test verifies that HttpHeaderBlock behaves correctly when empty.
TEST(HttpHeaderBlockTest,EmptyBlock)31 TEST(HttpHeaderBlockTest, EmptyBlock) {
32 HttpHeaderBlock block;
33 EXPECT_TRUE(block.empty());
34 EXPECT_EQ(0u, block.size());
35 EXPECT_EQ(block.end(), block.find("foo"));
36 EXPECT_FALSE(block.contains("foo"));
37 EXPECT_TRUE(block.end() == block.begin());
38
39 // Should have no effect.
40 block.erase("bar");
41 }
42
TEST(HttpHeaderBlockTest,KeyMemoryReclaimedOnLookup)43 TEST(HttpHeaderBlockTest, KeyMemoryReclaimedOnLookup) {
44 HttpHeaderBlock block;
45 absl::string_view copied_key1;
46 {
47 auto proxy1 = block["some key name"];
48 copied_key1 = ValueProxyPeer::key(&proxy1);
49 }
50 absl::string_view copied_key2;
51 {
52 auto proxy2 = block["some other key name"];
53 copied_key2 = ValueProxyPeer::key(&proxy2);
54 }
55 // Because proxy1 was never used to modify the block, the memory used for the
56 // key could be reclaimed and used for the second call to operator[].
57 // Therefore, we expect the pointers of the two absl::string_views to be
58 // equal.
59 EXPECT_EQ(copied_key1.data(), copied_key2.data());
60
61 {
62 auto proxy1 = block["some key name"];
63 block["some other key name"] = "some value";
64 }
65 // Nothing should blow up when proxy1 is destructed, and we should be able to
66 // modify and access the HttpHeaderBlock.
67 block["key"] = "value";
68 EXPECT_EQ("value", block["key"]);
69 EXPECT_EQ("some value", block["some other key name"]);
70 EXPECT_TRUE(block.find("some key name") == block.end());
71 }
72
73 // This test verifies that headers can be set in a variety of ways.
TEST(HttpHeaderBlockTest,AddHeaders)74 TEST(HttpHeaderBlockTest, AddHeaders) {
75 HttpHeaderBlock block;
76 block["foo"] = std::string(300, 'x');
77 block["bar"] = "baz";
78 block["qux"] = "qux1";
79 block["qux"] = "qux2";
80 block.insert(std::make_pair("key", "value"));
81
82 EXPECT_EQ(Pair("foo", std::string(300, 'x')), *block.find("foo"));
83 EXPECT_EQ("baz", block["bar"]);
84 std::string qux("qux");
85 EXPECT_EQ("qux2", block[qux]);
86 ASSERT_NE(block.end(), block.find("key"));
87 ASSERT_TRUE(block.contains("key"));
88 EXPECT_EQ(Pair("key", "value"), *block.find("key"));
89
90 block.erase("key");
91 EXPECT_EQ(block.end(), block.find("key"));
92 }
93
94 // This test verifies that HttpHeaderBlock can be copied using Clone().
TEST(HttpHeaderBlockTest,CopyBlocks)95 TEST(HttpHeaderBlockTest, CopyBlocks) {
96 HttpHeaderBlock block1;
97 block1["foo"] = std::string(300, 'x');
98 block1["bar"] = "baz";
99 block1.insert(std::make_pair("qux", "qux1"));
100
101 HttpHeaderBlock block2 = block1.Clone();
102 HttpHeaderBlock block3(block1.Clone());
103
104 EXPECT_EQ(block1, block2);
105 EXPECT_EQ(block1, block3);
106 }
107
TEST(HttpHeaderBlockTest,Equality)108 TEST(HttpHeaderBlockTest, Equality) {
109 // Test equality and inequality operators.
110 HttpHeaderBlock block1;
111 block1["foo"] = "bar";
112
113 HttpHeaderBlock block2;
114 block2["foo"] = "bar";
115
116 HttpHeaderBlock block3;
117 block3["baz"] = "qux";
118
119 EXPECT_EQ(block1, block2);
120 EXPECT_NE(block1, block3);
121
122 block2["baz"] = "qux";
123 EXPECT_NE(block1, block2);
124 }
125
ReturnTestHeaderBlock()126 HttpHeaderBlock ReturnTestHeaderBlock() {
127 HttpHeaderBlock block;
128 block["foo"] = "bar";
129 block.insert(std::make_pair("foo2", "baz"));
130 return block;
131 }
132
133 // Test that certain methods do not crash on moved-from instances.
TEST(HttpHeaderBlockTest,MovedFromIsValid)134 TEST(HttpHeaderBlockTest, MovedFromIsValid) {
135 HttpHeaderBlock block1;
136 block1["foo"] = "bar";
137
138 HttpHeaderBlock block2(std::move(block1));
139 EXPECT_THAT(block2, ElementsAre(Pair("foo", "bar")));
140
141 block1["baz"] = "qux"; // NOLINT testing post-move behavior
142
143 HttpHeaderBlock block3(std::move(block1));
144
145 block1["foo"] = "bar"; // NOLINT testing post-move behavior
146
147 HttpHeaderBlock block4(std::move(block1));
148
149 block1.clear(); // NOLINT testing post-move behavior
150 EXPECT_TRUE(block1.empty());
151
152 block1["foo"] = "bar";
153 EXPECT_THAT(block1, ElementsAre(Pair("foo", "bar")));
154
155 HttpHeaderBlock block5 = ReturnTestHeaderBlock();
156 block5.AppendValueOrAddHeader("foo", "bar2");
157 EXPECT_THAT(block5, ElementsAre(Pair("foo", std::string("bar\0bar2", 8)),
158 Pair("foo2", "baz")));
159 }
160
161 // This test verifies that headers can be appended to no matter how they were
162 // added originally.
TEST(HttpHeaderBlockTest,AppendHeaders)163 TEST(HttpHeaderBlockTest, AppendHeaders) {
164 HttpHeaderBlock block;
165 block["foo"] = "foo";
166 block.AppendValueOrAddHeader("foo", "bar");
167 EXPECT_EQ(Pair("foo", std::string("foo\0bar", 7)), *block.find("foo"));
168
169 block.insert(std::make_pair("foo", "baz"));
170 EXPECT_EQ("baz", block["foo"]);
171 EXPECT_EQ(Pair("foo", "baz"), *block.find("foo"));
172
173 // Try all four methods of adding an entry.
174 block["cookie"] = "key1=value1";
175 block.AppendValueOrAddHeader("h1", "h1v1");
176 block.insert(std::make_pair("h2", "h2v1"));
177
178 block.AppendValueOrAddHeader("h3", "h3v2");
179 block.AppendValueOrAddHeader("h2", "h2v2");
180 block.AppendValueOrAddHeader("h1", "h1v2");
181 block.AppendValueOrAddHeader("cookie", "key2=value2");
182
183 block.AppendValueOrAddHeader("cookie", "key3=value3");
184 block.AppendValueOrAddHeader("h1", "h1v3");
185 block.AppendValueOrAddHeader("h2", "h2v3");
186 block.AppendValueOrAddHeader("h3", "h3v3");
187 block.AppendValueOrAddHeader("h4", "singleton");
188
189 // Check for Set-Cookie header folding.
190 block.AppendValueOrAddHeader("set-cookie", "yummy");
191 block.AppendValueOrAddHeader("set-cookie", "scrumptious");
192
193 EXPECT_EQ("key1=value1; key2=value2; key3=value3", block["cookie"]);
194 EXPECT_EQ("baz", block["foo"]);
195 EXPECT_EQ(std::string("h1v1\0h1v2\0h1v3", 14), block["h1"]);
196 EXPECT_EQ(std::string("h2v1\0h2v2\0h2v3", 14), block["h2"]);
197 EXPECT_EQ(std::string("h3v2\0h3v3", 9), block["h3"]);
198 EXPECT_EQ("singleton", block["h4"]);
199 EXPECT_EQ(std::string("yummy\0scrumptious", 17), block["set-cookie"]);
200 }
201
TEST(HttpHeaderBlockTest,CompareValueToStringPiece)202 TEST(HttpHeaderBlockTest, CompareValueToStringPiece) {
203 HttpHeaderBlock block;
204 block["foo"] = "foo";
205 block.AppendValueOrAddHeader("foo", "bar");
206 const auto& val = block["foo"];
207 const char expected[] = "foo\0bar";
208 EXPECT_TRUE(absl::string_view(expected, 7) == val);
209 EXPECT_TRUE(val == absl::string_view(expected, 7));
210 EXPECT_FALSE(absl::string_view(expected, 3) == val);
211 EXPECT_FALSE(val == absl::string_view(expected, 3));
212 const char not_expected[] = "foo\0barextra";
213 EXPECT_FALSE(absl::string_view(not_expected, 12) == val);
214 EXPECT_FALSE(val == absl::string_view(not_expected, 12));
215
216 const auto& val2 = block["foo2"];
217 EXPECT_FALSE(absl::string_view(expected, 7) == val2);
218 EXPECT_FALSE(val2 == absl::string_view(expected, 7));
219 EXPECT_FALSE(absl::string_view("") == val2);
220 EXPECT_FALSE(val2 == absl::string_view(""));
221 }
222
223 // This test demonstrates that the HttpHeaderBlock data structure does not
224 // place any limitations on the characters present in the header names.
TEST(HttpHeaderBlockTest,UpperCaseNames)225 TEST(HttpHeaderBlockTest, UpperCaseNames) {
226 HttpHeaderBlock block;
227 block["Foo"] = "foo";
228 block.AppendValueOrAddHeader("Foo", "bar");
229 EXPECT_NE(block.end(), block.find("foo"));
230 EXPECT_EQ(Pair("Foo", std::string("foo\0bar", 7)), *block.find("Foo"));
231
232 // The map is case insensitive, so updating "foo" modifies the entry
233 // previously added.
234 block.AppendValueOrAddHeader("foo", "baz");
235 EXPECT_THAT(block,
236 ElementsAre(Pair("Foo", std::string("foo\0bar\0baz", 11))));
237 }
238
239 namespace {
HttpHeaderBlockSize(const HttpHeaderBlock & block)240 size_t HttpHeaderBlockSize(const HttpHeaderBlock& block) {
241 size_t size = 0;
242 for (const auto& pair : block) {
243 size += pair.first.size() + pair.second.size();
244 }
245 return size;
246 }
247 } // namespace
248
249 // Tests HttpHeaderBlock SizeEstimate().
TEST(HttpHeaderBlockTest,TotalBytesUsed)250 TEST(HttpHeaderBlockTest, TotalBytesUsed) {
251 HttpHeaderBlock block;
252 const size_t value_size = 300;
253 block["foo"] = std::string(value_size, 'x');
254 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
255 block.insert(std::make_pair("key", std::string(value_size, 'x')));
256 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
257 block.AppendValueOrAddHeader("abc", std::string(value_size, 'x'));
258 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
259
260 // Replace value for existing key.
261 block["foo"] = std::string(value_size, 'x');
262 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
263 block.insert(std::make_pair("key", std::string(value_size, 'x')));
264 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
265 // Add value for existing key.
266 block.AppendValueOrAddHeader("abc", std::string(value_size, 'x'));
267 EXPECT_EQ(block.TotalBytesUsed(), HttpHeaderBlockSize(block));
268
269 // Copies/clones HttpHeaderBlock.
270 size_t block_size = block.TotalBytesUsed();
271 HttpHeaderBlock block_copy = std::move(block);
272 EXPECT_EQ(block_size, block_copy.TotalBytesUsed());
273
274 // Erases key.
275 block_copy.erase("foo");
276 EXPECT_EQ(block_copy.TotalBytesUsed(), HttpHeaderBlockSize(block_copy));
277 block_copy.erase("key");
278 EXPECT_EQ(block_copy.TotalBytesUsed(), HttpHeaderBlockSize(block_copy));
279 block_copy.erase("abc");
280 EXPECT_EQ(block_copy.TotalBytesUsed(), HttpHeaderBlockSize(block_copy));
281 }
282
283 // The order of header fields is preserved. Note that all pseudo-header fields
284 // must appear before regular header fields, both in HTTP/2 and HTTP/3, see
285 // https://www.rfc-editor.org/rfc/rfc9113.html#name-http-control-data and
286 // https://www.rfc-editor.org/rfc/rfc9114.html#name-http-control-data. It is
287 // the responsibility of the higher layer to add header fields in the correct
288 // order.
TEST(HttpHeaderBlockTest,OrderPreserved)289 TEST(HttpHeaderBlockTest, OrderPreserved) {
290 HttpHeaderBlock block;
291 block[":method"] = "GET";
292 block["foo"] = "bar";
293 block[":path"] = "/";
294
295 EXPECT_THAT(block, ElementsAre(Pair(":method", "GET"), Pair("foo", "bar"),
296 Pair(":path", "/")));
297 }
298
TEST(HttpHeaderBlockTest,InsertReturnValue)299 TEST(HttpHeaderBlockTest, InsertReturnValue) {
300 HttpHeaderBlock block;
301 EXPECT_EQ(HttpHeaderBlock::InsertResult::kInserted,
302 block.insert({"foo", "bar"}));
303 EXPECT_EQ(HttpHeaderBlock::InsertResult::kReplaced,
304 block.insert({"foo", "baz"}));
305 }
306
307 } // namespace test
308 } // namespace quiche
309