src/chromeos/network/managed_network_configuration_handler_unittest.cc

   1 // Copyright (c) 2013 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 <iostream>
   6 #include <sstream>
   7
   8 #include "base/bind.h"
   9 #include "base/location.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/stl_util.h"
  13 #include "base/values.h"
  14 #include "chromeos/dbus/dbus_thread_manager.h"
  15 #include "chromeos/dbus/mock_shill_manager_client.h"
  16 #include "chromeos/dbus/mock_shill_profile_client.h"
  17 #include "chromeos/dbus/mock_shill_service_client.h"
  18 #include "chromeos/dbus/shill_client_helper.h"
  19 #include "chromeos/network/managed_network_configuration_handler_impl.h"
  20 #include "chromeos/network/network_configuration_handler.h"
  21 #include "chromeos/network/network_profile_handler.h"
  22 #include "chromeos/network/onc/onc_test_utils.h"
  23 #include "chromeos/network/onc/onc_utils.h"
  24 #include "dbus/object_path.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "third_party/cros_system_api/dbus/service_constants.h"
  28
  29 using ::testing::AnyNumber;
  30 using ::testing::Invoke;
  31 using ::testing::Mock;
  32 using ::testing::Pointee;
  33 using ::testing::Return;
  34 using ::testing::SaveArg;
  35 using ::testing::StrEq;
  36 using ::testing::StrictMock;
  37 using ::testing::_;
  38
  39 namespace test_utils = ::chromeos::onc::test_utils;
  40
  41 namespace chromeos {
  42
  43 namespace {
  44
  45 std::string ValueToString(const base::Value* value) {
  46   std::stringstream str;
  47   str << *value;
  48   return str.str();
  49 }
  50
  51 const char kUser1[] = "user1";
  52 const char kUser1ProfilePath[] = "/profile/user1/shill";
  53
  54 // Matcher to match base::Value.
  55 MATCHER_P(IsEqualTo,
  56           value,
  57           std::string(negation ? "isn't" : "is") + " equal to " +
  58           ValueToString(value)) {
  59   return value->Equals(&arg);
  60 }
  61
  62 class ShillProfileTestClient {
  63  public:
  64   typedef ShillClientHelper::DictionaryValueCallbackWithoutStatus
  65       DictionaryValueCallbackWithoutStatus;
  66   typedef ShillClientHelper::ErrorCallback ErrorCallback;
  67
  68   void AddProfile(const std::string& profile_path,
  69                   const std::string& userhash) {
  70     if (profile_entries_.HasKey(profile_path))
  71       return;
  72
  73     base::DictionaryValue* profile = new base::DictionaryValue;
  74     profile_entries_.SetWithoutPathExpansion(profile_path, profile);
  75     profile_to_user_[profile_path] = userhash;
  76   }
  77
  78   void AddEntry(const std::string& profile_path,
  79                 const std::string& entry_path,
  80                 const base::DictionaryValue& entry) {
  81     base::DictionaryValue* entries = NULL;
  82     profile_entries_.GetDictionaryWithoutPathExpansion(profile_path, &entries);
  83     ASSERT_TRUE(entries);
  84
  85     base::DictionaryValue* new_entry = entry.DeepCopy();
  86     new_entry->SetStringWithoutPathExpansion(shill::kProfileProperty,
  87                                              profile_path);
  88     entries->SetWithoutPathExpansion(entry_path, new_entry);
  89   }
  90
  91   void GetProperties(const dbus::ObjectPath& profile_path,
  92                      const DictionaryValueCallbackWithoutStatus& callback,
  93                      const ErrorCallback& error_callback) {
  94     base::DictionaryValue* entries = NULL;
  95     profile_entries_.GetDictionaryWithoutPathExpansion(profile_path.value(),
  96                                                        &entries);
  97     ASSERT_TRUE(entries);
  98
  99     scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 100     base::ListValue* entry_paths = new base::ListValue;
 101     result->SetWithoutPathExpansion(shill::kEntriesProperty, entry_paths);
 102     for (base::DictionaryValue::Iterator it(*entries); !it.IsAtEnd();
 103          it.Advance()) {
 104       entry_paths->AppendString(it.key());
 105     }
 106
 107     ASSERT_TRUE(ContainsKey(profile_to_user_, profile_path.value()));
 108     const std::string& userhash = profile_to_user_[profile_path.value()];
 109     result->SetStringWithoutPathExpansion(shill::kUserHashProperty, userhash);
 110
 111     callback.Run(*result);
 112   }
 113
 114   void GetEntry(const dbus::ObjectPath& profile_path,
 115                 const std::string& entry_path,
 116                 const DictionaryValueCallbackWithoutStatus& callback,
 117                 const ErrorCallback& error_callback) {
 118     base::DictionaryValue* entries = NULL;
 119     profile_entries_.GetDictionaryWithoutPathExpansion(profile_path.value(),
 120                                                        &entries);
 121     ASSERT_TRUE(entries);
 122
 123     base::DictionaryValue* entry = NULL;
 124     entries->GetDictionaryWithoutPathExpansion(entry_path, &entry);
 125     ASSERT_TRUE(entry);
 126     callback.Run(*entry);
 127   }
 128
 129  protected:
 130   base::DictionaryValue profile_entries_;
 131   std::map<std::string, std::string> profile_to_user_;
 132 };
 133
 134 class ShillServiceTestClient {
 135  public:
 136   typedef ShillClientHelper::DictionaryValueCallback DictionaryValueCallback;
 137   void SetFakeProperties(const base::DictionaryValue& service_properties) {
 138     service_properties_.Clear();
 139     service_properties_.MergeDictionary(&service_properties);
 140   }
 141
 142   void GetProperties(const dbus::ObjectPath& service_path,
 143                      const DictionaryValueCallback& callback) {
 144     base::MessageLoop::current()->PostTask(
 145         FROM_HERE,
 146         base::Bind(callback,
 147                    DBUS_METHOD_CALL_SUCCESS,
 148                    base::ConstRef(service_properties_)));
 149   }
 150
 151  protected:
 152   base::DictionaryValue service_properties_;
 153 };
 154
 155 class TestNetworkProfileHandler : public NetworkProfileHandler {
 156  public:
 157   TestNetworkProfileHandler() {
 158     Init();
 159   }
 160   virtual ~TestNetworkProfileHandler() {}
 161
 162   void AddProfileForTest(const NetworkProfile& profile) {
 163     AddProfile(profile);
 164   }
 165
 166  private:
 167   DISALLOW_COPY_AND_ASSIGN(TestNetworkProfileHandler);
 168 };
 169
 170 }  // namespace
 171
 172 class ManagedNetworkConfigurationHandlerTest : public testing::Test {
 173  public:
 174   ManagedNetworkConfigurationHandlerTest()
 175       : mock_manager_client_(NULL),
 176         mock_profile_client_(NULL),
 177         mock_service_client_(NULL) {
 178   }
 179
 180   virtual ~ManagedNetworkConfigurationHandlerTest() {
 181   }
 182
 183   virtual void SetUp() OVERRIDE {
 184     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
 185         DBusThreadManager::GetSetterForTesting();
 186     mock_manager_client_ = new StrictMock<MockShillManagerClient>();
 187     mock_profile_client_ = new StrictMock<MockShillProfileClient>();
 188     mock_service_client_ = new StrictMock<MockShillServiceClient>();
 189     dbus_setter->SetShillManagerClient(
 190         scoped_ptr<ShillManagerClient>(mock_manager_client_).Pass());
 191     dbus_setter->SetShillProfileClient(
 192         scoped_ptr<ShillProfileClient>(mock_profile_client_).Pass());
 193     dbus_setter->SetShillServiceClient(
 194         scoped_ptr<ShillServiceClient>(mock_service_client_).Pass());
 195
 196     SetNetworkConfigurationHandlerExpectations();
 197
 198     ON_CALL(*mock_profile_client_, GetProperties(_,_,_))
 199         .WillByDefault(Invoke(&profiles_stub_,
 200                               &ShillProfileTestClient::GetProperties));
 201
 202     ON_CALL(*mock_profile_client_, GetEntry(_,_,_,_))
 203         .WillByDefault(Invoke(&profiles_stub_,
 204                               &ShillProfileTestClient::GetEntry));
 205
 206     ON_CALL(*mock_service_client_, GetProperties(_,_))
 207         .WillByDefault(Invoke(&services_stub_,
 208                               &ShillServiceTestClient::GetProperties));
 209
 210     network_profile_handler_.reset(new TestNetworkProfileHandler());
 211     network_configuration_handler_.reset(
 212         NetworkConfigurationHandler::InitializeForTest(
 213             NULL /* no NetworkStateHandler */));
 214     managed_network_configuration_handler_.reset(
 215         new ManagedNetworkConfigurationHandlerImpl());
 216     managed_network_configuration_handler_->Init(
 217         NULL /* no NetworkStateHandler */,
 218         network_profile_handler_.get(),
 219         network_configuration_handler_.get(),
 220         NULL /* no DeviceHandler */);
 221
 222     message_loop_.RunUntilIdle();
 223   }
 224
 225   virtual void TearDown() OVERRIDE {
 226     managed_network_configuration_handler_.reset();
 227     network_configuration_handler_.reset();
 228     network_profile_handler_.reset();
 229     DBusThreadManager::Shutdown();
 230   }
 231
 232   void VerifyAndClearExpectations() {
 233     Mock::VerifyAndClearExpectations(mock_manager_client_);
 234     Mock::VerifyAndClearExpectations(mock_profile_client_);
 235     SetNetworkConfigurationHandlerExpectations();
 236   }
 237
 238   void InitializeStandardProfiles() {
 239     profiles_stub_.AddProfile(kUser1ProfilePath, kUser1);
 240     network_profile_handler_->
 241         AddProfileForTest(NetworkProfile(kUser1ProfilePath, kUser1));
 242
 243     profiles_stub_.AddProfile(NetworkProfileHandler::GetSharedProfilePath(),
 244                               std::string() /* no userhash */);
 245     network_profile_handler_->AddProfileForTest(
 246         NetworkProfile(NetworkProfileHandler::GetSharedProfilePath(),
 247                        std::string() /* no userhash */));
 248   }
 249
 250   void SetUpEntry(const std::string& path_to_shill_json,
 251                   const std::string& profile_path,
 252                   const std::string& entry_path) {
 253     scoped_ptr<base::DictionaryValue> entry =
 254         test_utils::ReadTestDictionary(path_to_shill_json);
 255     profiles_stub_.AddEntry(profile_path, entry_path, *entry);
 256   }
 257
 258   void SetPolicy(::onc::ONCSource onc_source,
 259                  const std::string& userhash,
 260                  const std::string& path_to_onc) {
 261     scoped_ptr<base::DictionaryValue> policy;
 262     if (path_to_onc.empty())
 263       policy = onc::ReadDictionaryFromJson(onc::kEmptyUnencryptedConfiguration);
 264     else
 265       policy = test_utils::ReadTestDictionary(path_to_onc);
 266
 267     base::ListValue empty_network_configs;
 268     base::ListValue* network_configs = &empty_network_configs;
 269     policy->GetListWithoutPathExpansion(
 270         ::onc::toplevel_config::kNetworkConfigurations, &network_configs);
 271
 272     base::DictionaryValue empty_global_config;
 273     base::DictionaryValue* global_network_config = &empty_global_config;
 274     policy->GetDictionaryWithoutPathExpansion(
 275         ::onc::toplevel_config::kGlobalNetworkConfiguration,
 276         &global_network_config);
 277
 278     managed_handler()->SetPolicy(
 279         onc_source, userhash, *network_configs, *global_network_config);
 280   }
 281
 282   void SetNetworkConfigurationHandlerExpectations() {
 283     // These calls occur in NetworkConfigurationHandler.
 284     EXPECT_CALL(*mock_manager_client_, GetProperties(_)).Times(AnyNumber());
 285     EXPECT_CALL(*mock_manager_client_,
 286                 AddPropertyChangedObserver(_)).Times(AnyNumber());
 287     EXPECT_CALL(*mock_manager_client_,
 288                 RemovePropertyChangedObserver(_)).Times(AnyNumber());
 289   }
 290
 291   ManagedNetworkConfigurationHandler* managed_handler() {
 292     return managed_network_configuration_handler_.get();
 293   }
 294
 295   void GetManagedProperties(const std::string& userhash,
 296                             const std::string& service_path) {
 297     managed_handler()->GetManagedProperties(
 298         userhash,
 299         service_path,
 300         base::Bind(
 301             &ManagedNetworkConfigurationHandlerTest::GetPropertiesCallback,
 302             base::Unretained(this)),
 303         base::Bind(&ManagedNetworkConfigurationHandlerTest::UnexpectedError));
 304   }
 305
 306   void GetPropertiesCallback(const std::string& service_path,
 307                              const base::DictionaryValue& dictionary) {
 308     get_properties_service_path_ = service_path;
 309     get_properties_result_.Clear();
 310     get_properties_result_.MergeDictionary(&dictionary);
 311   }
 312
 313   static void UnexpectedError(const std::string& error_name,
 314                               scoped_ptr<base::DictionaryValue> error_data) {
 315     ASSERT_FALSE(true);
 316   }
 317
 318  protected:
 319   MockShillManagerClient* mock_manager_client_;
 320   MockShillProfileClient* mock_profile_client_;
 321   MockShillServiceClient* mock_service_client_;
 322   ShillProfileTestClient profiles_stub_;
 323   ShillServiceTestClient services_stub_;
 324   scoped_ptr<TestNetworkProfileHandler> network_profile_handler_;
 325   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
 326   scoped_ptr<ManagedNetworkConfigurationHandlerImpl>
 327         managed_network_configuration_handler_;
 328   base::MessageLoop message_loop_;
 329
 330   std::string get_properties_service_path_;
 331   base::DictionaryValue get_properties_result_;
 332
 333  private:
 334   DISALLOW_COPY_AND_ASSIGN(ManagedNetworkConfigurationHandlerTest);
 335 };
 336
 337 TEST_F(ManagedNetworkConfigurationHandlerTest, ProfileInitialization) {
 338   InitializeStandardProfiles();
 339   message_loop_.RunUntilIdle();
 340 }
 341
 342 TEST_F(ManagedNetworkConfigurationHandlerTest, RemoveIrrelevantFields) {
 343   InitializeStandardProfiles();
 344   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 345       test_utils::ReadTestDictionary(
 346           "policy/shill_policy_on_unconfigured_wifi1.json");
 347
 348   EXPECT_CALL(*mock_profile_client_,
 349               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 350
 351   EXPECT_CALL(*mock_manager_client_,
 352               ConfigureServiceForProfile(
 353                   dbus::ObjectPath(kUser1ProfilePath),
 354                   IsEqualTo(expected_shill_properties.get()),
 355                   _, _));
 356
 357   SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
 358             kUser1,
 359             "policy/policy_wifi1_with_redundant_fields.onc");
 360   message_loop_.RunUntilIdle();
 361 }
 362
 363 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyManageUnconfigured) {
 364   InitializeStandardProfiles();
 365   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 366       test_utils::ReadTestDictionary(
 367           "policy/shill_policy_on_unconfigured_wifi1.json");
 368
 369   EXPECT_CALL(*mock_profile_client_,
 370               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 371
 372   EXPECT_CALL(*mock_manager_client_,
 373               ConfigureServiceForProfile(
 374                   dbus::ObjectPath(kUser1ProfilePath),
 375                   IsEqualTo(expected_shill_properties.get()),
 376                   _, _));
 377
 378   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 379   message_loop_.RunUntilIdle();
 380 }
 381
 382 // Ensure that EAP settings for ethernet are matched with the right profile
 383 // entry and written to the dedicated EthernetEAP service.
 384 TEST_F(ManagedNetworkConfigurationHandlerTest,
 385        SetPolicyManageUnmanagedEthernetEAP) {
 386   InitializeStandardProfiles();
 387   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 388       test_utils::ReadTestDictionary(
 389           "policy/"
 390           "shill_policy_on_unmanaged_ethernet_eap.json");
 391
 392   SetUpEntry("policy/shill_unmanaged_ethernet_eap.json",
 393              kUser1ProfilePath,
 394              "eth_entry");
 395
 396   // Also setup an unrelated WiFi configuration to verify that the right entry
 397   // is matched.
 398   SetUpEntry("policy/shill_unmanaged_wifi1.json",
 399              kUser1ProfilePath,
 400              "wifi_entry");
 401
 402   EXPECT_CALL(*mock_profile_client_,
 403               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 404
 405   EXPECT_CALL(*mock_profile_client_,
 406               GetEntry(dbus::ObjectPath(kUser1ProfilePath), _, _, _)).Times(2);
 407
 408   EXPECT_CALL(
 409       *mock_profile_client_,
 410       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "eth_entry", _, _));
 411
 412   EXPECT_CALL(
 413       *mock_manager_client_,
 414       ConfigureServiceForProfile(dbus::ObjectPath(kUser1ProfilePath),
 415                                  IsEqualTo(expected_shill_properties.get()),
 416                                  _, _));
 417
 418   SetPolicy(
 419       ::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_ethernet_eap.onc");
 420   message_loop_.RunUntilIdle();
 421 }
 422
 423 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyIgnoreUnmodified) {
 424   InitializeStandardProfiles();
 425   EXPECT_CALL(*mock_profile_client_, GetProperties(_, _, _));
 426
 427   EXPECT_CALL(*mock_manager_client_, ConfigureServiceForProfile(_, _, _, _));
 428
 429   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 430   message_loop_.RunUntilIdle();
 431   VerifyAndClearExpectations();
 432
 433   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
 434              kUser1ProfilePath,
 435              "some_entry_path");
 436
 437   EXPECT_CALL(*mock_profile_client_, GetProperties(_, _, _));
 438
 439   EXPECT_CALL(
 440       *mock_profile_client_,
 441       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "some_entry_path", _, _));
 442
 443   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 444   message_loop_.RunUntilIdle();
 445 }
 446
 447 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyManageUnmanaged) {
 448   InitializeStandardProfiles();
 449   SetUpEntry("policy/shill_unmanaged_wifi1.json",
 450              kUser1ProfilePath,
 451              "old_entry_path");
 452
 453   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 454       test_utils::ReadTestDictionary(
 455           "policy/shill_policy_on_unmanaged_wifi1.json");
 456
 457   EXPECT_CALL(*mock_profile_client_,
 458               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 459
 460   EXPECT_CALL(
 461       *mock_profile_client_,
 462       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 463
 464   EXPECT_CALL(
 465       *mock_profile_client_,
 466       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 467
 468   EXPECT_CALL(*mock_manager_client_,
 469               ConfigureServiceForProfile(
 470                   dbus::ObjectPath(kUser1ProfilePath),
 471                   IsEqualTo(expected_shill_properties.get()),
 472                   _, _));
 473
 474   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 475   message_loop_.RunUntilIdle();
 476 }
 477
 478 // Old ChromeOS versions may not have used the UIData property
 479 TEST_F(ManagedNetworkConfigurationHandlerTest,
 480        SetPolicyManageUnmanagedWithoutUIData) {
 481   InitializeStandardProfiles();
 482   SetUpEntry("policy/shill_unmanaged_wifi1.json",
 483              kUser1ProfilePath,
 484              "old_entry_path");
 485
 486   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 487       test_utils::ReadTestDictionary(
 488           "policy/shill_policy_on_unmanaged_wifi1.json");
 489
 490   EXPECT_CALL(*mock_profile_client_,
 491               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 492
 493   EXPECT_CALL(
 494       *mock_profile_client_,
 495       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 496
 497   EXPECT_CALL(
 498       *mock_profile_client_,
 499       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 500
 501   EXPECT_CALL(*mock_manager_client_,
 502               ConfigureServiceForProfile(
 503                   dbus::ObjectPath(kUser1ProfilePath),
 504                   IsEqualTo(expected_shill_properties.get()),
 505                   _, _));
 506
 507   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 508   message_loop_.RunUntilIdle();
 509 }
 510
 511 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUpdateManagedNewGUID) {
 512   InitializeStandardProfiles();
 513   SetUpEntry("policy/shill_managed_wifi1.json",
 514              kUser1ProfilePath,
 515              "old_entry_path");
 516
 517   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 518       test_utils::ReadTestDictionary(
 519           "policy/shill_policy_on_unmanaged_wifi1.json");
 520
 521   // The passphrase isn't sent again, because it's configured by the user and
 522   // Shill doesn't send it on GetProperties calls.
 523   expected_shill_properties->RemoveWithoutPathExpansion(
 524       shill::kPassphraseProperty, NULL);
 525
 526   EXPECT_CALL(*mock_profile_client_,
 527               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 528
 529   EXPECT_CALL(
 530       *mock_profile_client_,
 531       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 532
 533   EXPECT_CALL(
 534       *mock_profile_client_,
 535       DeleteEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 536
 537   EXPECT_CALL(*mock_manager_client_,
 538               ConfigureServiceForProfile(
 539                   dbus::ObjectPath(kUser1ProfilePath),
 540                   IsEqualTo(expected_shill_properties.get()),
 541                   _, _));
 542
 543   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 544   message_loop_.RunUntilIdle();
 545 }
 546
 547 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUpdateManagedVPN) {
 548   InitializeStandardProfiles();
 549   SetUpEntry("policy/shill_managed_vpn.json", kUser1ProfilePath, "entry_path");
 550
 551   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 552       test_utils::ReadTestDictionary(
 553           "policy/shill_policy_on_managed_vpn.json");
 554
 555   EXPECT_CALL(*mock_profile_client_,
 556               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 557
 558   EXPECT_CALL(
 559       *mock_profile_client_,
 560       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "entry_path", _, _));
 561
 562   EXPECT_CALL(*mock_manager_client_,
 563               ConfigureServiceForProfile(
 564                   dbus::ObjectPath(kUser1ProfilePath),
 565                   IsEqualTo(expected_shill_properties.get()),
 566                   _, _));
 567
 568   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_vpn.onc");
 569   message_loop_.RunUntilIdle();
 570   VerifyAndClearExpectations();
 571 }
 572
 573 TEST_F(ManagedNetworkConfigurationHandlerTest,
 574        SetPolicyUpdateManagedEquivalentSecurity) {
 575   InitializeStandardProfiles();
 576   SetUpEntry("policy/shill_managed_wifi1_rsn.json",
 577              kUser1ProfilePath,
 578              "old_entry_path");
 579
 580   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 581       test_utils::ReadTestDictionary(
 582           "policy/shill_policy_on_unmanaged_wifi1.json");
 583
 584   // The passphrase isn't sent again, because it's configured by the user and
 585   // Shill doesn't send it on GetProperties calls.
 586   expected_shill_properties->RemoveWithoutPathExpansion(
 587       shill::kPassphraseProperty, NULL);
 588
 589   EXPECT_CALL(*mock_profile_client_,
 590               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 591
 592   EXPECT_CALL(
 593       *mock_profile_client_,
 594       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 595
 596   // The existing entry must not be deleted because the Security type 'rsa' is
 597   // equivalent to 'psk' when identifying networks.
 598
 599   EXPECT_CALL(
 600       *mock_manager_client_,
 601       ConfigureServiceForProfile(dbus::ObjectPath(kUser1ProfilePath),
 602                                  IsEqualTo(expected_shill_properties.get()),
 603                                  _, _));
 604
 605   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 606   message_loop_.RunUntilIdle();
 607 }
 608
 609 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyReapplyToManaged) {
 610   InitializeStandardProfiles();
 611   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
 612              kUser1ProfilePath,
 613              "old_entry_path");
 614
 615   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 616       test_utils::ReadTestDictionary(
 617           "policy/shill_policy_on_unmanaged_wifi1.json");
 618
 619   // The passphrase isn't sent again, because it's configured by the user and
 620   // Shill doesn't send it on GetProperties calls.
 621   expected_shill_properties->RemoveWithoutPathExpansion(
 622       shill::kPassphraseProperty, NULL);
 623
 624   EXPECT_CALL(*mock_profile_client_,
 625               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 626
 627   EXPECT_CALL(
 628       *mock_profile_client_,
 629       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 630
 631   EXPECT_CALL(*mock_manager_client_,
 632               ConfigureServiceForProfile(
 633                   dbus::ObjectPath(kUser1ProfilePath),
 634                   IsEqualTo(expected_shill_properties.get()),
 635                   _, _));
 636
 637   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 638   message_loop_.RunUntilIdle();
 639   VerifyAndClearExpectations();
 640
 641   // If we apply the policy again, without change, then the Shill profile will
 642   // not be modified.
 643   EXPECT_CALL(*mock_profile_client_,
 644               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 645
 646   EXPECT_CALL(
 647       *mock_profile_client_,
 648       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "old_entry_path", _, _));
 649
 650   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 651   message_loop_.RunUntilIdle();
 652 }
 653
 654 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyUnmanageManaged) {
 655   InitializeStandardProfiles();
 656   SetUpEntry("policy/shill_policy_on_unmanaged_wifi1.json",
 657              kUser1ProfilePath,
 658              "old_entry_path");
 659
 660   EXPECT_CALL(*mock_profile_client_,
 661               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 662
 663   EXPECT_CALL(*mock_profile_client_,
 664               GetEntry(dbus::ObjectPath(kUser1ProfilePath),
 665                        "old_entry_path",
 666                        _, _));
 667
 668   EXPECT_CALL(*mock_profile_client_,
 669               DeleteEntry(dbus::ObjectPath(kUser1ProfilePath),
 670                           "old_entry_path",
 671                           _, _));
 672
 673   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "");
 674   message_loop_.RunUntilIdle();
 675 }
 676
 677 TEST_F(ManagedNetworkConfigurationHandlerTest, SetEmptyPolicyIgnoreUnmanaged) {
 678   InitializeStandardProfiles();
 679   SetUpEntry("policy/shill_unmanaged_wifi1.json",
 680              kUser1ProfilePath,
 681              "old_entry_path");
 682
 683   EXPECT_CALL(*mock_profile_client_,
 684               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 685
 686   EXPECT_CALL(*mock_profile_client_,
 687               GetEntry(dbus::ObjectPath(kUser1ProfilePath),
 688                        "old_entry_path",
 689                        _, _));
 690
 691   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "");
 692   message_loop_.RunUntilIdle();
 693 }
 694
 695 TEST_F(ManagedNetworkConfigurationHandlerTest, SetPolicyIgnoreUnmanaged) {
 696   InitializeStandardProfiles();
 697   SetUpEntry("policy/shill_unmanaged_wifi2.json",
 698              kUser1ProfilePath,
 699              "wifi2_entry_path");
 700
 701   EXPECT_CALL(*mock_profile_client_,
 702               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 703
 704   EXPECT_CALL(
 705       *mock_profile_client_,
 706       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "wifi2_entry_path", _, _));
 707
 708   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 709       test_utils::ReadTestDictionary(
 710           "policy/shill_policy_on_unconfigured_wifi1.json");
 711
 712   EXPECT_CALL(*mock_manager_client_,
 713               ConfigureServiceForProfile(
 714                   dbus::ObjectPath(kUser1ProfilePath),
 715                   IsEqualTo(expected_shill_properties.get()),
 716                   _, _));
 717
 718   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 719   message_loop_.RunUntilIdle();
 720 }
 721
 722 TEST_F(ManagedNetworkConfigurationHandlerTest, AutoConnectDisallowed) {
 723   InitializeStandardProfiles();
 724   // Setup an unmanaged network.
 725   SetUpEntry("policy/shill_unmanaged_wifi2.json",
 726              kUser1ProfilePath,
 727              "wifi2_entry_path");
 728
 729   // Apply the user policy with global autoconnect config and expect that
 730   // autoconnect is disabled in the network's profile entry.
 731   EXPECT_CALL(*mock_profile_client_,
 732               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 733
 734   EXPECT_CALL(
 735       *mock_profile_client_,
 736       GetEntry(dbus::ObjectPath(kUser1ProfilePath), "wifi2_entry_path", _, _));
 737
 738   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 739       test_utils::ReadTestDictionary(
 740           "policy/shill_disallow_autoconnect_on_unmanaged_wifi2.json");
 741
 742   EXPECT_CALL(*mock_manager_client_,
 743               ConfigureServiceForProfile(
 744                   dbus::ObjectPath(kUser1ProfilePath),
 745                   IsEqualTo(expected_shill_properties.get()),
 746                   _, _));
 747
 748   SetPolicy(::onc::ONC_SOURCE_USER_POLICY,
 749             kUser1,
 750             "policy/policy_disallow_autoconnect.onc");
 751   message_loop_.RunUntilIdle();
 752
 753   // Verify that GetManagedProperties correctly augments the properties with the
 754   // global config from the user policy.
 755
 756   // GetManagedProperties requires the device policy to be set or explicitly
 757   // unset.
 758   EXPECT_CALL(*mock_profile_client_,
 759               GetProperties(dbus::ObjectPath(
 760                                 NetworkProfileHandler::GetSharedProfilePath()),
 761                             _,
 762                             _));
 763   managed_handler()->SetPolicy(
 764       ::onc::ONC_SOURCE_DEVICE_POLICY,
 765       std::string(),             // no userhash
 766       base::ListValue(),         // no device network policy
 767       base::DictionaryValue());  // no device global config
 768
 769   services_stub_.SetFakeProperties(*expected_shill_properties);
 770   EXPECT_CALL(*mock_service_client_,
 771               GetProperties(dbus::ObjectPath(
 772                                 "wifi2"),_));
 773
 774   GetManagedProperties(kUser1, "wifi2");
 775   message_loop_.RunUntilIdle();
 776
 777   EXPECT_EQ("wifi2", get_properties_service_path_);
 778
 779   scoped_ptr<base::DictionaryValue> expected_managed_onc =
 780       test_utils::ReadTestDictionary(
 781           "policy/managed_onc_disallow_autoconnect_on_unmanaged_wifi2.onc");
 782   EXPECT_TRUE(onc::test_utils::Equals(expected_managed_onc.get(),
 783                                       &get_properties_result_));
 784 }
 785
 786 TEST_F(ManagedNetworkConfigurationHandlerTest, LateProfileLoading) {
 787   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 788
 789   message_loop_.RunUntilIdle();
 790   VerifyAndClearExpectations();
 791
 792   scoped_ptr<base::DictionaryValue> expected_shill_properties =
 793       test_utils::ReadTestDictionary(
 794           "policy/shill_policy_on_unconfigured_wifi1.json");
 795
 796   EXPECT_CALL(*mock_profile_client_,
 797               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 798
 799   EXPECT_CALL(*mock_manager_client_,
 800               ConfigureServiceForProfile(
 801                   dbus::ObjectPath(kUser1ProfilePath),
 802                   IsEqualTo(expected_shill_properties.get()),
 803                   _, _));
 804
 805   InitializeStandardProfiles();
 806   message_loop_.RunUntilIdle();
 807 }
 808
 809 class ManagedNetworkConfigurationHandlerShutdownTest
 810     : public ManagedNetworkConfigurationHandlerTest {
 811  public:
 812   virtual void SetUp() OVERRIDE {
 813     ManagedNetworkConfigurationHandlerTest::SetUp();
 814     ON_CALL(*mock_profile_client_, GetProperties(_, _, _)).WillByDefault(
 815         Invoke(&ManagedNetworkConfigurationHandlerShutdownTest::GetProperties));
 816   }
 817
 818   static void GetProperties(
 819       const dbus::ObjectPath& profile_path,
 820       const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback,
 821       const ShillClientHelper::ErrorCallback& error_callback) {
 822     base::MessageLoop::current()->PostTask(
 823         FROM_HERE,
 824         base::Bind(ManagedNetworkConfigurationHandlerShutdownTest::
 825                        CallbackWithEmptyDictionary,
 826                    callback));
 827   }
 828
 829   static void CallbackWithEmptyDictionary(
 830       const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback) {
 831     callback.Run(base::DictionaryValue());
 832   }
 833 };
 834
 835 TEST_F(ManagedNetworkConfigurationHandlerShutdownTest,
 836        DuringPolicyApplication) {
 837   InitializeStandardProfiles();
 838
 839   EXPECT_CALL(*mock_profile_client_,
 840               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 841
 842   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
 843   managed_network_configuration_handler_.reset();
 844   message_loop_.RunUntilIdle();
 845 }
 846
 847 }  // namespace chromeos