Autoconnect policy for CrOS.

chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc

 // Copyright 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 "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
@@ skipping 53 matching lines @@
 const char kFakeONC[] =
     "{ \"NetworkConfigurations\": ["
     "    { \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5040}\","
     "      \"Type\": \"WiFi\","
     "      \"Name\": \"My WiFi Network\","
     "      \"WiFi\": {"
     "        \"SSID\": \"ssid-none\","
     "        \"Security\": \"None\" }"
     "    }"
     "  ],"
+    "  \"GlobalNetworkConfiguration\": {"
+    "    \"AllowAutoconnect\": false,"
+    "  },"
     "  \"Certificates\": ["
     "    { \"GUID\": \"{f998f760-272b-6939-4c2beffe428697ac}\","
     "      \"PKCS12\": \"abc\","
     "       \"Type\": \"Client\" }"
     "  ],"
     "  \"Type\": \"UnencryptedConfiguration\""
     "}";
 
-std::string ValueToString(const base::Value* value) {
+std::string ValueToString(const base::Value& value) {
   std::stringstream str;
-  str << *value;
+  str << value;
   return str.str();
 }
 
+void AppendAll(const base::ListValue& from, base::ListValue* to) {
+  for (base::ListValue::const_iterator it = from.begin(); it != from.end();
+       ++it) {
+    to->Append((*it)->DeepCopy());
+  }
+}
+
 // Matcher to match base::Value.
 MATCHER_P(IsEqualTo,
           value,
           std::string(negation ? "isn't" : "is") + " equal to " +
-              ValueToString(value)) {
+              ValueToString(*value)) {
   return value->Equals(&arg);
 }
 
+MATCHER(IsEmpty, std::string(negation ? "isn't" : "is") + " empty.") {
+  return arg.empty();
+}
+
 ACTION_P(SetCertificateList, list) {
   if (arg2)
     *arg2 = list;
   return true;
 }
 
 }  // namespace
 
 class NetworkConfigurationUpdaterTest : public testing::Test {
  protected:
   NetworkConfigurationUpdaterTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
 
-    empty_network_configs_.reset(new base::ListValue);
-    empty_certificates_.reset(new base::ListValue);
-
     scoped_ptr<base::DictionaryValue> fake_toplevel_onc =
         chromeos::onc::ReadDictionaryFromJson(kFakeONC);
 
-    scoped_ptr<base::Value> network_configs_value;
     base::ListValue* network_configs = NULL;
-    fake_toplevel_onc->RemoveWithoutPathExpansion(
-        onc::toplevel_config::kNetworkConfigurations, &network_configs_value);
-    network_configs_value.release()->GetAsList(&network_configs);
-    fake_network_configs_.reset(network_configs);
+    fake_toplevel_onc->GetListWithoutPathExpansion(
+        onc::toplevel_config::kNetworkConfigurations, &network_configs);
+    AppendAll(*network_configs, &fake_network_configs_);
 
-    scoped_ptr<base::Value> certs_value;
+    base::DictionaryValue* global_config = NULL;
+    fake_toplevel_onc->GetDictionaryWithoutPathExpansion(
+        onc::toplevel_config::kGlobalNetworkConfiguration, &global_config);
+    fake_global_network_config_.MergeDictionary(global_config);
+
     base::ListValue* certs = NULL;
-    fake_toplevel_onc->RemoveWithoutPathExpansion(
-        onc::toplevel_config::kCertificates, &certs_value);
-    certs_value.release()->GetAsList(&certs);
-    fake_certificates_.reset(certs);
+    fake_toplevel_onc->GetListWithoutPathExpansion(
+        onc::toplevel_config::kCertificates, &certs);
+    AppendAll(*certs, &fake_certificates_);
 
     certificate_importer_ =
         new StrictMock<chromeos::onc::MockCertificateImporter>();
     certificate_importer_owned_.reset(certificate_importer_);
   }
 
   virtual void TearDown() OVERRIDE {
     network_configuration_updater_.reset();
     provider_.Shutdown();
     base::RunLoop().RunUntilIdle();
@@ skipping 19 matching lines @@
   }
 
   void CreateNetworkConfigurationUpdaterForDevicePolicy() {
     network_configuration_updater_ =
         NetworkConfigurationUpdater::CreateForDevicePolicy(
             certificate_importer_owned_.Pass(),
             policy_service_.get(),
             &network_config_handler_);
   }
 
-  scoped_ptr<base::ListValue> empty_network_configs_;
-  scoped_ptr<base::ListValue> empty_certificates_;
-  scoped_ptr<base::ListValue> fake_network_configs_;
-  scoped_ptr<base::ListValue> fake_certificates_;
+  base::ListValue fake_network_configs_;
+  base::DictionaryValue fake_global_network_config_;
+  base::ListValue fake_certificates_;
   StrictMock<chromeos::MockManagedNetworkConfigurationHandler>
       network_config_handler_;
 
   // Ownership of certificate_importer_owned_ is passed to the
   // NetworkConfigurationUpdater. When that happens, |certificate_importer_|
   // continues to point to that instance but |certificate_importer_owned_| is
   // released.
   StrictMock<chromeos::onc::MockCertificateImporter>* certificate_importer_;
   scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer_owned_;
 
@@ skipping 11 matching lines @@
 
   scoped_ptr<base::DictionaryValue> onc_repaired =
       chromeos::onc::test_utils::ReadTestDictionary(
           "repaired_toplevel_partially_invalid.onc");
 
   base::ListValue* network_configs_repaired = NULL;
   onc_repaired->GetListWithoutPathExpansion(
       onc::toplevel_config::kNetworkConfigurations, &network_configs_repaired);
   ASSERT_TRUE(network_configs_repaired);
 
+  base::DictionaryValue* global_config_repaired = NULL;
+  onc_repaired->GetDictionaryWithoutPathExpansion(
+      onc::toplevel_config::kGlobalNetworkConfiguration,
+      &global_config_repaired);
+  ASSERT_TRUE(global_config_repaired);
+
   PolicyMap policy;
   policy.Set(key::kOpenNetworkConfiguration,
              POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_USER,
              new base::StringValue(onc_policy),
              NULL);
   UpdateProviderPolicy(policy);
 
-  EXPECT_CALL(
-      network_config_handler_,
-      SetPolicy(
-          onc::ONC_SOURCE_USER_POLICY, _, IsEqualTo(network_configs_repaired)));
+  EXPECT_CALL(network_config_handler_,
+              SetPolicy(onc::ONC_SOURCE_USER_POLICY,
+                        _,
+                        IsEqualTo(network_configs_repaired),
+                        IsEqualTo(global_config_repaired)));
   EXPECT_CALL(*certificate_importer_,
               ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY, _));
 
   CreateNetworkConfigurationUpdaterForUserPolicy(
       false /* do not allow trusted certs from policy */ );
 }
 
 TEST_F(NetworkConfigurationUpdaterTest,
        DoNotAllowTrustedCertificatesFromPolicy) {
   net::CertificateList cert_list;
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
 
   EXPECT_CALL(network_config_handler_,
-              SetPolicy(onc::ONC_SOURCE_USER_POLICY, _, _));
+              SetPolicy(onc::ONC_SOURCE_USER_POLICY, _, _, _));
   EXPECT_CALL(*certificate_importer_, ImportCertificates(_, _, _))
       .WillRepeatedly(SetCertificateList(cert_list));
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           false /* do not allow trusted certs from policy */);
 
   // Certificates with the "Web" trust flag set should not be forwarded to the
   // trust provider.
   policy::PolicyCertVerifier cert_verifier((
       base::Closure() /* no policy cert trusted callback */));
   updater->SetPolicyCertVerifier(&cert_verifier);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(cert_verifier.GetAdditionalTrustAnchors().empty());
 
   // |cert_verifier| must outlive the updater.
   network_configuration_updater_.reset();
 }
 
 TEST_F(NetworkConfigurationUpdaterTest, AllowTrustedCertificatesFromPolicy) {
   net::CertificateList cert_list;
   cert_list =
       net::CreateCertificateListFromFile(net::GetTestCertsDirectory(),
                                          "ok_cert.pem",
                                          net::X509Certificate::FORMAT_AUTO);
   ASSERT_EQ(1u, cert_list.size());
 
   EXPECT_CALL(network_config_handler_,
-              SetPolicy(onc::ONC_SOURCE_USER_POLICY, _, _));
+              SetPolicy(onc::ONC_SOURCE_USER_POLICY, _, _, _));
   EXPECT_CALL(*certificate_importer_,
               ImportCertificates(_, onc::ONC_SOURCE_USER_POLICY, _))
       .WillRepeatedly(SetCertificateList(cert_list));
 
   UserNetworkConfigurationUpdater* updater =
       CreateNetworkConfigurationUpdaterForUserPolicy(
           true /* allow trusted certs from policy */);
 
   // Certificates with the "Web" trust flag set should be forwarded to the
   // trust provider.
@@ skipping 39 matching lines @@
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam, InitialUpdates) {
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
 
   EXPECT_CALL(network_config_handler_,
               SetPolicy(CurrentONCSource(),
                         ExpectedUsernameHash(),
-                        IsEqualTo(fake_network_configs_.get())));
+                        IsEqualTo(&fake_network_configs_),
+                        IsEqualTo(&fake_global_network_config_)));
   EXPECT_CALL(*certificate_importer_,
               ImportCertificates(
-                  IsEqualTo(fake_certificates_.get()), CurrentONCSource(), _));
+                  IsEqualTo(&fake_certificates_), CurrentONCSource(), _));
 
   CreateNetworkConfigurationUpdater();
 }
 
 
 TEST_P(NetworkConfigurationUpdaterTestWithParam, PolicyChange) {
   // Ignore the initial updates.
-  EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _)).Times(AtLeast(1));
+  EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _)).Times(AtLeast(1));
   EXPECT_CALL(*certificate_importer_, ImportCertificates(_, _, _))
       .Times(AtLeast(1));
   CreateNetworkConfigurationUpdater();
   Mock::VerifyAndClearExpectations(&network_config_handler_);
   Mock::VerifyAndClearExpectations(certificate_importer_);
 
   // The Updater should update if policy changes.
-  EXPECT_CALL(
-      network_config_handler_,
-      SetPolicy(CurrentONCSource(), _, IsEqualTo(fake_network_configs_.get())));
+  EXPECT_CALL(network_config_handler_,
+              SetPolicy(CurrentONCSource(),
+                        _,
+                        IsEqualTo(&fake_network_configs_),
+                        IsEqualTo(&fake_global_network_config_)));
   EXPECT_CALL(*certificate_importer_,
               ImportCertificates(
-                  IsEqualTo(fake_certificates_.get()), CurrentONCSource(), _));
+                  IsEqualTo(&fake_certificates_), CurrentONCSource(), _));
 
   PolicyMap policy;
   policy.Set(GetParam(), POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              new base::StringValue(kFakeONC), NULL);
   UpdateProviderPolicy(policy);
   Mock::VerifyAndClearExpectations(&network_config_handler_);
   Mock::VerifyAndClearExpectations(certificate_importer_);
 
   // Another update is expected if the policy goes away.
-  EXPECT_CALL(
-      network_config_handler_,
-      SetPolicy(
-          CurrentONCSource(), _, IsEqualTo(empty_network_configs_.get())));
+  EXPECT_CALL(network_config_handler_,
+              SetPolicy(CurrentONCSource(), _, IsEmpty(), IsEmpty()));
   EXPECT_CALL(*certificate_importer_,
-              ImportCertificates(
-                  IsEqualTo(empty_certificates_.get()), CurrentONCSource(), _));
+              ImportCertificates(IsEmpty(), CurrentONCSource(), _));
 
   policy.Erase(GetParam());
   UpdateProviderPolicy(policy);
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy