chromeos/network/network_change_notifier_chromeos_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 "chromeos/network/network_change_notifier_chromeos.h"
   6
   7 #include <string>
   8
   9 #include "base/basictypes.h"
  10 #include "base/strings/string_split.h"
  11 #include "chromeos/network/network_change_notifier_factory_chromeos.h"
  12 #include "chromeos/network/network_state.h"
  13 #include "net/base/network_change_notifier.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/cros_system_api/dbus/service_constants.h"
  16
  17 namespace chromeos {
  18
  19 namespace {
  20
  21 const char kDnsServers1[] = "192.168.0.1,192.168.0.2";
  22 const char kDnsServers2[] = "192.168.3.1,192.168.3.2";
  23 const char kIpAddress1[] = "192.168.1.1";
  24 const char kIpAddress2[] = "192.168.1.2";
  25 const char kService1[] = "/service/1";
  26 const char kService2[] = "/service/2";
  27 const char kService3[] = "/service/3";
  28
  29 struct NotifierState {
  30   net::NetworkChangeNotifier::ConnectionType type;
  31   const char* service_path;
  32   const char* ip_address;
  33   const char* dns_servers;
  34 };
  35
  36 struct DefaultNetworkState {
  37   bool is_connected;
  38   const char* type;
  39   const char* network_technology;
  40   const char* service_path;
  41   const char* ip_address;
  42   const char* dns_servers;
  43 };
  44
  45 struct NotifierUpdateTestCase {
  46   const char* test_description;
  47   NotifierState initial_state;
  48   DefaultNetworkState default_network_state;
  49   NotifierState expected_state;
  50   bool expected_type_changed;
  51   bool expected_ip_changed;
  52   bool expected_dns_changed;
  53 };
  54
  55 } // namespace
  56
  57 using net::NetworkChangeNotifier;
  58
  59 TEST(NetworkChangeNotifierChromeosTest, ConnectionTypeFromShill) {
  60   struct TypeMapping {
  61     const char* shill_type;
  62     const char* technology;
  63     NetworkChangeNotifier::ConnectionType connection_type;
  64   };
  65   TypeMapping type_mappings[] = {
  66     { shill::kTypeEthernet, "", NetworkChangeNotifier::CONNECTION_ETHERNET },
  67     { shill::kTypeWifi, "", NetworkChangeNotifier::CONNECTION_WIFI },
  68     { shill::kTypeWimax, "", NetworkChangeNotifier::CONNECTION_4G },
  69     { "unknown type", "unknown technology",
  70       NetworkChangeNotifier::CONNECTION_UNKNOWN },
  71     { shill::kTypeCellular, shill::kNetworkTechnology1Xrtt,
  72       NetworkChangeNotifier::CONNECTION_2G },
  73     { shill::kTypeCellular, shill::kNetworkTechnologyGprs,
  74       NetworkChangeNotifier::CONNECTION_2G },
  75     { shill::kTypeCellular, shill::kNetworkTechnologyEdge,
  76       NetworkChangeNotifier::CONNECTION_2G },
  77     { shill::kTypeCellular, shill::kNetworkTechnologyEvdo,
  78       NetworkChangeNotifier::CONNECTION_3G },
  79     { shill::kTypeCellular, shill::kNetworkTechnologyGsm,
  80       NetworkChangeNotifier::CONNECTION_3G },
  81     { shill::kTypeCellular, shill::kNetworkTechnologyUmts,
  82       NetworkChangeNotifier::CONNECTION_3G },
  83     { shill::kTypeCellular, shill::kNetworkTechnologyHspa,
  84       NetworkChangeNotifier::CONNECTION_3G },
  85     { shill::kTypeCellular, shill::kNetworkTechnologyHspaPlus,
  86       NetworkChangeNotifier::CONNECTION_4G },
  87     { shill::kTypeCellular, shill::kNetworkTechnologyLte,
  88       NetworkChangeNotifier::CONNECTION_4G },
  89     { shill::kTypeCellular, shill::kNetworkTechnologyLteAdvanced,
  90       NetworkChangeNotifier::CONNECTION_4G },
  91     { shill::kTypeCellular, "unknown technology",
  92       NetworkChangeNotifier::CONNECTION_2G }
  93   };
  94
  95   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(type_mappings); ++i) {
  96     NetworkChangeNotifier::ConnectionType type =
  97         NetworkChangeNotifierChromeos::ConnectionTypeFromShill(
  98             type_mappings[i].shill_type, type_mappings[i].technology);
  99     EXPECT_EQ(type_mappings[i].connection_type, type);
 100   }
 101 }
 102
 103 class NetworkChangeNotifierChromeosUpdateTest : public testing::Test {
 104  protected:
 105   NetworkChangeNotifierChromeosUpdateTest() : default_network_("") {
 106   }
 107   virtual ~NetworkChangeNotifierChromeosUpdateTest() {}
 108
 109   void SetNotifierState(const NotifierState& notifier_state) {
 110     notifier_.connection_type_ = notifier_state.type;
 111     notifier_.service_path_ = notifier_state.service_path;
 112     notifier_.ip_address_ = notifier_state.ip_address;
 113     std::vector<std::string> dns_servers;
 114     base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
 115     notifier_.dns_servers_ = dns_servers;
 116   }
 117
 118   void VerifyNotifierState(const NotifierState& notifier_state) {
 119     EXPECT_EQ(notifier_state.type, notifier_.connection_type_);
 120     EXPECT_EQ(notifier_state.service_path, notifier_.service_path_);
 121     EXPECT_EQ(notifier_state.ip_address, notifier_.ip_address_);
 122     std::vector<std::string> dns_servers;
 123     base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
 124     EXPECT_EQ(dns_servers, notifier_.dns_servers_);
 125   }
 126
 127   // Sets the default network state used for notifier updates.
 128   void SetDefaultNetworkState(
 129       const DefaultNetworkState& default_network_state) {
 130     default_network_.visible_ = true;
 131     if (default_network_state.is_connected)
 132       default_network_.connection_state_ = shill::kStateOnline;
 133     else
 134       default_network_.connection_state_ = shill::kStateConfiguration;
 135     default_network_.type_ = default_network_state.type;
 136     default_network_.network_technology_ =
 137         default_network_state.network_technology;
 138     default_network_.path_ = default_network_state.service_path;
 139     default_network_.ip_address_ = default_network_state.ip_address;
 140     std::vector<std::string> dns_servers;
 141     base::SplitString(default_network_state.dns_servers, ',', &dns_servers);
 142     default_network_.dns_servers_ = dns_servers;
 143   }
 144
 145   // Process an default network update based on the state of |default_network_|.
 146   void ProcessDefaultNetworkUpdate(bool* type_changed,
 147                                    bool* ip_changed,
 148                                    bool* dns_changed) {
 149     notifier_.UpdateState(&default_network_, type_changed, ip_changed,
 150                           dns_changed);
 151   }
 152
 153  private:
 154   NetworkState default_network_;
 155   NetworkChangeNotifierChromeos notifier_;
 156 };
 157
 158 NotifierUpdateTestCase test_cases[] = {
 159   { "Online -> Offline",
 160     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
 161       kDnsServers1 },
 162     { false, shill::kTypeEthernet, "", kService1, "", "" },
 163     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
 164     true, true, true
 165   },
 166   { "Offline -> Offline",
 167     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
 168     { false, shill::kTypeEthernet, "", kService1, kIpAddress1,
 169       kDnsServers1 },
 170     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
 171     false, false, false
 172   },
 173   { "Offline -> Online",
 174     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
 175     { true, shill::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 },
 176     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
 177       kDnsServers1 },
 178     true, true, true
 179   },
 180   { "Online -> Online (new default service, different connection type)",
 181     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
 182       kDnsServers1 },
 183     { true, shill::kTypeWifi, "", kService2, kIpAddress1, kDnsServers1 },
 184     { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1,
 185       kDnsServers1 },
 186     true, true, true
 187   },
 188   { "Online -> Online (new default service, same connection type)",
 189     { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1,
 190       kDnsServers1 },
 191     { true, shill::kTypeWifi, "", kService3, kIpAddress1, kDnsServers1 },
 192     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1,
 193       kDnsServers1 },
 194     false, true, true
 195   },
 196   { "Online -> Online (same default service, first IP address update)",
 197     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, "", kDnsServers1 },
 198     { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
 199     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
 200       kDnsServers1 },
 201     false, false, false
 202   },
 203   { "Online -> Online (same default service, new IP address, same DNS)",
 204     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1,
 205       kDnsServers1 },
 206     { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
 207     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
 208       kDnsServers1 },
 209     false, true, false
 210   },
 211   { "Online -> Online (same default service, same IP address, new DNS)",
 212     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
 213       kDnsServers1 },
 214     { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers2 },
 215     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
 216       kDnsServers2 },
 217     false, false, true
 218   }
 219 };
 220
 221 TEST_F(NetworkChangeNotifierChromeosUpdateTest, UpdateDefaultNetwork) {
 222   for (size_t i = 0; i < arraysize(test_cases); ++i) {
 223     SCOPED_TRACE(test_cases[i].test_description);
 224     SetNotifierState(test_cases[i].initial_state);
 225     SetDefaultNetworkState(test_cases[i].default_network_state);
 226     bool type_changed = false, ip_changed = false, dns_changed = false;
 227     ProcessDefaultNetworkUpdate(&type_changed, &ip_changed, &dns_changed);
 228     VerifyNotifierState(test_cases[i].expected_state);
 229     EXPECT_TRUE(type_changed == test_cases[i].expected_type_changed);
 230     EXPECT_TRUE(ip_changed == test_cases[i].expected_ip_changed);
 231     EXPECT_TRUE(dns_changed == test_cases[i].expected_dns_changed);
 232   }
 233 }
 234
 235 }  // namespace chromeos