net/socket/websocket_endpoint_lock_manager_unittest.cc

   1 // Copyright 2014 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/socket/websocket_endpoint_lock_manager.h"
   6
   7 #include "net/base/net_errors.h"
   8 #include "net/socket/next_proto.h"
   9 #include "net/socket/socket_test_util.h"
  10 #include "net/socket/stream_socket.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace net {
  14
  15 namespace {
  16
  17 // A StreamSocket implementation with no functionality at all.
  18 // TODO(ricea): If you need to use this in another file, please move it to
  19 // socket_test_util.h.
  20 class FakeStreamSocket : public StreamSocket {
  21  public:
  22   FakeStreamSocket() {}
  23
  24   // StreamSocket implementation
  25   int Connect(const CompletionCallback& callback) override {
  26     return ERR_FAILED;
  27   }
  28
  29   void Disconnect() override { return; }
  30
  31   bool IsConnected() const override { return false; }
  32
  33   bool IsConnectedAndIdle() const override { return false; }
  34
  35   int GetPeerAddress(IPEndPoint* address) const override { return ERR_FAILED; }
  36
  37   int GetLocalAddress(IPEndPoint* address) const override { return ERR_FAILED; }
  38
  39   const BoundNetLog& NetLog() const override { return bound_net_log_; }
  40
  41   void SetSubresourceSpeculation() override { return; }
  42   void SetOmniboxSpeculation() override { return; }
  43
  44   bool WasEverUsed() const override { return false; }
  45
  46   bool UsingTCPFastOpen() const override { return false; }
  47
  48   bool WasNpnNegotiated() const override { return false; }
  49
  50   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  51
  52   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
  53
  54   // Socket implementation
  55   int Read(IOBuffer* buf,
  56            int buf_len,
  57            const CompletionCallback& callback) override {
  58     return ERR_FAILED;
  59   }
  60
  61   int Write(IOBuffer* buf,
  62             int buf_len,
  63             const CompletionCallback& callback) override {
  64     return ERR_FAILED;
  65   }
  66
  67   int SetReceiveBufferSize(int32 size) override { return ERR_FAILED; }
  68
  69   int SetSendBufferSize(int32 size) override { return ERR_FAILED; }
  70
  71  private:
  72   BoundNetLog bound_net_log_;
  73
  74   DISALLOW_COPY_AND_ASSIGN(FakeStreamSocket);
  75 };
  76
  77 class FakeWaiter : public WebSocketEndpointLockManager::Waiter {
  78  public:
  79   FakeWaiter() : called_(false) {}
  80
  81   void GotEndpointLock() override {
  82     CHECK(!called_);
  83     called_ = true;
  84   }
  85
  86   bool called() const { return called_; }
  87
  88  private:
  89   bool called_;
  90 };
  91
  92 class WebSocketEndpointLockManagerTest : public ::testing::Test {
  93  protected:
  94   WebSocketEndpointLockManagerTest()
  95       : instance_(WebSocketEndpointLockManager::GetInstance()) {}
  96   ~WebSocketEndpointLockManagerTest() override {
  97     // If this check fails then subsequent tests may fail.
  98     CHECK(instance_->IsEmpty());
  99   }
 100
 101   WebSocketEndpointLockManager* instance() const { return instance_; }
 102
 103   IPEndPoint DummyEndpoint() {
 104     IPAddressNumber ip_address_number;
 105     CHECK(ParseIPLiteralToNumber("127.0.0.1", &ip_address_number));
 106     return IPEndPoint(ip_address_number, 80);
 107   }
 108
 109   void UnlockDummyEndpoint(int times) {
 110     for (int i = 0; i < times; ++i) {
 111       instance()->UnlockEndpoint(DummyEndpoint());
 112     }
 113   }
 114
 115   WebSocketEndpointLockManager* const instance_;
 116 };
 117
 118 TEST_F(WebSocketEndpointLockManagerTest, GetInstanceWorks) {
 119   // All the work is done by the test framework.
 120 }
 121
 122 TEST_F(WebSocketEndpointLockManagerTest, LockEndpointReturnsOkOnce) {
 123   FakeWaiter waiters[2];
 124   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiters[0]));
 125   EXPECT_EQ(ERR_IO_PENDING,
 126             instance()->LockEndpoint(DummyEndpoint(), &waiters[1]));
 127
 128   UnlockDummyEndpoint(2);
 129 }
 130
 131 TEST_F(WebSocketEndpointLockManagerTest, GotEndpointLockNotCalledOnOk) {
 132   FakeWaiter waiter;
 133   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiter));
 134   EXPECT_FALSE(waiter.called());
 135
 136   UnlockDummyEndpoint(1);
 137 }
 138
 139 TEST_F(WebSocketEndpointLockManagerTest, GotEndpointLockNotCalledImmediately) {
 140   FakeWaiter waiters[2];
 141   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiters[0]));
 142   EXPECT_EQ(ERR_IO_PENDING,
 143             instance()->LockEndpoint(DummyEndpoint(), &waiters[1]));
 144   EXPECT_FALSE(waiters[1].called());
 145
 146   UnlockDummyEndpoint(2);
 147 }
 148
 149 TEST_F(WebSocketEndpointLockManagerTest, GotEndpointLockCalledWhenUnlocked) {
 150   FakeWaiter waiters[2];
 151   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiters[0]));
 152   EXPECT_EQ(ERR_IO_PENDING,
 153             instance()->LockEndpoint(DummyEndpoint(), &waiters[1]));
 154   instance()->UnlockEndpoint(DummyEndpoint());
 155   EXPECT_TRUE(waiters[1].called());
 156
 157   UnlockDummyEndpoint(1);
 158 }
 159
 160 TEST_F(WebSocketEndpointLockManagerTest,
 161        EndpointUnlockedIfWaiterAlreadyDeleted) {
 162   FakeWaiter first_lock_holder;
 163   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &first_lock_holder));
 164
 165   {
 166     FakeWaiter short_lived_waiter;
 167     EXPECT_EQ(ERR_IO_PENDING,
 168               instance()->LockEndpoint(DummyEndpoint(), &short_lived_waiter));
 169   }
 170
 171   instance()->UnlockEndpoint(DummyEndpoint());
 172
 173   FakeWaiter second_lock_holder;
 174   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &second_lock_holder));
 175
 176   UnlockDummyEndpoint(1);
 177 }
 178
 179 TEST_F(WebSocketEndpointLockManagerTest, RememberSocketWorks) {
 180   FakeWaiter waiters[2];
 181   FakeStreamSocket dummy_socket;
 182   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiters[0]));
 183   EXPECT_EQ(ERR_IO_PENDING,
 184             instance()->LockEndpoint(DummyEndpoint(), &waiters[1]));
 185
 186   instance()->RememberSocket(&dummy_socket, DummyEndpoint());
 187   instance()->UnlockSocket(&dummy_socket);
 188   EXPECT_TRUE(waiters[1].called());
 189
 190   UnlockDummyEndpoint(1);
 191 }
 192
 193 // UnlockEndpoint() should cause any sockets remembered for this endpoint
 194 // to be forgotten.
 195 TEST_F(WebSocketEndpointLockManagerTest, SocketAssociationForgottenOnUnlock) {
 196   FakeWaiter waiter;
 197   FakeStreamSocket dummy_socket;
 198
 199   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiter));
 200   instance()->RememberSocket(&dummy_socket, DummyEndpoint());
 201   instance()->UnlockEndpoint(DummyEndpoint());
 202   EXPECT_TRUE(instance()->IsEmpty());
 203 }
 204
 205 // When ownership of the endpoint is passed to a new waiter, the new waiter can
 206 // call RememberSocket() again.
 207 TEST_F(WebSocketEndpointLockManagerTest, NextWaiterCanCallRememberSocketAgain) {
 208   FakeWaiter waiters[2];
 209   FakeStreamSocket dummy_sockets[2];
 210   EXPECT_EQ(OK, instance()->LockEndpoint(DummyEndpoint(), &waiters[0]));
 211   EXPECT_EQ(ERR_IO_PENDING,
 212             instance()->LockEndpoint(DummyEndpoint(), &waiters[1]));
 213
 214   instance()->RememberSocket(&dummy_sockets[0], DummyEndpoint());
 215   instance()->UnlockEndpoint(DummyEndpoint());
 216   EXPECT_TRUE(waiters[1].called());
 217   instance()->RememberSocket(&dummy_sockets[1], DummyEndpoint());
 218
 219   UnlockDummyEndpoint(1);
 220 }
 221
 222 }  // namespace
 223
 224 }  // namespace net