net/tools/quic/quic_dispatcher_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/tools/quic/quic_dispatcher.h"
   6
   7 #include <string>
   8
   9 #include "base/strings/string_piece.h"
  10 #include "net/quic/crypto/crypto_handshake.h"
  11 #include "net/quic/crypto/crypto_server_config.h"
  12 #include "net/quic/crypto/quic_random.h"
  13 #include "net/quic/quic_crypto_stream.h"
  14 #include "net/quic/test_tools/quic_test_utils.h"
  15 #include "net/tools/flip_server/epoll_server.h"
  16 #include "net/tools/quic/quic_time_wait_list_manager.h"
  17 #include "net/tools/quic/test_tools/quic_test_utils.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using base::StringPiece;
  22 using net::EpollServer;
  23 using net::test::MockSession;
  24 using net::tools::test::MockConnection;
  25 using testing::_;
  26 using testing::DoAll;
  27 using testing::Invoke;
  28 using testing::InSequence;
  29 using testing::Return;
  30 using testing::WithoutArgs;
  31
  32 namespace net {
  33 namespace tools {
  34 namespace test {
  35 class QuicDispatcherPeer {
  36  public:
  37   static void SetTimeWaitListManager(
  38       QuicDispatcher* dispatcher,
  39       QuicTimeWaitListManager* time_wait_list_manager) {
  40     dispatcher->time_wait_list_manager_.reset(time_wait_list_manager);
  41   }
  42
  43   static void SetWriteBlocked(QuicDispatcher* dispatcher) {
  44     dispatcher->write_blocked_ = true;
  45   }
  46 };
  47
  48 namespace {
  49
  50 class TestDispatcher : public QuicDispatcher {
  51  public:
  52   explicit TestDispatcher(const QuicConfig& config,
  53                           const QuicCryptoServerConfig& crypto_config,
  54                           EpollServer* eps)
  55       : QuicDispatcher(config, crypto_config, 1, eps) {}
  56
  57   MOCK_METHOD4(CreateQuicSession, QuicSession*(
  58       QuicGuid guid,
  59       const IPEndPoint& client_address,
  60       int fd,
  61       EpollServer* eps));
  62   using QuicDispatcher::write_blocked_list;
  63 };
  64
  65 // A Connection class which unregisters the session from the dispatcher
  66 // when sending connection close.
  67 // It'd be slightly more realistic to do this from the Session but it would
  68 // involve a lot more mocking.
  69 class MockServerConnection : public MockConnection {
  70  public:
  71   MockServerConnection(QuicGuid guid,
  72                        IPEndPoint address,
  73                        int fd,
  74                        EpollServer* eps,
  75                        QuicDispatcher* dispatcher)
  76       : MockConnection(guid, address, fd, eps, true),
  77         dispatcher_(dispatcher) {
  78   }
  79   void UnregisterOnConnectionClose() {
  80     LOG(ERROR) << "Unregistering " << guid();
  81     dispatcher_->OnConnectionClose(guid(), QUIC_NO_ERROR);
  82   }
  83  private:
  84   QuicDispatcher* dispatcher_;
  85 };
  86
  87 QuicSession* CreateSession(QuicDispatcher* dispatcher,
  88                            QuicGuid guid,
  89                            const IPEndPoint& addr,
  90                            MockSession** session,
  91                            EpollServer* eps) {
  92   MockServerConnection* connection =
  93       new MockServerConnection(guid, addr, 0, eps, dispatcher);
  94   *session = new MockSession(connection, true);
  95   ON_CALL(*connection, SendConnectionClose(_)).WillByDefault(
  96       WithoutArgs(Invoke(
  97           connection, &MockServerConnection::UnregisterOnConnectionClose)));
  98   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
  99               ProcessUdpPacket(_, addr, _));
 100
 101   return *session;
 102 }
 103
 104 class QuicDispatcherTest : public ::testing::Test {
 105  public:
 106   QuicDispatcherTest()
 107       : crypto_config_(QuicCryptoServerConfig::TESTING,
 108                        QuicRandom::GetInstance()),
 109         dispatcher_(config_, crypto_config_, &eps_),
 110         session1_(NULL),
 111         session2_(NULL) {
 112   }
 113
 114   virtual ~QuicDispatcherTest() {}
 115
 116   MockConnection* connection1() {
 117     return reinterpret_cast<MockConnection*>(session1_->connection());
 118   }
 119
 120   MockConnection* connection2() {
 121     return reinterpret_cast<MockConnection*>(session2_->connection());
 122   }
 123
 124   void ProcessPacket(IPEndPoint addr,
 125                      QuicGuid guid,
 126                      const string& data) {
 127     QuicEncryptedPacket packet(data.data(), data.length());
 128     dispatcher_.ProcessPacket(IPEndPoint(), addr, guid, packet);
 129   }
 130
 131   void ValidatePacket(const QuicEncryptedPacket& packet) {
 132     EXPECT_TRUE(packet.AsStringPiece().find(data_) != StringPiece::npos);
 133   }
 134
 135   IPAddressNumber Loopback4() {
 136     net::IPAddressNumber addr;
 137     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &addr));
 138     return addr;
 139   }
 140
 141   EpollServer eps_;
 142   QuicConfig config_;
 143   QuicCryptoServerConfig crypto_config_;
 144   TestDispatcher dispatcher_;
 145   MockSession* session1_;
 146   MockSession* session2_;
 147   string data_;
 148 };
 149
 150 TEST_F(QuicDispatcherTest, ProcessPackets) {
 151   IPEndPoint addr(Loopback4(), 1);
 152
 153   EXPECT_CALL(dispatcher_, CreateQuicSession(1, addr, _, &eps_))
 154       .WillOnce(testing::Return(CreateSession(
 155           &dispatcher_, 1, addr, &session1_, &eps_)));
 156   ProcessPacket(addr, 1, "foo");
 157
 158   EXPECT_CALL(dispatcher_, CreateQuicSession(2, addr, _, &eps_))
 159       .WillOnce(testing::Return(CreateSession(
 160                     &dispatcher_, 2, addr, &session2_, &eps_)));
 161   ProcessPacket(addr, 2, "bar");
 162
 163   data_ = "eep";
 164   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
 165               ProcessUdpPacket(_, _, _)).Times(1).
 166       WillOnce(testing::WithArgs<2>(Invoke(
 167           this, &QuicDispatcherTest::ValidatePacket)));
 168   ProcessPacket(addr, 1, "eep");
 169 }
 170
 171 TEST_F(QuicDispatcherTest, Shutdown) {
 172   IPEndPoint addr(Loopback4(), 1);
 173
 174   EXPECT_CALL(dispatcher_, CreateQuicSession(_, addr, _, &eps_))
 175       .WillOnce(testing::Return(CreateSession(
 176                     &dispatcher_, 1, addr, &session1_, &eps_)));
 177
 178   ProcessPacket(addr, 1, "foo");
 179
 180   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
 181               SendConnectionClose(QUIC_PEER_GOING_AWAY));
 182
 183   dispatcher_.Shutdown();
 184 }
 185
 186 class MockTimeWaitListManager : public QuicTimeWaitListManager {
 187  public:
 188   MockTimeWaitListManager(QuicPacketWriter* writer,
 189                           EpollServer* eps)
 190       : QuicTimeWaitListManager(writer, eps) {
 191   }
 192
 193   MOCK_METHOD4(ProcessPacket, void(const IPEndPoint& server_address,
 194                                    const IPEndPoint& client_address,
 195                                    QuicGuid guid,
 196                                    const QuicEncryptedPacket& packet));
 197 };
 198
 199 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
 200   MockTimeWaitListManager* time_wait_list_manager =
 201       new MockTimeWaitListManager(&dispatcher_, &eps_);
 202   // dispatcher takes the ownership of time_wait_list_manager.
 203   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
 204                                              time_wait_list_manager);
 205   // Create a new session.
 206   IPEndPoint addr(Loopback4(), 1);
 207   QuicGuid guid = 1;
 208   EXPECT_CALL(dispatcher_, CreateQuicSession(guid, addr, _, &eps_))
 209       .WillOnce(testing::Return(CreateSession(
 210                     &dispatcher_, guid, addr, &session1_, &eps_)));
 211   ProcessPacket(addr, guid, "foo");
 212
 213   // Close the connection by sending public reset packet.
 214   QuicPublicResetPacket packet;
 215   packet.public_header.guid = guid;
 216   packet.public_header.reset_flag = true;
 217   packet.public_header.version_flag = false;
 218   packet.rejected_sequence_number = 19191;
 219   packet.nonce_proof = 132232;
 220   scoped_ptr<QuicEncryptedPacket> encrypted(
 221       QuicFramer::BuildPublicResetPacket(packet));
 222   EXPECT_CALL(*session1_, ConnectionClose(QUIC_PUBLIC_RESET, true)).Times(1)
 223       .WillOnce(WithoutArgs(Invoke(
 224           reinterpret_cast<MockServerConnection*>(session1_->connection()),
 225           &MockServerConnection::UnregisterOnConnectionClose)));
 226   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
 227               ProcessUdpPacket(_, _, _))
 228       .WillOnce(Invoke(
 229           reinterpret_cast<MockConnection*>(session1_->connection()),
 230           &MockConnection::ReallyProcessUdpPacket));
 231   dispatcher_.ProcessPacket(IPEndPoint(), addr, guid, *encrypted);
 232   EXPECT_TRUE(time_wait_list_manager->IsGuidInTimeWait(guid));
 233
 234   // Dispatcher forwards subsequent packets for this guid to the time wait list
 235   // manager.
 236   EXPECT_CALL(*time_wait_list_manager, ProcessPacket(_, _, guid, _)).Times(1);
 237   ProcessPacket(addr, guid, "foo");
 238 }
 239
 240 class WriteBlockedListTest : public QuicDispatcherTest {
 241  public:
 242   virtual void SetUp() {
 243     IPEndPoint addr(Loopback4(), 1);
 244
 245     EXPECT_CALL(dispatcher_, CreateQuicSession(_, addr, _, &eps_))
 246         .WillOnce(testing::Return(CreateSession(
 247                       &dispatcher_, 1, addr, &session1_, &eps_)));
 248     ProcessPacket(addr, 1, "foo");
 249
 250     EXPECT_CALL(dispatcher_, CreateQuicSession(_, addr, _, &eps_))
 251         .WillOnce(testing::Return(CreateSession(
 252                       &dispatcher_, 2, addr, &session2_, &eps_)));
 253     ProcessPacket(addr, 2, "bar");
 254
 255     blocked_list_ = dispatcher_.write_blocked_list();
 256   }
 257
 258   virtual void TearDown() {
 259     EXPECT_CALL(*connection1(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
 260     EXPECT_CALL(*connection2(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
 261     dispatcher_.Shutdown();
 262   }
 263
 264   bool SetBlocked() {
 265     QuicDispatcherPeer::SetWriteBlocked(&dispatcher_);
 266     return true;
 267   }
 268
 269  protected:
 270   QuicDispatcher::WriteBlockedList* blocked_list_;
 271 };
 272
 273 TEST_F(WriteBlockedListTest, BasicOnCanWrite) {
 274   // No OnCanWrite calls because no connections are blocked.
 275   dispatcher_.OnCanWrite();
 276
 277   // Register connection 1 for events, and make sure it's nofitied.
 278   blocked_list_->AddBlockedObject(connection1());
 279   EXPECT_CALL(*connection1(), OnCanWrite());
 280   dispatcher_.OnCanWrite();
 281
 282   // It should get only one notification.
 283   EXPECT_CALL(*connection1(), OnCanWrite()).Times(0);
 284   EXPECT_FALSE(dispatcher_.OnCanWrite());
 285 }
 286
 287 TEST_F(WriteBlockedListTest, OnCanWriteOrder) {
 288   // Make sure we handle events in order.
 289   InSequence s;
 290   blocked_list_->AddBlockedObject(connection1());
 291   blocked_list_->AddBlockedObject(connection2());
 292   EXPECT_CALL(*connection1(), OnCanWrite());
 293   EXPECT_CALL(*connection2(), OnCanWrite());
 294   dispatcher_.OnCanWrite();
 295
 296   // Check the other ordering.
 297   blocked_list_->AddBlockedObject(connection2());
 298   blocked_list_->AddBlockedObject(connection1());
 299   EXPECT_CALL(*connection2(), OnCanWrite());
 300   EXPECT_CALL(*connection1(), OnCanWrite());
 301   dispatcher_.OnCanWrite();
 302 }
 303
 304 TEST_F(WriteBlockedListTest, OnCanWriteRemove) {
 305   // Add and remove one connction.
 306   blocked_list_->AddBlockedObject(connection1());
 307   blocked_list_->RemoveBlockedObject(connection1());
 308   EXPECT_CALL(*connection1(), OnCanWrite()).Times(0);
 309   dispatcher_.OnCanWrite();
 310
 311   // Add and remove one connction and make sure it doesn't affect others.
 312   blocked_list_->AddBlockedObject(connection1());
 313   blocked_list_->AddBlockedObject(connection2());
 314   blocked_list_->RemoveBlockedObject(connection1());
 315   EXPECT_CALL(*connection2(), OnCanWrite());
 316   dispatcher_.OnCanWrite();
 317
 318   // Add it, remove it, and add it back and make sure things are OK.
 319   blocked_list_->AddBlockedObject(connection1());
 320   blocked_list_->RemoveBlockedObject(connection1());
 321   blocked_list_->AddBlockedObject(connection1());
 322   EXPECT_CALL(*connection1(), OnCanWrite()).Times(1);
 323   dispatcher_.OnCanWrite();
 324 }
 325
 326 TEST_F(WriteBlockedListTest, DoubleAdd) {
 327   // Make sure a double add does not necessitate a double remove.
 328   blocked_list_->AddBlockedObject(connection1());
 329   blocked_list_->AddBlockedObject(connection1());
 330   blocked_list_->RemoveBlockedObject(connection1());
 331   EXPECT_CALL(*connection1(), OnCanWrite()).Times(0);
 332   dispatcher_.OnCanWrite();
 333
 334   // Make sure a double add does not result in two OnCanWrite calls.
 335   blocked_list_->AddBlockedObject(connection1());
 336   blocked_list_->AddBlockedObject(connection1());
 337   EXPECT_CALL(*connection1(), OnCanWrite()).Times(1);
 338   dispatcher_.OnCanWrite();
 339 }
 340
 341 TEST_F(WriteBlockedListTest, OnCanWriteHandleBlock) {
 342   // Finally make sure if we write block on a write call, we stop calling.
 343   InSequence s;
 344   blocked_list_->AddBlockedObject(connection1());
 345   blocked_list_->AddBlockedObject(connection2());
 346   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(
 347       Invoke(this, &WriteBlockedListTest::SetBlocked));
 348   EXPECT_CALL(*connection2(), OnCanWrite()).Times(0);
 349   dispatcher_.OnCanWrite();
 350
 351   // And we'll resume where we left off when we get another call.
 352   EXPECT_CALL(*connection2(), OnCanWrite());
 353   dispatcher_.OnCanWrite();
 354 }
 355
 356 TEST_F(WriteBlockedListTest, LimitedWrites) {
 357   // Make sure we call both writers.  The first will register for more writing
 358   // but should not be immediately called due to limits.
 359   InSequence s;
 360   blocked_list_->AddBlockedObject(connection1());
 361   blocked_list_->AddBlockedObject(connection2());
 362   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(Return(true));
 363   EXPECT_CALL(*connection2(), OnCanWrite()).WillOnce(Return(false));
 364   dispatcher_.OnCanWrite();
 365
 366   // Now call OnCanWrite again, and connection1 should get its second chance
 367   EXPECT_CALL(*connection1(), OnCanWrite());
 368   dispatcher_.OnCanWrite();
 369 }
 370
 371 TEST_F(WriteBlockedListTest, TestWriteLimits) {
 372   // Finally make sure if we write block on a write call, we stop calling.
 373   InSequence s;
 374   blocked_list_->AddBlockedObject(connection1());
 375   blocked_list_->AddBlockedObject(connection2());
 376   EXPECT_CALL(*connection1(), OnCanWrite()).WillOnce(
 377       Invoke(this, &WriteBlockedListTest::SetBlocked));
 378   EXPECT_CALL(*connection2(), OnCanWrite()).Times(0);
 379   dispatcher_.OnCanWrite();
 380
 381   // And we'll resume where we left off when we get another call.
 382   EXPECT_CALL(*connection2(), OnCanWrite());
 383   dispatcher_.OnCanWrite();
 384 }
 385
 386
 387 }  // namespace
 388 }  // namespace test
 389 }  // namespace tools
 390 }  // namespace net