Improve functionality of FakeShillProfileClient

chromeos/network/network_state_handler_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/network/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 14 matching lines @@
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 void ErrorCallbackFunction(const std::string& error_name,
                            const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 const std::string kShillManagerClientStubDefaultService = "eth1";
-const std::string kShillManagerClientStubDefaultWireless = "wifi1";
-const std::string kShillManagerClientStubWireless2 = "wifi2";
+const std::string kShillManagerClientStubDefaultWifi = "wifi1";
+const std::string kShillManagerClientStubWifi2 = "wifi2";
 const std::string kShillManagerClientStubCellular = "cellular1";
 
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         device_list_changed_count_(0),
@@ skipping 85 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace
 
 namespace chromeos {
 
 class NetworkStateHandlerTest : public testing::Test {
  public:
   NetworkStateHandlerTest()
-      : device_test_(NULL), manager_test_(NULL), service_test_(NULL) {}
+      : device_test_(NULL),
+        manager_test_(NULL),
+        profile_test_(NULL),
+        service_test_(NULL) {}
   virtual ~NetworkStateHandlerTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Initialize DBusThreadManager with a stub implementation.
     DBusThreadManager::InitializeWithStub();

[pneubeck (no reviews), 2014/05/14 08:12:17]

instead of setting up the default network environment here and clearing it
below, the idea was at some time to instead create/set stubs explicitly.

Or if that is too much explicitness for your taste:

FakeDBusThreadManager* dbus_manager = new FakeDBusThreadManager;
dbus_manager->SetFakeClients();
DBusThreadManager::InitializeTesting(dbus_manager);

[stevenjb, 2014/05/14 17:08:10]

That seems like an unrelated re-factor.

[pneubeck (no reviews), 2014/05/14 18:08:35]

I just wanted to mentioned it because it makes the ClearProfiles function
unnecessary.

[stevenjb, 2014/05/14 19:13:07]

Ah. Perhaps. At some point we should probably test unloading profiles too. I
still have mixed feelings about the Fake Shill implementations in general. Baby
steps.

     SetupNetworkStateHandler();
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     network_state_handler_->RemoveObserver(test_observer_.get(), FROM_HERE);
     test_observer_.reset();
     network_state_handler_.reset();
     DBusThreadManager::Shutdown();
   }
 
   void SetupNetworkStateHandler() {
     SetupDefaultShillState();
     network_state_handler_.reset(new NetworkStateHandler);
     test_observer_.reset(new TestObserver(network_state_handler_.get()));
     network_state_handler_->AddObserver(test_observer_.get(), FROM_HERE);
     network_state_handler_->InitShillPropertyHandler();
   }
 
  protected:
+  void AddService(const std::string& service_path,
+                  const std::string& name,
+                  const std::string& type,
+                  const std::string& state) {
+    service_test_->AddService(service_path, name, type, state,
+                              true /* add_to_visible */,
+                              true /* add_to_watchlist */);
+  }
+
   void SetupDefaultShillState() {
     message_loop_.RunUntilIdle();  // Process any pending updates
     device_test_ =
         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     ASSERT_TRUE(device_test_);
     device_test_->ClearDevices();
     device_test_->AddDevice(
         "/device/stub_wifi_device1", shill::kTypeWifi, "stub_wifi_device1");
     device_test_->AddDevice("/device/stub_cellular_device1",
                             shill::kTypeCellular,
                             "stub_cellular_device1");
 
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
     ASSERT_TRUE(manager_test_);
 
+    profile_test_ =
+        DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
+    ASSERT_TRUE(profile_test_);
+    profile_test_->ClearProfiles();
+
     service_test_ =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     ASSERT_TRUE(service_test_);
     service_test_->ClearServices();
-    const bool add_to_visible = true;
-    const bool add_to_watchlist = true;
-    service_test_->AddService(kShillManagerClientStubDefaultService,
-                              kShillManagerClientStubDefaultService,
-                              shill::kTypeEthernet,
-                              shill::kStateOnline,
-                              add_to_visible,
-                              add_to_watchlist);
-    service_test_->AddService(kShillManagerClientStubDefaultWireless,
-                              kShillManagerClientStubDefaultWireless,
-                              shill::kTypeWifi,
-                              shill::kStateOnline,
-                              add_to_visible,
-                              add_to_watchlist);
-    service_test_->AddService(kShillManagerClientStubWireless2,
-                              kShillManagerClientStubWireless2,
-                              shill::kTypeWifi,
-                              shill::kStateIdle,
-                              add_to_visible,
-                              add_to_watchlist);
-    service_test_->AddService(kShillManagerClientStubCellular,
-                              kShillManagerClientStubCellular,
-                              shill::kTypeCellular,
-                              shill::kStateIdle,
-                              add_to_visible,
-                              add_to_watchlist);
+    AddService(kShillManagerClientStubDefaultService,
+               kShillManagerClientStubDefaultService,
+               shill::kTypeEthernet,
+               shill::kStateOnline);
+    AddService(kShillManagerClientStubDefaultWifi,
+               kShillManagerClientStubDefaultWifi,
+               shill::kTypeWifi,
+               shill::kStateOnline);
+    AddService(kShillManagerClientStubWifi2,
+               kShillManagerClientStubWifi2,
+               shill::kTypeWifi,
+               shill::kStateIdle);
+    AddService(kShillManagerClientStubCellular,
+               kShillManagerClientStubCellular,
+               shill::kTypeCellular,
+               shill::kStateIdle);
+  }
+
+  void UpdateManagerProperties() {
+    message_loop_.RunUntilIdle();
+    network_state_handler_->UpdateManagerProperties();
+    message_loop_.RunUntilIdle();
   }
 
   base::MessageLoopForUI message_loop_;
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<TestObserver> test_observer_;
   ShillDeviceClient::TestInterface* device_test_;
   ShillManagerClient::TestInterface* manager_test_;
+  ShillProfileClient::TestInterface* profile_test_;
   ShillServiceClient::TestInterface* service_test_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest);
 };
 
 TEST_F(NetworkStateHandlerTest, NetworkStateHandlerStub) {
   // Ensure that the network list is the expected size.
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             test_observer_->network_count());
   // Ensure that the first stub network is the default network.
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             test_observer_->default_network());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
                 NetworkTypePattern::Default())->path());
   EXPECT_EQ(kShillManagerClientStubDefaultService,
             network_state_handler_->ConnectedNetworkByType(
                 NetworkTypePattern::Ethernet())->path());
-  EXPECT_EQ(kShillManagerClientStubDefaultWireless,
+  EXPECT_EQ(kShillManagerClientStubDefaultWifi,
             network_state_handler_->ConnectedNetworkByType(
-                NetworkTypePattern::Wireless())->path());
+                NetworkTypePattern::WiFi())->path());
   EXPECT_EQ(kShillManagerClientStubCellular,
             network_state_handler_->FirstNetworkByType(
                 NetworkTypePattern::Mobile())->path());
   EXPECT_EQ(
       kShillManagerClientStubCellular,
       network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular())
           ->path());
   EXPECT_EQ(shill::kStateOnline,
             test_observer_->default_network_connection_state());
 }
@@ skipping 84 matching lines @@
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(eth1),
       shill::kSecurityProperty, security_value,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, FavoriteState) {
   // Set the profile entry of a service
-  const std::string wifi1 = kShillManagerClientStubDefaultWireless;
-  ShillProfileClient::TestInterface* profile_test =
-      DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
-  EXPECT_TRUE(profile_test->AddService("/profile/default", wifi1));
-  message_loop_.RunUntilIdle();
-  network_state_handler_->UpdateManagerProperties();
-  message_loop_.RunUntilIdle();
+  const std::string profile = "/profile/profile1";
+  const std::string wifi1 = kShillManagerClientStubDefaultWifi;
+  profile_test_->AddProfile(profile, "" /* userhash */);
+  EXPECT_TRUE(profile_test_->AddService(profile, wifi1));
+  UpdateManagerProperties();
   EXPECT_EQ(1u, test_observer_->favorite_count());
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
   // Change a network state.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(shill::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth1));
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
   // Confirm that changing the connection state to the same value does *not*
   // signal the observer.
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceDisconnected) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
-  const std::string wifi1 = kShillManagerClientStubDefaultWireless;
+  const std::string wifi1 = kShillManagerClientStubDefaultWifi;
 
   // Disconnect ethernet.
   test_observer_->reset_network_change_count();
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_idle_value);
   message_loop_.RunUntilIdle();
   // Expect two changes: first when eth1 becomes disconnected, second when
   // wifi1 becomes the default.
   EXPECT_EQ(2u, test_observer_->default_network_change_count());
   EXPECT_EQ(wifi1, test_observer_->default_network());
 
   // Disconnect wifi.
   test_observer_->reset_network_change_count();
   service_test_->SetServiceProperty(wifi1, shill::kStateProperty,
                                     connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
   EXPECT_EQ("", test_observer_->default_network());
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceConnected) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
-  const std::string wifi1 = kShillManagerClientStubDefaultWireless;
+  const std::string wifi1 = kShillManagerClientStubDefaultWifi;
 
   // Disconnect ethernet and wifi.
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_idle_value);
   service_test_->SetServiceProperty(wifi1, shill::kStateProperty,
                                     connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(std::string(), test_observer_->default_network());
 
   // Connect ethernet, should become the default network.
   test_observer_->reset_network_change_count();
   base::StringValue connection_state_ready_value(shill::kStateReady);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                     connection_state_ready_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(eth1, test_observer_->default_network());
   EXPECT_EQ(shill::kStateReady,
             test_observer_->default_network_connection_state());
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   // The default service should be eth1.
   EXPECT_EQ(eth1, test_observer_->default_network());
 
   // Change the default network by changing Manager.DefaultService.
   test_observer_->reset_network_change_count();
-  const std::string wifi1 = kShillManagerClientStubDefaultWireless;
+  const std::string wifi1 = kShillManagerClientStubDefaultWifi;
   base::StringValue wifi1_value(wifi1);
   manager_test_->SetManagerProperty(
       shill::kDefaultServiceProperty, wifi1_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(wifi1, test_observer_->default_network());
   EXPECT_EQ(1u, test_observer_->default_network_change_count());
 
   // Change the state of the default network.
   test_observer_->reset_network_change_count();
   base::StringValue connection_state_ready_value(shill::kStateReady);
@@ skipping 18 matching lines @@
   test_observer_->reset_network_change_count();
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(wifi1),
       shill::kSignalStrengthProperty, base::FundamentalValue(32),
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(0u, test_observer_->default_network_change_count());
 }
 
 TEST_F(NetworkStateHandlerTest, RequestUpdate) {
-  // Request an update for kShillManagerClientStubDefaultWireless.
+  // Request an update for kShillManagerClientStubDefaultWifi.
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
-      kShillManagerClientStubDefaultWireless));
+      kShillManagerClientStubDefaultWifi));
   network_state_handler_->RequestUpdateForNetwork(
-      kShillManagerClientStubDefaultWireless);
+      kShillManagerClientStubDefaultWifi);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
-      kShillManagerClientStubDefaultWireless));
+      kShillManagerClientStubDefaultWifi));
 }
-
 }  // namespace chromeos