src/net/quic/quic_client_session_test.cc

   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 "net/quic/quic_client_session.h"
   6
   7 #include <vector>
   8
   9 #include "base/rand_util.h"
  10 #include "net/base/capturing_net_log.h"
  11 #include "net/base/test_completion_callback.h"
  12 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
  13 #include "net/quic/crypto/crypto_protocol.h"
  14 #include "net/quic/crypto/quic_decrypter.h"
  15 #include "net/quic/crypto/quic_encrypter.h"
  16 #include "net/quic/crypto/quic_server_info.h"
  17 #include "net/quic/quic_default_packet_writer.h"
  18 #include "net/quic/test_tools/crypto_test_utils.h"
  19 #include "net/quic/test_tools/quic_client_session_peer.h"
  20 #include "net/quic/test_tools/quic_test_utils.h"
  21 #include "net/quic/test_tools/simple_quic_framer.h"
  22 #include "net/socket/socket_test_util.h"
  23 #include "net/udp/datagram_client_socket.h"
  24
  25 using testing::_;
  26
  27 namespace net {
  28 namespace test {
  29 namespace {
  30
  31 const char kServerHostname[] = "www.example.com";
  32 const uint16 kServerPort = 80;
  33
  34 class TestPacketWriter : public QuicDefaultPacketWriter {
  35  public:
  36   TestPacketWriter(QuicVersion version) : version_(version) {
  37   }
  38
  39   // QuicPacketWriter
  40   virtual WriteResult WritePacket(
  41       const char* buffer, size_t buf_len,
  42       const IPAddressNumber& self_address,
  43       const IPEndPoint& peer_address) OVERRIDE {
  44     SimpleQuicFramer framer(SupportedVersions(version_));
  45     QuicEncryptedPacket packet(buffer, buf_len);
  46     EXPECT_TRUE(framer.ProcessPacket(packet));
  47     header_ = framer.header();
  48     return WriteResult(WRITE_STATUS_OK, packet.length());
  49   }
  50
  51   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
  52     // Chrome sockets' Write() methods buffer the data until the Write is
  53     // permitted.
  54     return true;
  55   }
  56
  57   // Returns the header from the last packet written.
  58   const QuicPacketHeader& header() { return header_; }
  59
  60  private:
  61   QuicVersion version_;
  62   QuicPacketHeader header_;
  63 };
  64
  65 class QuicClientSessionTest : public ::testing::TestWithParam<QuicVersion> {
  66  protected:
  67   QuicClientSessionTest()
  68       : writer_(new TestPacketWriter(GetParam())),
  69         connection_(
  70             new PacketSavingConnection(false, SupportedVersions(GetParam()))),
  71         session_(connection_, GetSocket().Pass(), writer_.Pass(), NULL, NULL,
  72                  make_scoped_ptr((QuicServerInfo*)NULL),
  73                  QuicServerId(kServerHostname, kServerPort, false,
  74                               PRIVACY_MODE_DISABLED),
  75                  DefaultQuicConfig(), &crypto_config_, &net_log_) {
  76     session_.config()->SetDefaults();
  77     crypto_config_.SetDefaults();
  78   }
  79
  80   virtual void TearDown() OVERRIDE {
  81     session_.CloseSessionOnError(ERR_ABORTED);
  82   }
  83
  84   scoped_ptr<DatagramClientSocket> GetSocket() {
  85     socket_factory_.AddSocketDataProvider(&socket_data_);
  86     return socket_factory_.CreateDatagramClientSocket(
  87         DatagramSocket::DEFAULT_BIND, base::Bind(&base::RandInt),
  88         &net_log_, NetLog::Source());
  89   }
  90
  91   void CompleteCryptoHandshake() {
  92     ASSERT_EQ(ERR_IO_PENDING,
  93               session_.CryptoConnect(false, callback_.callback()));
  94     CryptoTestUtils::HandshakeWithFakeServer(
  95         connection_, session_.GetCryptoStream());
  96     ASSERT_EQ(OK, callback_.WaitForResult());
  97   }
  98
  99   scoped_ptr<QuicDefaultPacketWriter> writer_;
 100   PacketSavingConnection* connection_;
 101   CapturingNetLog net_log_;
 102   MockClientSocketFactory socket_factory_;
 103   StaticSocketDataProvider socket_data_;
 104   QuicClientSession session_;
 105   MockClock clock_;
 106   MockRandom random_;
 107   QuicConnectionVisitorInterface* visitor_;
 108   TestCompletionCallback callback_;
 109   QuicCryptoClientConfig crypto_config_;
 110 };
 111
 112 INSTANTIATE_TEST_CASE_P(Tests, QuicClientSessionTest,
 113                         ::testing::ValuesIn(QuicSupportedVersions()));
 114
 115 TEST_P(QuicClientSessionTest, CryptoConnect) {
 116   CompleteCryptoHandshake();
 117 }
 118
 119 TEST_P(QuicClientSessionTest, MaxNumStreams) {
 120   CompleteCryptoHandshake();
 121
 122   std::vector<QuicReliableClientStream*> streams;
 123   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
 124     QuicReliableClientStream* stream = session_.CreateOutgoingDataStream();
 125     EXPECT_TRUE(stream);
 126     streams.push_back(stream);
 127   }
 128   EXPECT_FALSE(session_.CreateOutgoingDataStream());
 129
 130   // Close a stream and ensure I can now open a new one.
 131   session_.CloseStream(streams[0]->id());
 132   EXPECT_TRUE(session_.CreateOutgoingDataStream());
 133 }
 134
 135 TEST_P(QuicClientSessionTest, MaxNumStreamsViaRequest) {
 136   CompleteCryptoHandshake();
 137
 138   std::vector<QuicReliableClientStream*> streams;
 139   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
 140     QuicReliableClientStream* stream = session_.CreateOutgoingDataStream();
 141     EXPECT_TRUE(stream);
 142     streams.push_back(stream);
 143   }
 144
 145   QuicReliableClientStream* stream;
 146   QuicClientSession::StreamRequest stream_request;
 147   TestCompletionCallback callback;
 148   ASSERT_EQ(ERR_IO_PENDING,
 149             stream_request.StartRequest(session_.GetWeakPtr(), &stream,
 150                                         callback.callback()));
 151
 152   // Close a stream and ensure I can now open a new one.
 153   session_.CloseStream(streams[0]->id());
 154   ASSERT_TRUE(callback.have_result());
 155   EXPECT_EQ(OK, callback.WaitForResult());
 156   EXPECT_TRUE(stream != NULL);
 157 }
 158
 159 TEST_P(QuicClientSessionTest, GoAwayReceived) {
 160   CompleteCryptoHandshake();
 161
 162   // After receiving a GoAway, I should no longer be able to create outgoing
 163   // streams.
 164   session_.OnGoAway(QuicGoAwayFrame(QUIC_PEER_GOING_AWAY, 1u, "Going away."));
 165   EXPECT_EQ(NULL, session_.CreateOutgoingDataStream());
 166 }
 167
 168 }  // namespace
 169 }  // namespace test
 170 }  // namespace net