Apply global auto connect ONC policy in GetManagedProperties.

chromeos/network/managed_network_configuration_handler_unittest.cc

 // Copyright (c) 2013 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 <iostream>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
+#include "chromeos/dbus/mock_shill_service_client.h"
 #include "chromeos/dbus/shill_client_helper.h"
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "dbus/object_path.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 96 matching lines @@
     entries->GetDictionaryWithoutPathExpansion(entry_path, &entry);
     ASSERT_TRUE(entry);
     callback.Run(*entry);
   }
 
  protected:
   base::DictionaryValue profile_entries_;
   std::map<std::string, std::string> profile_to_user_;
 };
 
+class ShillServiceTestClient {
+ public:
+  typedef ShillClientHelper::DictionaryValueCallback DictionaryValueCallback;
+  void SetFakeProperties(const base::DictionaryValue& service_properties) {
+    service_properties_.Clear();
+    service_properties_.MergeDictionary(&service_properties);
+  }
+
+  void GetProperties(const dbus::ObjectPath& service_path,
+                     const DictionaryValueCallback& callback) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   DBUS_METHOD_CALL_SUCCESS,
+                   base::ConstRef(service_properties_)));
+  }
+
+ protected:
+  base::DictionaryValue service_properties_;
+};
+
 class TestNetworkProfileHandler : public NetworkProfileHandler {
  public:
   TestNetworkProfileHandler() {
     Init();
   }
   virtual ~TestNetworkProfileHandler() {}
 
   void AddProfileForTest(const NetworkProfile& profile) {
     AddProfile(profile);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestNetworkProfileHandler);
 };
 
 }  // namespace
 
 class ManagedNetworkConfigurationHandlerTest : public testing::Test {
  public:
   ManagedNetworkConfigurationHandlerTest()
       : mock_manager_client_(NULL),
-        mock_profile_client_(NULL) {
+        mock_profile_client_(NULL),
+        mock_service_client_(NULL) {
   }
 
   virtual ~ManagedNetworkConfigurationHandlerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
         DBusThreadManager::GetSetterForTesting();
     mock_manager_client_ = new StrictMock<MockShillManagerClient>();
     mock_profile_client_ = new StrictMock<MockShillProfileClient>();
+    mock_service_client_ = new StrictMock<MockShillServiceClient>();
     dbus_setter->SetShillManagerClient(
         scoped_ptr<ShillManagerClient>(mock_manager_client_).Pass());
     dbus_setter->SetShillProfileClient(
         scoped_ptr<ShillProfileClient>(mock_profile_client_).Pass());
+    dbus_setter->SetShillServiceClient(
+        scoped_ptr<ShillServiceClient>(mock_service_client_).Pass());
 
     SetNetworkConfigurationHandlerExpectations();
 
     ON_CALL(*mock_profile_client_, GetProperties(_,_,_))
         .WillByDefault(Invoke(&profiles_stub_,
                               &ShillProfileTestClient::GetProperties));
 
     ON_CALL(*mock_profile_client_, GetEntry(_,_,_,_))
         .WillByDefault(Invoke(&profiles_stub_,
                               &ShillProfileTestClient::GetEntry));
 
+    ON_CALL(*mock_service_client_, GetProperties(_,_))
+        .WillByDefault(Invoke(&services_stub_,
+                              &ShillServiceTestClient::GetProperties));
+
     network_profile_handler_.reset(new TestNetworkProfileHandler());
     network_configuration_handler_.reset(
         NetworkConfigurationHandler::InitializeForTest(
             NULL /* no NetworkStateHandler */));
     managed_network_configuration_handler_.reset(
         new ManagedNetworkConfigurationHandlerImpl());
     managed_network_configuration_handler_->Init(
         NULL /* no NetworkStateHandler */,
         network_profile_handler_.get(),
         network_configuration_handler_.get(),
@@ skipping 12 matching lines @@
   void VerifyAndClearExpectations() {
     Mock::VerifyAndClearExpectations(mock_manager_client_);
     Mock::VerifyAndClearExpectations(mock_profile_client_);
     SetNetworkConfigurationHandlerExpectations();
   }
 
   void InitializeStandardProfiles() {
     profiles_stub_.AddProfile(kUser1ProfilePath, kUser1);
     network_profile_handler_->
         AddProfileForTest(NetworkProfile(kUser1ProfilePath, kUser1));
-    network_profile_handler_->
-        AddProfileForTest(NetworkProfile(
-            NetworkProfileHandler::GetSharedProfilePath(), std::string()));
+
+    profiles_stub_.AddProfile(NetworkProfileHandler::GetSharedProfilePath(),
+                              std::string() /* no userhash */);
+    network_profile_handler_->AddProfileForTest(
+        NetworkProfile(NetworkProfileHandler::GetSharedProfilePath(),
+                       std::string() /* no userhash */));
   }
 
   void SetUpEntry(const std::string& path_to_shill_json,
                   const std::string& profile_path,
                   const std::string& entry_path) {
     scoped_ptr<base::DictionaryValue> entry =
         test_utils::ReadTestDictionary(path_to_shill_json);
     profiles_stub_.AddEntry(profile_path, entry_path, *entry);
   }
 
@@ skipping 27 matching lines @@
     EXPECT_CALL(*mock_manager_client_,
                 AddPropertyChangedObserver(_)).Times(AnyNumber());
     EXPECT_CALL(*mock_manager_client_,
                 RemovePropertyChangedObserver(_)).Times(AnyNumber());
   }
 
   ManagedNetworkConfigurationHandler* managed_handler() {
     return managed_network_configuration_handler_.get();
   }
 
+  void GetManagedProperties(const std::string& userhash,
+                            const std::string& service_path) {
+    managed_handler()->GetManagedProperties(
+        userhash,
+        service_path,
+        base::Bind(
+            &ManagedNetworkConfigurationHandlerTest::GetPropertiesCallback,
+            base::Unretained(this)),
+        base::Bind(&ManagedNetworkConfigurationHandlerTest::UnexpectedError));
+  }
+
+  void GetPropertiesCallback(const std::string& service_path,
+                             const base::DictionaryValue& dictionary) {
+    get_properties_service_path_ = service_path;
+    get_properties_result_.Clear();
+    get_properties_result_.MergeDictionary(&dictionary);
+  }
+
+  static void UnexpectedError(const std::string& error_name,
+                              scoped_ptr<base::DictionaryValue> error_data) {
+    ASSERT_FALSE(true);
+  }
+
  protected:
   MockShillManagerClient* mock_manager_client_;
   MockShillProfileClient* mock_profile_client_;
+  MockShillServiceClient* mock_service_client_;
   ShillProfileTestClient profiles_stub_;
+  ShillServiceTestClient services_stub_;
   scoped_ptr<TestNetworkProfileHandler> network_profile_handler_;
   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
   scoped_ptr<ManagedNetworkConfigurationHandlerImpl>
         managed_network_configuration_handler_;
   base::MessageLoop message_loop_;
 
+  std::string get_properties_service_path_;
+  base::DictionaryValue get_properties_result_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ManagedNetworkConfigurationHandlerTest);
 };
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, ProfileInitialization) {
   InitializeStandardProfiles();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, RemoveIrrelevantFields) {
@@ skipping 371 matching lines @@
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, AutoConnectDisallowed) {
   InitializeStandardProfiles();
+  // Setup an unmanaged network.
   SetUpEntry("policy/shill_unmanaged_wifi2.json",
              kUser1ProfilePath,
              "wifi2_entry_path");
 
+  // Apply the user policy with global autoconnect config and expect that
+  // autoconnect is disabled in the network's profile entry.
   EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   EXPECT_CALL(
       *mock_profile_client_,
       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "wifi2_entry_path", _, _));
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
           "policy/shill_disallow_autoconnect_on_unmanaged_wifi2.json");
 
   EXPECT_CALL(*mock_manager_client_,
               ConfigureServiceForProfile(
                   dbus::ObjectPath(kUser1ProfilePath),
                   IsEqualTo(expected_shill_properties.get()),
                   _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
             kUser1,
             "policy/policy_disallow_autoconnect.onc");
   message_loop_.RunUntilIdle();
+
+  // Verify that GetManagedProperties correctly augments the properties with the
+  // global config from the user policy.
+
+  // GetManagedProperties requires the device policy to be set or explicitly
+  // unset.
+  EXPECT_CALL(*mock_profile_client_,
+              GetProperties(dbus::ObjectPath(
+                                NetworkProfileHandler::GetSharedProfilePath()),
+                            _,
+                            _));
+  managed_handler()->SetPolicy(
+      ::onc::ONC_SOURCE_DEVICE_POLICY,
+      std::string(),             // no userhash
+      base::ListValue(),         // no device network policy
+      base::DictionaryValue());  // no device global config
+
+  services_stub_.SetFakeProperties(*expected_shill_properties);
+  EXPECT_CALL(*mock_service_client_,
+              GetProperties(dbus::ObjectPath(
+                                "wifi2"),_));
+
+  GetManagedProperties(kUser1, "wifi2");
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ("wifi2", get_properties_service_path_);
+
+  scoped_ptr<base::DictionaryValue> expected_managed_onc =
+      test_utils::ReadTestDictionary(
+          "policy/managed_onc_disallow_autoconnect_on_unmanaged_wifi2.onc");
+  EXPECT_TRUE(onc::test_utils::Equals(expected_managed_onc.get(),
+                                      &get_properties_result_));
 }
 
 TEST_F(ManagedNetworkConfigurationHandlerTest, LateProfileLoading) {
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 
   message_loop_.RunUntilIdle();
   VerifyAndClearExpectations();
 
   scoped_ptr<base::DictionaryValue> expected_shill_properties =
       test_utils::ReadTestDictionary(
@@ skipping 44 matching lines @@
 
   EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   managed_network_configuration_handler_.reset();
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace chromeos