src/chrome/browser/extensions/api/dial/dial_service_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 "base/memory/ref_counted.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "chrome/browser/extensions/api/dial/dial_device_data.h"
   9 #include "chrome/browser/extensions/api/dial/dial_service.h"
  10 #include "net/base/capturing_net_log.h"
  11 #include "net/base/ip_endpoint.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using base::Time;
  16 using base::TimeDelta;
  17 using ::testing::A;
  18 using ::testing::AtLeast;
  19 using ::testing::Return;
  20
  21 namespace {
  22
  23 const char kValidResponse[] =
  24   "HTTP/1.1 OK\r\n"
  25   "LOCATION: http://127.0.0.1/dd.xml\r\n"
  26   "USN: some_id\r\n"
  27   "CACHE-CONTROL: max-age=1800\r\n"
  28   "CONFIGID.UPNP.ORG: 1\r\n\r\n";
  29
  30 }  // namespace
  31
  32 namespace extensions {
  33
  34 class MockObserver : public DialService::Observer {
  35  public:
  36   MOCK_METHOD1(OnDiscoveryRequest, void(DialService*));
  37   MOCK_METHOD2(OnDeviceDiscovered, void(DialService*, const DialDeviceData&));
  38   MOCK_METHOD1(OnDiscoveryFinished, void(DialService*));
  39   MOCK_METHOD2(OnError, void(DialService*,
  40                              const DialService::DialServiceErrorCode&));
  41 };
  42
  43 class DialServiceTest : public testing::Test {
  44  public:
  45   DialServiceTest()
  46     : dial_service_(&capturing_net_log_) {
  47     CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &mock_ip_));
  48     dial_service_.AddObserver(&mock_observer_);
  49     dial_socket_ = dial_service_.CreateDialSocket();
  50   }
  51  protected:
  52   net::CapturingNetLog capturing_net_log_;
  53   net::IPAddressNumber mock_ip_;
  54   DialServiceImpl dial_service_;
  55   scoped_ptr<DialServiceImpl::DialSocket> dial_socket_;
  56   MockObserver mock_observer_;
  57 };
  58
  59 TEST_F(DialServiceTest, TestSendMultipleRequests) {
  60   base::MessageLoopForIO loop;
  61   // Setting the finish delay to zero disables the timer that invokes
  62   // FinishDiscovery().
  63   dial_service_.finish_delay_ = TimeDelta::FromSeconds(0);
  64   dial_service_.request_interval_ = TimeDelta::FromSeconds(0);
  65   dial_service_.max_requests_ = 4;
  66   dial_service_.discovery_active_ = true;
  67   EXPECT_CALL(mock_observer_, OnDiscoveryRequest(A<DialService*>())).Times(4);
  68   EXPECT_CALL(mock_observer_, OnDiscoveryFinished(A<DialService*>())).Times(1);
  69   dial_service_.BindAndAddSocket(mock_ip_);
  70   EXPECT_EQ(1u, dial_service_.dial_sockets_.size());
  71   dial_service_.SendOneRequest();
  72   loop.RunUntilIdle();
  73   dial_service_.FinishDiscovery();
  74 }
  75
  76 TEST_F(DialServiceTest, TestMultipleNetworkInterfaces) {
  77   base::MessageLoopForIO loop;
  78   // Setting the finish delay to zero disables the timer that invokes
  79   // FinishDiscovery().
  80   dial_service_.finish_delay_ = TimeDelta::FromSeconds(0);
  81   dial_service_.request_interval_ = TimeDelta::FromSeconds(0);
  82   dial_service_.max_requests_ = 4;
  83   dial_service_.discovery_active_ = true;
  84   net::NetworkInterfaceList interface_list;
  85   interface_list.push_back(
  86       net::NetworkInterface("network1", "network1", 0,
  87                             net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
  88                             mock_ip_, 0));
  89   interface_list.push_back(
  90       net::NetworkInterface("network2", "network2", 1,
  91                             net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
  92                             mock_ip_, 0));
  93   interface_list.push_back(
  94       net::NetworkInterface("network3", "network3", 2,
  95                             net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
  96                             mock_ip_, 0));
  97
  98   // "network4" is equivalent to "network2" because both the address family
  99   // and interface index are the same.
 100   interface_list.push_back(
 101       net::NetworkInterface("network4", "network4", 1,
 102                             net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
 103                             mock_ip_, 0));
 104
 105   // 3 sockets * 4 requests per socket = 12 requests
 106   EXPECT_CALL(mock_observer_, OnDiscoveryRequest(A<DialService*>())).Times(12);
 107   EXPECT_CALL(mock_observer_, OnDiscoveryFinished(A<DialService*>())).Times(1);
 108
 109   dial_service_.SendNetworkList(interface_list);
 110   EXPECT_EQ(3u, dial_service_.dial_sockets_.size());
 111
 112   loop.RunUntilIdle();
 113   dial_service_.FinishDiscovery();
 114 }
 115
 116 TEST_F(DialServiceTest, TestOnDiscoveryRequest) {
 117   dial_service_.discovery_active_ = true;
 118   dial_service_.num_requests_sent_ = 1;
 119   dial_service_.max_requests_ = 1;
 120   size_t num_bytes = dial_service_.send_buffer_->size();
 121   EXPECT_CALL(mock_observer_, OnDiscoveryRequest(A<DialService*>())).Times(1);
 122   dial_socket_->OnSocketWrite(num_bytes, num_bytes);
 123 }
 124
 125 TEST_F(DialServiceTest, TestOnDeviceDiscovered) {
 126   dial_service_.discovery_active_ = true;
 127   int response_size = arraysize(kValidResponse) - 1;
 128   dial_socket_->recv_buffer_ =
 129       new net::IOBufferWithSize(response_size);
 130   strncpy(dial_socket_->recv_buffer_->data(),
 131           kValidResponse,
 132           response_size);
 133   dial_socket_->recv_address_ = net::IPEndPoint(mock_ip_, 12345);
 134
 135   DialDeviceData expected_device;
 136   expected_device.set_device_id("some_id");
 137
 138   EXPECT_CALL(mock_observer_,
 139               OnDeviceDiscovered(A<DialService*>(), expected_device))
 140       .Times(1);
 141   dial_socket_->OnSocketRead(response_size);
 142 };
 143
 144 TEST_F(DialServiceTest, TestOnDiscoveryFinished) {
 145   dial_service_.discovery_active_ = true;
 146
 147   EXPECT_CALL(mock_observer_, OnDiscoveryFinished(A<DialService*>())).Times(1);
 148   dial_service_.FinishDiscovery();
 149   EXPECT_FALSE(dial_service_.discovery_active_);
 150 }
 151
 152 TEST_F(DialServiceTest, TestResponseParsing) {
 153   Time now = Time::Now();
 154
 155   // Successful case
 156   DialDeviceData parsed;
 157   EXPECT_TRUE(DialServiceImpl::DialSocket::ParseResponse(
 158       kValidResponse, now, &parsed));
 159   EXPECT_EQ("some_id", parsed.device_id());
 160   EXPECT_EQ("http://127.0.0.1/dd.xml", parsed.device_description_url().spec());
 161   EXPECT_EQ(1, parsed.config_id());
 162   EXPECT_EQ(now, parsed.response_time());
 163
 164   // Failure cases
 165   DialDeviceData not_parsed;
 166
 167   // Empty, garbage
 168   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 169       std::string(), now, &not_parsed));
 170   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 171       "\r\n\r\n",
 172     now, &not_parsed));
 173   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 174       "xyzzy",
 175       now, &not_parsed));
 176
 177   // No headers
 178   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 179       "HTTP/1.1 OK\r\n\r\n",
 180       now, &not_parsed));
 181
 182   // Missing LOCATION
 183   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 184       "HTTP/1.1 OK\r\n"
 185       "USN: some_id\r\n\r\n",
 186       now, &not_parsed));
 187
 188   // Empty LOCATION
 189   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 190       "HTTP/1.1 OK\r\n"
 191       "LOCATION:\r\n"
 192       "USN: some_id\r\n\r\n",
 193       now, &not_parsed));
 194
 195   // Missing USN
 196   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 197       "HTTP/1.1 OK\r\n"
 198       "LOCATION: http://127.0.0.1/dd.xml\r\n\r\n",
 199       now, &not_parsed));
 200
 201   // Empty USN
 202   EXPECT_FALSE(DialServiceImpl::DialSocket::ParseResponse(
 203       "HTTP/1.1 OK\r\n"
 204       "LOCATION: http://127.0.0.1/dd.xml\r\n"
 205       "USN:\r\n\r\n",
 206       now, &not_parsed));
 207 }
 208
 209 }  // namespace extensions