chrome/browser/extensions/api/socket/tcp_socket_unittest.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 "extensions/browser/api/socket/tcp_socket.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "net/base/address_list.h"
   9 #include "net/base/completion_callback.h"
  10 #include "net/base/io_buffer.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/base/rand_callback.h"
  13 #include "net/socket/tcp_client_socket.h"
  14 #include "net/socket/tcp_server_socket.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16
  17 using testing::_;
  18 using testing::DoAll;
  19 using testing::Return;
  20 using testing::SaveArg;
  21
  22 namespace extensions {
  23
  24 class MockTCPSocket : public net::TCPClientSocket {
  25  public:
  26   explicit MockTCPSocket(const net::AddressList& address_list)
  27       : net::TCPClientSocket(address_list, NULL, net::NetLog::Source()) {
  28   }
  29
  30   MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
  31                          const net::CompletionCallback& callback));
  32   MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
  33                           const net::CompletionCallback& callback));
  34   MOCK_METHOD2(SetKeepAlive, bool(bool enable, int delay));
  35   MOCK_METHOD1(SetNoDelay, bool(bool no_delay));
  36   bool IsConnected() const override {
  37     return true;
  38   }
  39
  40  private:
  41   DISALLOW_COPY_AND_ASSIGN(MockTCPSocket);
  42 };
  43
  44 class MockTCPServerSocket : public net::TCPServerSocket {
  45  public:
  46   explicit MockTCPServerSocket()
  47       : net::TCPServerSocket(NULL, net::NetLog::Source()) {
  48   }
  49   MOCK_METHOD2(Listen, int(const net::IPEndPoint& address, int backlog));
  50   MOCK_METHOD2(Accept, int(scoped_ptr<net::StreamSocket>* socket,
  51                             const net::CompletionCallback& callback));
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(MockTCPServerSocket);
  55 };
  56
  57 class CompleteHandler {
  58  public:
  59   CompleteHandler() {}
  60   MOCK_METHOD1(OnComplete, void(int result_code));
  61   MOCK_METHOD2(OnReadComplete, void(int result_code,
  62       scoped_refptr<net::IOBuffer> io_buffer));
  63   MOCK_METHOD2(OnAccept, void(int, net::TCPClientSocket*));
  64  private:
  65   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
  66 };
  67
  68 const std::string FAKE_ID = "abcdefghijklmnopqrst";
  69
  70 TEST(SocketTest, TestTCPSocketRead) {
  71   net::AddressList address_list;
  72   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
  73   CompleteHandler handler;
  74
  75   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
  76       tcp_client_socket, FAKE_ID, true));
  77
  78   EXPECT_CALL(*tcp_client_socket, Read(_, _, _))
  79       .Times(1);
  80   EXPECT_CALL(handler, OnReadComplete(_, _))
  81       .Times(1);
  82
  83   const int count = 512;
  84   socket->Read(count, base::Bind(&CompleteHandler::OnReadComplete,
  85         base::Unretained(&handler)));
  86 }
  87
  88 TEST(SocketTest, TestTCPSocketWrite) {
  89   net::AddressList address_list;
  90   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
  91   CompleteHandler handler;
  92
  93   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
  94       tcp_client_socket, FAKE_ID, true));
  95
  96   net::CompletionCallback callback;
  97   EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
  98       .Times(2)
  99       .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
 100                                      Return(128)));
 101   EXPECT_CALL(handler, OnComplete(_))
 102       .Times(1);
 103
 104   scoped_refptr<net::IOBufferWithSize> io_buffer(
 105       new net::IOBufferWithSize(256));
 106   socket->Write(io_buffer.get(), io_buffer->size(),
 107       base::Bind(&CompleteHandler::OnComplete, base::Unretained(&handler)));
 108 }
 109
 110 TEST(SocketTest, TestTCPSocketBlockedWrite) {
 111   net::AddressList address_list;
 112   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
 113   CompleteHandler handler;
 114
 115   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
 116       tcp_client_socket, FAKE_ID, true));
 117
 118   net::CompletionCallback callback;
 119   EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
 120       .Times(2)
 121       .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
 122                                      Return(net::ERR_IO_PENDING)));
 123   scoped_refptr<net::IOBufferWithSize> io_buffer(new net::IOBufferWithSize(42));
 124   socket->Write(io_buffer.get(), io_buffer->size(),
 125       base::Bind(&CompleteHandler::OnComplete, base::Unretained(&handler)));
 126
 127   // Good. Original call came back unable to complete. Now pretend the socket
 128   // finished, and confirm that we passed the error back.
 129   EXPECT_CALL(handler, OnComplete(42))
 130       .Times(1);
 131   callback.Run(40);
 132   callback.Run(2);
 133 }
 134
 135 TEST(SocketTest, TestTCPSocketBlockedWriteReentry) {
 136   net::AddressList address_list;
 137   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
 138   CompleteHandler handlers[5];
 139
 140   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
 141       tcp_client_socket, FAKE_ID, true));
 142
 143   net::CompletionCallback callback;
 144   EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
 145       .Times(5)
 146       .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
 147                                      Return(net::ERR_IO_PENDING)));
 148   scoped_refptr<net::IOBufferWithSize> io_buffers[5];
 149   int i;
 150   for (i = 0; i < 5; i++) {
 151     io_buffers[i] = new net::IOBufferWithSize(128 + i * 50);
 152     scoped_refptr<net::IOBufferWithSize> io_buffer1(
 153         new net::IOBufferWithSize(42));
 154     socket->Write(io_buffers[i].get(), io_buffers[i]->size(),
 155         base::Bind(&CompleteHandler::OnComplete,
 156             base::Unretained(&handlers[i])));
 157
 158     EXPECT_CALL(handlers[i], OnComplete(io_buffers[i]->size()))
 159         .Times(1);
 160   }
 161
 162   for (i = 0; i < 5; i++) {
 163     callback.Run(128 + i * 50);
 164   }
 165 }
 166
 167 TEST(SocketTest, TestTCPSocketSetNoDelay) {
 168   net::AddressList address_list;
 169   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
 170
 171   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
 172       tcp_client_socket, FAKE_ID));
 173
 174   bool no_delay = false;
 175   EXPECT_CALL(*tcp_client_socket, SetNoDelay(_))
 176       .WillOnce(testing::DoAll(SaveArg<0>(&no_delay), Return(true)));
 177   int result = socket->SetNoDelay(true);
 178   EXPECT_TRUE(result);
 179   EXPECT_TRUE(no_delay);
 180
 181   EXPECT_CALL(*tcp_client_socket, SetNoDelay(_))
 182       .WillOnce(testing::DoAll(SaveArg<0>(&no_delay), Return(false)));
 183
 184   result = socket->SetNoDelay(false);
 185   EXPECT_FALSE(result);
 186   EXPECT_FALSE(no_delay);
 187 }
 188
 189 TEST(SocketTest, TestTCPSocketSetKeepAlive) {
 190   net::AddressList address_list;
 191   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
 192
 193   scoped_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
 194       tcp_client_socket, FAKE_ID));
 195
 196   bool enable = false;
 197   int delay = 0;
 198   EXPECT_CALL(*tcp_client_socket, SetKeepAlive(_, _))
 199       .WillOnce(testing::DoAll(SaveArg<0>(&enable),
 200                                SaveArg<1>(&delay),
 201                                Return(true)));
 202   int result = socket->SetKeepAlive(true, 4500);
 203   EXPECT_TRUE(result);
 204   EXPECT_TRUE(enable);
 205   EXPECT_EQ(4500, delay);
 206
 207   EXPECT_CALL(*tcp_client_socket, SetKeepAlive(_, _))
 208       .WillOnce(testing::DoAll(SaveArg<0>(&enable),
 209                                SaveArg<1>(&delay),
 210                                Return(false)));
 211   result = socket->SetKeepAlive(false, 0);
 212   EXPECT_FALSE(result);
 213   EXPECT_FALSE(enable);
 214   EXPECT_EQ(0, delay);
 215 }
 216
 217 TEST(SocketTest, TestTCPServerSocketListenAccept) {
 218   MockTCPServerSocket* tcp_server_socket = new MockTCPServerSocket();
 219   CompleteHandler handler;
 220
 221   scoped_ptr<TCPSocket> socket(TCPSocket::CreateServerSocketForTesting(
 222       tcp_server_socket, FAKE_ID));
 223
 224   EXPECT_CALL(*tcp_server_socket, Accept(_, _)).Times(1);
 225   EXPECT_CALL(*tcp_server_socket, Listen(_, _)).Times(1);
 226   EXPECT_CALL(handler, OnAccept(_, _));
 227
 228   std::string err_msg;
 229   EXPECT_EQ(net::OK, socket->Listen("127.0.0.1", 9999, 10, &err_msg));
 230   socket->Accept(base::Bind(&CompleteHandler::OnAccept,
 231         base::Unretained(&handler)));
 232 }
 233
 234 }  // namespace extensions