Skip to content

GitLab

T
tangled
Commit 1f7384c5 authored by Renjie Tang's avatar Renjie Tang Committed by Commit Bot
Browse files
Options

Enable TLS1.3 in QuicChromiumClientStreamTest. 

Change-Id: I0861e5a870f2e43f45d971b8c6b6530ac72db59d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1918836
Commit-Queue: Renjie Tang <renjietang@chromium.org>
Reviewed-by: default avatarRyan Hamilton <rch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715830}
parent a1aa4dd2
Show whitespace changes
Inline Side-by-side
Showing with 90 additions and 65 deletions
net/quic/quic_chromium_client_stream_test.cc
View file @ 1f7384c5
......@@ -23,6 +23,7 @@
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
......@@ -151,22 +152,30 @@ MockQuicClientSessionBase::MockQuicClientSessionBase(
MockQuicClientSessionBase::~MockQuicClientSessionBase() {}
class QuicChromiumClientStreamTest
: public ::testing::TestWithParam<quic::QuicTransportVersion>,
: public ::testing::TestWithParam<quic::ParsedQuicVersion>,
public WithTaskEnvironment {
public:
QuicChromiumClientStreamTest()
: crypto_config_(
: version_(GetParam()),
crypto_config_(
quic::test::crypto_test_utils::ProofVerifierForTesting()),
session_(new quic::test::MockQuicConnection(
&helper_,
&alarm_factory_,
quic::Perspective::IS_CLIENT,
quic::test::SupportedVersions(
quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO,
GetParam()))),
quic::test::SupportedVersions(version_)),
&push_promise_index_) {
quic::test::QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
session_.config(), quic::kMinimumFlowControlSendWindow);
quic::test::QuicConfigPeer::
SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
session_.config(), quic::kMinimumFlowControlSendWindow);
quic::test::QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
session_.config(), 10);
session_.OnConfigNegotiated();
stream_ = new QuicChromiumClientStream(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
&session_, quic::BIDIRECTIONAL, NetLogWithSource(),
TRAFFIC_ANNOTATION_FOR_TESTS);
session_.ActivateStream(base::WrapUnique(stream_));
......@@ -251,7 +260,7 @@ class QuicChromiumClientStreamTest
}
std::string ConstructDataHeader(size_t body_len) {
if (GetParam() != quic::QUIC_VERSION_99) {
if (version_.transport_version != quic::QUIC_VERSION_99) {
return "";
}
std::unique_ptr<char[]> buffer;
......@@ -260,6 +269,7 @@ class QuicChromiumClientStreamTest
return std::string(buffer.get(), header_length);
}
const quic::ParsedQuicVersion version_;
quic::QuicCryptoClientConfig crypto_config_;
std::unique_ptr<QuicChromiumClientStream::Handle> handle_;
std::unique_ptr<QuicChromiumClientStream::Handle> handle2_;
......@@ -272,17 +282,16 @@ class QuicChromiumClientStreamTest
quic::QuicClientPushPromiseIndex push_promise_index_;
};
INSTANTIATE_TEST_SUITE_P(
Version,
INSTANTIATE_TEST_SUITE_P(Version,
QuicChromiumClientStreamTest,
::testing::ValuesIn(quic::AllSupportedTransportVersions()),
::testing::ValuesIn(quic::AllSupportedVersions()),
::testing::PrintToStringParamName());
TEST_P(QuicChromiumClientStreamTest, Handle) {
testing::InSequence seq;
EXPECT_TRUE(handle_->IsOpen());
EXPECT_EQ(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
EXPECT_EQ(quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
handle_->id());
EXPECT_EQ(quic::QUIC_NO_ERROR, handle_->connection_error());
EXPECT_EQ(quic::QUIC_STREAM_NO_ERROR, handle_->stream_error());
......@@ -298,7 +307,8 @@ TEST_P(QuicChromiumClientStreamTest, Handle) {
quic::QuicStreamOffset offset = 0;
ProcessHeadersFull(headers_);
quic::QuicStreamFrame frame2(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
true, offset, quic::QuicStringPiece());
stream_->OnStreamFrame(frame2);
EXPECT_TRUE(handle_->fin_received());
......@@ -309,7 +319,7 @@ TEST_P(QuicChromiumClientStreamTest, Handle) {
// All data written.
std::string header = ConstructDataHeader(kDataLen);
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
}
......@@ -321,8 +331,8 @@ TEST_P(QuicChromiumClientStreamTest, Handle) {
true, callback.callback()));
EXPECT_FALSE(handle_->IsOpen());
EXPECT_EQ(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
EXPECT_EQ(quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
handle_->id());
EXPECT_EQ(quic::QUIC_NO_ERROR, handle_->connection_error());
EXPECT_EQ(quic::QUIC_STREAM_NO_ERROR, handle_->stream_error());
......@@ -352,8 +362,8 @@ TEST_P(QuicChromiumClientStreamTest, Handle) {
TEST_P(QuicChromiumClientStreamTest, HandleAfterConnectionClose) {
EXPECT_CALL(
session_,
SendRstStream(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
SendRstStream(quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
quic::QUIC_RST_ACKNOWLEDGEMENT, 0));
stream_->OnConnectionClosed(quic::QUIC_INVALID_FRAME_DATA,
quic::ConnectionCloseSource::FROM_PEER);
......@@ -366,13 +376,14 @@ TEST_P(QuicChromiumClientStreamTest, HandleAfterStreamReset) {
// Verify that the Handle still behaves correctly after the stream is reset.
quic::QuicRstStreamFrame rst(
quic::kInvalidControlFrameId,
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
quic::QUIC_STREAM_CANCELLED, 0);
if (GetParam() != quic::QUIC_VERSION_99) {
if (version_.transport_version != quic::QUIC_VERSION_99) {
EXPECT_CALL(
session_,
SendRstStream(quic::test::GetNthClientInitiatedBidirectionalStreamId(
GetParam(), 0),
version_.transport_version, 0),
quic::QUIC_RST_ACKNOWLEDGEMENT, 0));
} else {
// Intercept & check that the call to the QuicConnection's OnStreamReast
......@@ -388,13 +399,14 @@ TEST_P(QuicChromiumClientStreamTest, HandleAfterStreamReset) {
}
stream_->OnStreamReset(rst);
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
// Make a STOP_SENDING frame and pass it to QUIC. For V99/IETF QUIC,
// we need both a REST_STREAM and a STOP_SENDING to effect a closed
// stream.
quic::QuicStopSendingFrame stop_sending_frame(
quic::kInvalidControlFrameId,
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
quic::QUIC_STREAM_CANCELLED);
session_.OnStopSendingFrame(stop_sending_frame);
}
......@@ -407,7 +419,8 @@ TEST_P(QuicChromiumClientStreamTest, OnFinRead) {
quic::QuicStreamOffset offset = 0;
ProcessHeadersFull(headers_);
quic::QuicStreamFrame frame2(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
true, offset, quic::QuicStringPiece());
stream_->OnStreamFrame(frame2);
}
......@@ -419,16 +432,18 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailable) {
const char data[] = "hello world!";
int data_len = strlen(data);
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, data));
......@@ -455,17 +470,19 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailableAfterReadBody) {
handle_->ReadBody(buffer.get(), 2 * data_len, callback.callback()));
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, data));
......@@ -480,8 +497,8 @@ TEST_P(QuicChromiumClientStreamTest, ProcessHeadersWithError) {
bad_headers["NAME"] = "...";
EXPECT_CALL(
session_,
SendRstStream(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
SendRstStream(quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
quic::QUIC_BAD_APPLICATION_PAYLOAD, 0));
auto headers = quic::test::AsHeaderList(bad_headers);
......@@ -497,8 +514,8 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailableWithError) {
ProcessHeadersFull(headers_);
EXPECT_CALL(
session_,
SendRstStream(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
SendRstStream(quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
quic::QUIC_STREAM_CANCELLED, 0));
const char data[] = "hello world!";
......@@ -516,16 +533,18 @@ TEST_P(QuicChromiumClientStreamTest, OnDataAvailableWithError) {
// Receive the data and close the stream during the callback.
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/0, data));
......@@ -546,16 +565,18 @@ TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
const char data[] = "hello world!";
int data_len = strlen(data);
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, data));
......@@ -569,7 +590,7 @@ TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
spdy::SpdyHeaderBlock trailers;
trailers["bar"] = "foo";
if (GetParam() != quic::QUIC_VERSION_99) {
if (version_.transport_version != quic::QUIC_VERSION_99) {
trailers[quic::kFinalOffsetHeaderKey] = base::NumberToString(strlen(data));
}
......@@ -600,16 +621,18 @@ TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
const char data[] = "hello world!";
int data_len = strlen(data);
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, data));
......@@ -628,7 +651,7 @@ TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
spdy::SpdyHeaderBlock trailers;
trailers["bar"] = "foo";
if (GetParam() != quic::QUIC_VERSION_99) {
if (version_.transport_version != quic::QUIC_VERSION_99) {
trailers[quic::kFinalOffsetHeaderKey] = base::NumberToString(strlen(data));
}
quic::QuicHeaderList t = ProcessTrailers(trailers);
......@@ -661,16 +684,18 @@ TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
const char data[] = "hello world!";
int data_len = strlen(data);
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(data_len);
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, header));
offset += header.length();
}
stream_->OnStreamFrame(quic::QuicStreamFrame(
quic::test::GetNthClientInitiatedBidirectionalStreamId(GetParam(), 0),
quic::test::GetNthClientInitiatedBidirectionalStreamId(
version_.transport_version, 0),
/*fin=*/false,
/*offset=*/offset, data));
......@@ -685,7 +710,7 @@ TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
// Deliver trailers. Delegate notification is posted asynchronously.
spdy::SpdyHeaderBlock trailers;
trailers["bar"] = "foo";
if (GetParam() != quic::QUIC_VERSION_99) {
if (version_.transport_version != quic::QUIC_VERSION_99) {
trailers[quic::kFinalOffsetHeaderKey] = base::NumberToString(strlen(data));
}
......@@ -726,7 +751,7 @@ TEST_P(QuicChromiumClientStreamTest, WriteStreamData) {
const size_t kDataLen = base::size(kData1);
// All data written.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(kDataLen);
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
......@@ -754,7 +779,7 @@ TEST_P(QuicChromiumClientStreamTest, WriteStreamDataAsync) {
ASSERT_FALSE(callback.have_result());
// All data written.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(kDataLen);
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
......@@ -763,7 +788,7 @@ TEST_P(QuicChromiumClientStreamTest, WriteStreamDataAsync) {
.WillOnce(Return(quic::QuicConsumedData(kDataLen, true)));
stream_->OnCanWrite();
// Do 2 writes in version 99.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
stream_->OnCanWrite();
}
ASSERT_TRUE(callback.have_result());
......@@ -778,14 +803,14 @@ TEST_P(QuicChromiumClientStreamTest, WritevStreamData) {
base::MakeRefCounted<StringIOBuffer>("Just a small payload");
// All data written.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(buf1->size());
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
}
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(buf1->size(), false)));
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(buf2->size());
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
......@@ -806,7 +831,7 @@ TEST_P(QuicChromiumClientStreamTest, WritevStreamDataAsync) {
base::MakeRefCounted<StringIOBuffer>("Just a small payload");
// Only a part of the data is written.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(buf1->size());
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
......@@ -825,7 +850,7 @@ TEST_P(QuicChromiumClientStreamTest, WritevStreamDataAsync) {
ASSERT_FALSE(callback.have_result());
// The second piece of data is written.
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(buf2->size());
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(header.length(), false)));
......@@ -833,7 +858,7 @@ TEST_P(QuicChromiumClientStreamTest, WritevStreamDataAsync) {
EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _))
.WillOnce(Return(quic::QuicConsumedData(buf2->size(), true)));
stream_->OnCanWrite();
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
stream_->OnCanWrite();
}
ASSERT_TRUE(callback.have_result());
......@@ -882,7 +907,7 @@ TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeHandle) {
const char data[] = "hello world!";
size_t offset = 0;
if (GetParam() == quic::QUIC_VERSION_99) {
if (version_.transport_version == quic::QUIC_VERSION_99) {
std::string header = ConstructDataHeader(strlen(data));
stream2->OnStreamFrame(quic::QuicStreamFrame(stream_id,
/*fin=*/false,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment