Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(172)

Side by Side Diff: net/tools/quic/quic_simple_server_stream_test.cc

Issue 1983183002: Landing Recent QUIC changes until 5/14/2016 02:25:25 UTC (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: "first try to fix link error for win_clang build" Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/tools/quic/quic_server_session_base_test.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/tools/quic/quic_simple_server_stream.h" 5 #include "net/tools/quic/quic_simple_server_stream.h"
6 6
7 #include "base/strings/string_number_conversions.h" 7 #include "base/strings/string_number_conversions.h"
8 #include "base/strings/string_piece.h" 8 #include "base/strings/string_piece.h"
9 #include "net/quic/quic_connection.h" 9 #include "net/quic/quic_connection.h"
10 #include "net/quic/quic_flags.h" 10 #include "net/quic/quic_flags.h"
(...skipping 24 matching lines...) Expand all
35 using std::string; 35 using std::string;
36 using testing::_; 36 using testing::_;
37 using testing::AnyNumber; 37 using testing::AnyNumber;
38 using testing::Invoke; 38 using testing::Invoke;
39 using testing::InvokeArgument; 39 using testing::InvokeArgument;
40 using testing::InSequence; 40 using testing::InSequence;
41 using testing::Return; 41 using testing::Return;
42 using testing::StrictMock; 42 using testing::StrictMock;
43 using testing::WithArgs; 43 using testing::WithArgs;
44 44
45 DECLARE_bool(quic_always_log_bugs_for_tests);
46
47 namespace net { 45 namespace net {
48 namespace test { 46 namespace test {
49 47
50 class QuicSimpleServerStreamPeer : public QuicSimpleServerStream { 48 class QuicSimpleServerStreamPeer : public QuicSimpleServerStream {
51 public: 49 public:
52 QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session) 50 QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session)
53 : QuicSimpleServerStream(stream_id, session) {} 51 : QuicSimpleServerStream(stream_id, session) {}
54 52
55 ~QuicSimpleServerStreamPeer() override{}; 53 ~QuicSimpleServerStreamPeer() override{};
56 54
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
89 MockQuicServerSessionVisitor* owner, 87 MockQuicServerSessionVisitor* owner,
90 QuicCryptoServerConfig* crypto_config, 88 QuicCryptoServerConfig* crypto_config,
91 QuicCompressedCertsCache* compressed_certs_cache) 89 QuicCompressedCertsCache* compressed_certs_cache)
92 : QuicSimpleServerSession(DefaultQuicConfig(), 90 : QuicSimpleServerSession(DefaultQuicConfig(),
93 connection, 91 connection,
94 owner, 92 owner,
95 crypto_config, 93 crypto_config,
96 compressed_certs_cache) { 94 compressed_certs_cache) {
97 set_max_open_incoming_streams(kMaxStreamsForTest); 95 set_max_open_incoming_streams(kMaxStreamsForTest);
98 set_max_open_outgoing_streams(kMaxStreamsForTest); 96 set_max_open_outgoing_streams(kMaxStreamsForTest);
99 ON_CALL(*this, WritevData(_, _, _, _, _)) 97 ON_CALL(*this, WritevData(_, _, _, _, _, _))
100 .WillByDefault(testing::Return(QuicConsumedData(0, false))); 98 .WillByDefault(testing::Return(QuicConsumedData(0, false)));
101 } 99 }
102 100
103 ~MockQuicSimpleServerSession() override {} 101 ~MockQuicSimpleServerSession() override {}
104 102
105 MOCK_METHOD3(OnConnectionClosed, 103 MOCK_METHOD3(OnConnectionClosed,
106 void(QuicErrorCode error, 104 void(QuicErrorCode error,
107 const string& error_details, 105 const string& error_details,
108 ConnectionCloseSource source)); 106 ConnectionCloseSource source));
109 MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id)); 107 MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
110 MOCK_METHOD5(WritevData, 108 MOCK_METHOD6(WritevData,
111 QuicConsumedData(QuicStreamId id, 109 QuicConsumedData(ReliableQuicStream* stream,
110 QuicStreamId id,
112 QuicIOVector data, 111 QuicIOVector data,
113 QuicStreamOffset offset, 112 QuicStreamOffset offset,
114 bool fin, 113 bool fin,
115 QuicAckListenerInterface*)); 114 QuicAckListenerInterface*));
116 MOCK_METHOD2(OnStreamHeaders, 115 MOCK_METHOD2(OnStreamHeaders,
117 void(QuicStreamId stream_id, StringPiece headers_data)); 116 void(QuicStreamId stream_id, StringPiece headers_data));
118 MOCK_METHOD2(OnStreamHeadersPriority, 117 MOCK_METHOD2(OnStreamHeadersPriority,
119 void(QuicStreamId stream_id, SpdyPriority priority)); 118 void(QuicStreamId stream_id, SpdyPriority priority));
120 MOCK_METHOD3(OnStreamHeadersComplete, 119 MOCK_METHOD3(OnStreamHeadersComplete,
121 void(QuicStreamId stream_id, bool fin, size_t frame_len)); 120 void(QuicStreamId stream_id, bool fin, size_t frame_len));
122 MOCK_METHOD5(WriteHeaders, 121 MOCK_METHOD5(WriteHeaders,
123 size_t(QuicStreamId id, 122 size_t(QuicStreamId id,
124 const SpdyHeaderBlock& headers, 123 const SpdyHeaderBlock& headers,
125 bool fin, 124 bool fin,
126 SpdyPriority priority, 125 SpdyPriority priority,
127 QuicAckListenerInterface* ack_notifier_delegate)); 126 QuicAckListenerInterface* ack_notifier_delegate));
128 MOCK_METHOD3(SendRstStream, 127 MOCK_METHOD3(SendRstStream,
129 void(QuicStreamId stream_id, 128 void(QuicStreamId stream_id,
130 QuicRstStreamErrorCode error, 129 QuicRstStreamErrorCode error,
131 QuicStreamOffset bytes_written)); 130 QuicStreamOffset bytes_written));
132 MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta)); 131 MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
133 MOCK_METHOD4(PromisePushResources, 132 MOCK_METHOD4(PromisePushResources,
134 void(const string&, 133 void(const string&,
135 const list<QuicInMemoryCache::ServerPushInfo>&, 134 const std::list<QuicInMemoryCache::ServerPushInfo>&,
136 QuicStreamId, 135 QuicStreamId,
137 const SpdyHeaderBlock&)); 136 const SpdyHeaderBlock&));
138 137
139 using QuicSession::ActivateStream; 138 using QuicSession::ActivateStream;
140 139
141 private: 140 private:
142 DISALLOW_COPY_AND_ASSIGN(MockQuicSimpleServerSession); 141 DISALLOW_COPY_AND_ASSIGN(MockQuicSimpleServerSession);
143 }; 142 };
144 143
145 namespace { 144 namespace {
146 145
147 class QuicSimpleServerStreamTest 146 class QuicSimpleServerStreamTest
148 : public ::testing::TestWithParam<QuicVersion> { 147 : public ::testing::TestWithParam<QuicVersion> {
149 public: 148 public:
150 QuicSimpleServerStreamTest() 149 QuicSimpleServerStreamTest()
151 : connection_( 150 : connection_(
152 new StrictMock<MockQuicConnection>(&helper_, 151 new StrictMock<MockQuicConnection>(&helper_,
153 &alarm_factory_, 152 &alarm_factory_,
154 Perspective::IS_SERVER, 153 Perspective::IS_SERVER,
155 SupportedVersions(GetParam()))), 154 SupportedVersions(GetParam()))),
156 session_owner_(new StrictMock<MockQuicServerSessionVisitor>()),
157 crypto_config_(new QuicCryptoServerConfig( 155 crypto_config_(new QuicCryptoServerConfig(
158 QuicCryptoServerConfig::TESTING, 156 QuicCryptoServerConfig::TESTING,
159 QuicRandom::GetInstance(), 157 QuicRandom::GetInstance(),
160 ::net::test::CryptoTestUtils::ProofSourceForTesting())), 158 ::net::test::CryptoTestUtils::ProofSourceForTesting())),
161 compressed_certs_cache_( 159 compressed_certs_cache_(
162 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize), 160 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
163 session_(connection_, 161 session_(connection_,
164 session_owner_, 162 &session_owner_,
165 crypto_config_.get(), 163 crypto_config_.get(),
166 &compressed_certs_cache_), 164 &compressed_certs_cache_),
167 body_("hello world") { 165 body_("hello world") {
168 FLAGS_quic_always_log_bugs_for_tests = true; 166 FLAGS_quic_always_log_bugs_for_tests = true;
169 SpdyHeaderBlock request_headers; 167 SpdyHeaderBlock request_headers;
170 request_headers[":host"] = ""; 168 request_headers[":host"] = "";
171 request_headers[":authority"] = "www.google.com"; 169 request_headers[":authority"] = "www.google.com";
172 request_headers[":path"] = "/"; 170 request_headers[":path"] = "/";
173 request_headers[":method"] = "POST"; 171 request_headers[":method"] = "POST";
174 request_headers[":version"] = "HTTP/1.1"; 172 request_headers[":version"] = "HTTP/1.1";
(...skipping 25 matching lines...) Expand all
200 } 198 }
201 199
202 StringPiece StreamHeadersValue(const string& key) { 200 StringPiece StreamHeadersValue(const string& key) {
203 return (*stream_->mutable_headers())[key]; 201 return (*stream_->mutable_headers())[key];
204 } 202 }
205 203
206 SpdyHeaderBlock response_headers_; 204 SpdyHeaderBlock response_headers_;
207 MockQuicConnectionHelper helper_; 205 MockQuicConnectionHelper helper_;
208 MockAlarmFactory alarm_factory_; 206 MockAlarmFactory alarm_factory_;
209 StrictMock<MockQuicConnection>* connection_; 207 StrictMock<MockQuicConnection>* connection_;
210 StrictMock<MockQuicServerSessionVisitor>* session_owner_; 208 StrictMock<MockQuicServerSessionVisitor> session_owner_;
211 std::unique_ptr<QuicCryptoServerConfig> crypto_config_; 209 std::unique_ptr<QuicCryptoServerConfig> crypto_config_;
212 QuicCompressedCertsCache compressed_certs_cache_; 210 QuicCompressedCertsCache compressed_certs_cache_;
213 StrictMock<MockQuicSimpleServerSession> session_; 211 StrictMock<MockQuicSimpleServerSession> session_;
214 QuicSimpleServerStreamPeer* stream_; // Owned by session_. 212 QuicSimpleServerStreamPeer* stream_; // Owned by session_.
215 string headers_string_; 213 string headers_string_;
216 string body_; 214 string body_;
217 }; 215 };
218 216
219 INSTANTIATE_TEST_CASE_P(Tests, 217 INSTANTIATE_TEST_CASE_P(Tests,
220 QuicSimpleServerStreamTest, 218 QuicSimpleServerStreamTest,
221 ::testing::ValuesIn(QuicSupportedVersions())); 219 ::testing::ValuesIn(QuicSupportedVersions()));
222 220
223 TEST_P(QuicSimpleServerStreamTest, TestFraming) { 221 TEST_P(QuicSimpleServerStreamTest, TestFraming) {
224 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 222 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
225 .Times(AnyNumber()) 223 .Times(AnyNumber())
226 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); 224 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
227 stream_->OnStreamHeaders(headers_string_); 225 stream_->OnStreamHeaders(headers_string_);
228 stream_->OnStreamHeadersComplete(false, headers_string_.size()); 226 stream_->OnStreamHeadersComplete(false, headers_string_.size());
229 stream_->OnStreamFrame( 227 stream_->OnStreamFrame(
230 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); 228 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
231 EXPECT_EQ("11", StreamHeadersValue("content-length")); 229 EXPECT_EQ("11", StreamHeadersValue("content-length"));
232 EXPECT_EQ("/", StreamHeadersValue(":path")); 230 EXPECT_EQ("/", StreamHeadersValue(":path"));
233 EXPECT_EQ("POST", StreamHeadersValue(":method")); 231 EXPECT_EQ("POST", StreamHeadersValue(":method"));
234 EXPECT_EQ(body_, StreamBody()); 232 EXPECT_EQ(body_, StreamBody());
235 } 233 }
236 234
237 TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) { 235 TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) {
238 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 236 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
239 .Times(AnyNumber()) 237 .Times(AnyNumber())
240 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); 238 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
241 239
242 stream_->OnStreamHeaders(headers_string_); 240 stream_->OnStreamHeaders(headers_string_);
243 stream_->OnStreamHeadersComplete(false, headers_string_.size()); 241 stream_->OnStreamHeadersComplete(false, headers_string_.size());
244 stream_->OnStreamFrame( 242 stream_->OnStreamFrame(
245 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); 243 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
246 EXPECT_EQ("11", StreamHeadersValue("content-length")); 244 EXPECT_EQ("11", StreamHeadersValue("content-length"));
247 EXPECT_EQ("/", StreamHeadersValue(":path")); 245 EXPECT_EQ("/", StreamHeadersValue(":path"));
248 EXPECT_EQ("POST", StreamHeadersValue(":method")); 246 EXPECT_EQ("POST", StreamHeadersValue(":method"));
249 EXPECT_EQ(body_, StreamBody()); 247 EXPECT_EQ(body_, StreamBody());
250 } 248 }
251 249
252 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) { 250 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
253 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 251 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
254 .Times(AnyNumber()) 252 .Times(AnyNumber())
255 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); 253 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
256 254
257 EXPECT_FALSE(stream_->fin_received()); 255 EXPECT_FALSE(stream_->fin_received());
258 EXPECT_FALSE(stream_->rst_received()); 256 EXPECT_FALSE(stream_->rst_received());
259 257
260 stream_->set_fin_sent(true); 258 stream_->set_fin_sent(true);
261 stream_->CloseWriteSide(); 259 stream_->CloseWriteSide();
262 260
263 if (GetParam() > QUIC_VERSION_28) { 261 if (GetParam() > QUIC_VERSION_28) {
264 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); 262 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
265 } else { 263 } else {
266 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 264 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
267 } 265 }
268 stream_->StopReading(); 266 stream_->StopReading();
269 } 267 }
270 268
271 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) { 269 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
272 string large_body = "hello world!!!!!!"; 270 string large_body = "hello world!!!!!!";
273 271
274 // We'll automatically write out an error (headers + body) 272 // We'll automatically write out an error (headers + body)
275 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); 273 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
276 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 274 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
277 .WillOnce(Invoke(MockQuicSession::ConsumeAllData)); 275 .WillOnce(Invoke(MockQuicSession::ConsumeAllData));
278 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 276 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
279 277
280 stream_->OnStreamHeaders(headers_string_); 278 stream_->OnStreamHeaders(headers_string_);
281 stream_->OnStreamHeadersComplete(false, headers_string_.size()); 279 stream_->OnStreamHeadersComplete(false, headers_string_.size());
282 stream_->OnStreamFrame( 280 stream_->OnStreamFrame(
283 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); 281 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_));
284 // Content length is still 11. This will register as an error and we won't 282 // Content length is still 11. This will register as an error and we won't
285 // accept the bytes. 283 // accept the bytes.
286 stream_->OnStreamFrame( 284 stream_->OnStreamFrame(
(...skipping 16 matching lines...) Expand all
303 response_headers_[":status"] = "200 OK"; 301 response_headers_[":status"] = "200 OK";
304 response_headers_["content-length"] = "5"; 302 response_headers_["content-length"] = "5";
305 string body = "Yummm"; 303 string body = "Yummm";
306 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", 304 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar",
307 response_headers_, body); 305 response_headers_, body);
308 306
309 stream_->set_fin_received(true); 307 stream_->set_fin_received(true);
310 308
311 InSequence s; 309 InSequence s;
312 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); 310 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
313 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 311 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
314 .Times(1) 312 .Times(1)
315 .WillOnce(Return(QuicConsumedData( 313 .WillOnce(Return(QuicConsumedData(
316 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); 314 strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
317 315
318 QuicSimpleServerStreamPeer::SendResponse(stream_); 316 QuicSimpleServerStreamPeer::SendResponse(stream_);
319 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); 317 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
320 EXPECT_TRUE(stream_->reading_stopped()); 318 EXPECT_TRUE(stream_->reading_stopped());
321 EXPECT_TRUE(stream_->write_side_closed()); 319 EXPECT_TRUE(stream_->write_side_closed());
322 } 320 }
323 321
(...skipping 10 matching lines...) Expand all
334 response_headers_[":status"] = "+200"; 332 response_headers_[":status"] = "+200";
335 response_headers_["content-length"] = "5"; 333 response_headers_["content-length"] = "5";
336 string body = "Yummm"; 334 string body = "Yummm";
337 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", 335 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar",
338 response_headers_, body); 336 response_headers_, body);
339 337
340 stream_->set_fin_received(true); 338 stream_->set_fin_received(true);
341 339
342 InSequence s; 340 InSequence s;
343 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); 341 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
344 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 342 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
345 .Times(1) 343 .Times(1)
346 .WillOnce(Return(QuicConsumedData( 344 .WillOnce(Return(QuicConsumedData(
347 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); 345 strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
348 346
349 QuicSimpleServerStreamPeer::SendResponse(stream_); 347 QuicSimpleServerStreamPeer::SendResponse(stream_);
350 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); 348 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
351 EXPECT_TRUE(stream_->reading_stopped()); 349 EXPECT_TRUE(stream_->reading_stopped());
352 EXPECT_TRUE(stream_->write_side_closed()); 350 EXPECT_TRUE(stream_->write_side_closed());
353 } 351 }
354 352
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
391 response_headers_[":version"] = "HTTP/1.1"; 389 response_headers_[":version"] = "HTTP/1.1";
392 response_headers_[":status"] = "200"; 390 response_headers_[":status"] = "200";
393 response_headers_["content-length"] = "5"; 391 response_headers_["content-length"] = "5";
394 string body = "Yummm"; 392 string body = "Yummm";
395 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", 393 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar",
396 response_headers_, body); 394 response_headers_, body);
397 stream_->set_fin_received(true); 395 stream_->set_fin_received(true);
398 396
399 InSequence s; 397 InSequence s;
400 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); 398 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
401 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 399 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
402 .Times(1) 400 .Times(1)
403 .WillOnce(Return(QuicConsumedData(body.length(), true))); 401 .WillOnce(Return(QuicConsumedData(body.length(), true)));
404 402
405 QuicSimpleServerStreamPeer::SendResponse(stream_); 403 QuicSimpleServerStreamPeer::SendResponse(stream_);
406 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); 404 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
407 EXPECT_TRUE(stream_->reading_stopped()); 405 EXPECT_TRUE(stream_->reading_stopped());
408 EXPECT_TRUE(stream_->write_side_closed()); 406 EXPECT_TRUE(stream_->write_side_closed());
409 } 407 }
410 408
411 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) { 409 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) {
412 // Tests that if a reponse has push resources to be send, SendResponse() will 410 // Tests that if a reponse has push resources to be send, SendResponse() will
413 // call PromisePushResources() to handle these resources. 411 // call PromisePushResources() to handle these resources.
414 412
415 // Add a request and response with valid headers into cache. 413 // Add a request and response with valid headers into cache.
416 string host = "www.google.com"; 414 string host = "www.google.com";
417 string request_path = "/foo"; 415 string request_path = "/foo";
418 string body = "Yummm"; 416 string body = "Yummm";
419 SpdyHeaderBlock response_headers; 417 SpdyHeaderBlock response_headers;
420 string url = host + "/bar"; 418 string url = host + "/bar";
421 QuicInMemoryCache::ServerPushInfo push_info(GURL(url), response_headers, 419 QuicInMemoryCache::ServerPushInfo push_info(GURL(url), response_headers,
422 kDefaultPriority, "Push body"); 420 kDefaultPriority, "Push body");
423 list<QuicInMemoryCache::ServerPushInfo> push_resources; 421 std::list<QuicInMemoryCache::ServerPushInfo> push_resources;
424 push_resources.push_back(push_info); 422 push_resources.push_back(push_info);
425 QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources( 423 QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources(
426 host, request_path, 200, body, push_resources); 424 host, request_path, 200, body, push_resources);
427 425
428 SpdyHeaderBlock* request_headers = stream_->mutable_headers(); 426 SpdyHeaderBlock* request_headers = stream_->mutable_headers();
429 (*request_headers)[":path"] = request_path; 427 (*request_headers)[":path"] = request_path;
430 (*request_headers)[":authority"] = host; 428 (*request_headers)[":authority"] = host;
431 (*request_headers)[":version"] = "HTTP/1.1"; 429 (*request_headers)[":version"] = "HTTP/1.1";
432 (*request_headers)[":method"] = "GET"; 430 (*request_headers)[":method"] = "GET";
433 431
434 stream_->set_fin_received(true); 432 stream_->set_fin_received(true);
435 InSequence s; 433 InSequence s;
436 EXPECT_CALL(session_, PromisePushResources(host + request_path, _, 434 EXPECT_CALL(session_, PromisePushResources(host + request_path, _,
437 ::net::test::kClientDataStreamId1, 435 ::net::test::kClientDataStreamId1,
438 *request_headers)); 436 *request_headers));
439 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); 437 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr));
440 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 438 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
441 .Times(1) 439 .Times(1)
442 .WillOnce(Return(QuicConsumedData(body.length(), true))); 440 .WillOnce(Return(QuicConsumedData(body.length(), true)));
443 QuicSimpleServerStreamPeer::SendResponse(stream_); 441 QuicSimpleServerStreamPeer::SendResponse(stream_);
444 } 442 }
445 443
446 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) { 444 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) {
447 // Calling PushResponse() on a client initialted stream is never supposed to 445 // Calling PushResponse() on a client initialted stream is never supposed to
448 // happen. 446 // happen.
449 SpdyHeaderBlock headers; 447 SpdyHeaderBlock headers;
450 EXPECT_DFATAL(stream_->PushResponse(headers), 448 EXPECT_DFATAL(stream_->PushResponse(headers),
(...skipping 25 matching lines...) Expand all
476 response_headers_["content-length"] = "5"; 474 response_headers_["content-length"] = "5";
477 const string kBody = "Hello"; 475 const string kBody = "Hello";
478 QuicInMemoryCache::GetInstance()->AddResponse(kHost, kPath, response_headers_, 476 QuicInMemoryCache::GetInstance()->AddResponse(kHost, kPath, response_headers_,
479 kBody); 477 kBody);
480 478
481 // Call PushResponse() should trigger stream to fetch response from cache 479 // Call PushResponse() should trigger stream to fetch response from cache
482 // and send it back. 480 // and send it back.
483 EXPECT_CALL(session_, 481 EXPECT_CALL(session_,
484 WriteHeaders(kServerInitiatedStreamId, _, false, 482 WriteHeaders(kServerInitiatedStreamId, _, false,
485 server_initiated_stream->priority(), nullptr)); 483 server_initiated_stream->priority(), nullptr));
486 EXPECT_CALL(session_, WritevData(kServerInitiatedStreamId, _, _, _, _)) 484 EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, _, _, _, _))
487 .Times(1) 485 .Times(1)
488 .WillOnce(Return(QuicConsumedData(kBody.size(), true))); 486 .WillOnce(Return(QuicConsumedData(kBody.size(), true)));
489 server_initiated_stream->PushResponse(headers); 487 server_initiated_stream->PushResponse(headers);
490 EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers( 488 EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers(
491 server_initiated_stream)[":path"] 489 server_initiated_stream)[":path"]
492 .as_string()); 490 .as_string());
493 EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers( 491 EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers(
494 server_initiated_stream)[":method"] 492 server_initiated_stream)[":method"]
495 .as_string()); 493 .as_string());
496 } 494 }
497 495
498 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) { 496 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
499 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 497 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
500 498
501 response_headers_[":version"] = "HTTP/1.1"; 499 response_headers_[":version"] = "HTTP/1.1";
502 response_headers_[":status"] = "500 Server Error"; 500 response_headers_[":status"] = "500 Server Error";
503 response_headers_["content-length"] = "3"; 501 response_headers_["content-length"] = "3";
504 stream_->set_fin_received(true); 502 stream_->set_fin_received(true);
505 503
506 InSequence s; 504 InSequence s;
507 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); 505 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
508 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 506 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
509 .Times(1) 507 .Times(1)
510 .WillOnce(Return(QuicConsumedData(3, true))); 508 .WillOnce(Return(QuicConsumedData(3, true)));
511 509
512 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); 510 QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
513 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); 511 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
514 EXPECT_TRUE(stream_->reading_stopped()); 512 EXPECT_TRUE(stream_->reading_stopped());
515 EXPECT_TRUE(stream_->write_side_closed()); 513 EXPECT_TRUE(stream_->write_side_closed());
516 } 514 }
517 515
518 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) { 516 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
519 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 517 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
520 518
521 SpdyHeaderBlock request_headers; 519 SpdyHeaderBlock request_headers;
522 // \000 is a way to write the null byte when followed by a literal digit. 520 // \000 is a way to write the null byte when followed by a literal digit.
523 request_headers["content-length"] = StringPiece("11\00012", 5); 521 request_headers["content-length"] = StringPiece("11\00012", 5);
524 522
525 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); 523 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers);
526 524
527 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); 525 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
528 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 526 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
529 .Times(AnyNumber()) 527 .Times(AnyNumber())
530 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); 528 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
531 stream_->OnStreamHeaders(headers_string_); 529 stream_->OnStreamHeaders(headers_string_);
532 stream_->OnStreamHeadersComplete(true, headers_string_.size()); 530 stream_->OnStreamHeadersComplete(true, headers_string_.size());
533 531
534 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); 532 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
535 EXPECT_TRUE(stream_->reading_stopped()); 533 EXPECT_TRUE(stream_->reading_stopped());
536 EXPECT_TRUE(stream_->write_side_closed()); 534 EXPECT_TRUE(stream_->write_side_closed());
537 } 535 }
538 536
539 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) { 537 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
540 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 538 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
541 539
542 SpdyHeaderBlock request_headers; 540 SpdyHeaderBlock request_headers;
543 // \000 is a way to write the null byte when followed by a literal digit. 541 // \000 is a way to write the null byte when followed by a literal digit.
544 request_headers["content-length"] = StringPiece("\00012", 3); 542 request_headers["content-length"] = StringPiece("\00012", 3);
545 543
546 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); 544 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers);
547 545
548 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); 546 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
549 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 547 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
550 .Times(AnyNumber()) 548 .Times(AnyNumber())
551 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); 549 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
552 stream_->OnStreamHeaders(headers_string_); 550 stream_->OnStreamHeaders(headers_string_);
553 stream_->OnStreamHeadersComplete(true, headers_string_.size()); 551 stream_->OnStreamHeadersComplete(true, headers_string_.size());
554 552
555 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); 553 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
556 EXPECT_TRUE(stream_->reading_stopped()); 554 EXPECT_TRUE(stream_->reading_stopped());
557 EXPECT_TRUE(stream_->write_side_closed()); 555 EXPECT_TRUE(stream_->write_side_closed());
558 } 556 }
559 557
(...skipping 13 matching lines...) Expand all
573 EXPECT_FALSE(stream_->write_side_closed()); 571 EXPECT_FALSE(stream_->write_side_closed());
574 } 572 }
575 573
576 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) { 574 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
577 response_headers_[":version"] = "HTTP/1.1"; 575 response_headers_[":version"] = "HTTP/1.1";
578 response_headers_[":status"] = "500 Server Error"; 576 response_headers_[":status"] = "500 Server Error";
579 response_headers_["content-length"] = "3"; 577 response_headers_["content-length"] = "3";
580 578
581 InSequence s; 579 InSequence s;
582 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, _, _, _)); 580 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, _, _, _));
583 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) 581 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
584 .Times(1) 582 .Times(1)
585 .WillOnce(Return(QuicConsumedData(3, true))); 583 .WillOnce(Return(QuicConsumedData(3, true)));
586 if (GetParam() > QUIC_VERSION_28) { 584 if (GetParam() > QUIC_VERSION_28) {
587 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); 585 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
588 } else { 586 } else {
589 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); 587 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
590 } 588 }
591 EXPECT_FALSE(stream_->fin_received()); 589 EXPECT_FALSE(stream_->fin_received());
592 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); 590 QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
593 EXPECT_TRUE(stream_->reading_stopped()); 591 EXPECT_TRUE(stream_->reading_stopped());
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
638 }; 636 };
639 StringPiece data(arr, arraysize(arr)); 637 StringPiece data(arr, arraysize(arr));
640 QuicStreamFrame frame(stream_->id(), true, 0, data); 638 QuicStreamFrame frame(stream_->id(), true, 0, data);
641 // Verify that we don't crash when we get a invalid headers in stream frame. 639 // Verify that we don't crash when we get a invalid headers in stream frame.
642 stream_->OnStreamFrame(frame); 640 stream_->OnStreamFrame(frame);
643 } 641 }
644 642
645 } // namespace 643 } // namespace
646 } // namespace test 644 } // namespace test
647 } // namespace net 645 } // namespace net
OLDNEW
« no previous file with comments | « net/tools/quic/quic_server_session_base_test.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698