Resolve certificate references in ONC by PEM.

chrome/browser/chromeos/cros/network_library_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 <pk11pub.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 136 matching lines @@
     cros_ = NULL;
   }
 
   // Load the ONC from |onc_file| using NetworkLibrary::LoadOncNetworks. Check
   // that return value matches |expect_successful_import| and the configuration
   // that would be sent to Shill matches |shill_json|.
   void LoadOncAndVerifyNetworks(std::string onc_file,
                                 std::string shill_json,
                                 onc::ONCSource source,
                                 bool expect_successful_import) {
-    MockUserManager* mock_user_manager = new MockUserManager;
+    MockUserManager* mock_user_manager =
+        new ::testing::StrictMock<MockUserManager>;
     // Takes ownership of |mock_user_manager|.
     ScopedUserManagerEnabler user_manager_enabler(mock_user_manager);
     mock_user_manager->SetActiveUser("madmax@my.domain.com");
     EXPECT_CALL(*mock_user_manager, IsUserLoggedIn())
         .Times(AnyNumber())
         .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mock_user_manager, Shutdown());
 
     scoped_ptr<base::DictionaryValue> onc_blob =
         onc::test_utils::ReadTestDictionary(onc_file);
     base::ListValue* onc_network_configs;
     onc_blob->GetListWithoutPathExpansion(
         onc::toplevel_config::kNetworkConfigurations,
         &onc_network_configs);
     ASSERT_TRUE(onc_network_configs);
 
     scoped_ptr<base::Value> expected_value =
@@ skipping 108 matching lines @@
   EXPECT_TRUE(wifi1->connected());
   cros_->DisconnectFromNetwork(wifi1);
   EXPECT_FALSE(wifi1->connected());
   EXPECT_TRUE(cros_->CanConnectToNetwork(wifi1));
   cros_->ConnectToWifiNetwork(wifi1);
   EXPECT_TRUE(wifi1->connected());
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectWifiWithCertPattern) {
   scoped_ptr<base::DictionaryValue> onc_root =
-      onc::test_utils::ReadTestDictionary("toplevel_wifi_eap_clientcert.onc");
+      onc::test_utils::ReadTestDictionary("certificate-client.onc");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
   onc::CertificateImporter importer(true /* allow trust imports */);
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates, NULL));
+            importer.ParseAndStoreCertificates(*certificates, NULL, NULL));
 
   WifiNetwork* wifi = cros_->FindWifiNetworkByPath("wifi_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
   wifi->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
 
   ASSERT_NE(static_cast<const WifiNetwork*>(NULL), wifi);
   EXPECT_FALSE(wifi->connected());
   EXPECT_TRUE(cros_->CanConnectToNetwork(wifi));
   EXPECT_FALSE(wifi->connected());
   wifi->AttemptConnection(
       base::Bind(&WifiNetworkConnectCallback, cros_, wifi));
   EXPECT_TRUE(wifi->connected());
   EXPECT_TRUE(enrollment_delegate->did_enroll);
   EXPECT_TRUE(enrollment_delegate->correct_args);
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectVPNWithCertPattern) {
   scoped_ptr<base::DictionaryValue> onc_root =
-      onc::test_utils::ReadTestDictionary("toplevel_openvpn_clientcert.onc");
+      onc::test_utils::ReadTestDictionary("certificate-client.onc");
   base::ListValue* certificates;
   onc_root->GetListWithoutPathExpansion(onc::toplevel_config::kCertificates,
                                         &certificates);
 
   onc::CertificateImporter importer(true /* allow trust imports */);
   ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
-            importer.ParseAndStoreCertificates(*certificates, NULL));
+            importer.ParseAndStoreCertificates(*certificates, NULL, NULL));
 
   VirtualNetwork* vpn = cros_->FindVirtualNetworkByPath("vpn_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
   vpn->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
 
   ASSERT_NE(static_cast<const VirtualNetwork*>(NULL), vpn);
   EXPECT_FALSE(vpn->connected());
@@ skipping 58 matching lines @@
   LoadOncAndVerifyNetworks(GetParam().onc_file,
                            GetParam().shill_file,
                            GetParam().onc_source,
                            GetParam().expect_import_result);
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoadOncNetworksTest,
     LoadOncNetworksTest,
     ::testing::Values(
-         ImportParams("managed_toplevel1.onc",
+         ImportParams("managed_toplevel1_with_cert_pems.onc",
                       "chromeos/net/shill_for_managed_toplevel1.json",
                       onc::ONC_SOURCE_USER_POLICY),
-         ImportParams("managed_toplevel2.onc",
+         ImportParams("managed_toplevel2_with_cert_pems.onc",
                       "chromeos/net/shill_for_managed_toplevel2.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("managed_toplevel_l2tpipsec.onc",
                       "chromeos/net/shill_for_managed_toplevel_l2tpipsec.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("managed_toplevel_wifi_peap.onc",
                       "chromeos/net/shill_for_managed_toplevel_wifi_peap.json",
                       onc::ONC_SOURCE_DEVICE_POLICY),
          ImportParams("toplevel_wifi_open.onc",
                       "chromeos/net/shill_for_toplevel_wifi_open.json",
                       onc::ONC_SOURCE_DEVICE_POLICY),
          ImportParams("toplevel_wifi_wep_proxy.onc",
                       "chromeos/net/shill_for_toplevel_wifi_wep_proxy.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_wpa_psk.onc",
                       "chromeos/net/shill_for_toplevel_wifi_wpa_psk.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_leap.onc",
                       "chromeos/net/shill_for_toplevel_wifi_leap.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams(
-            "toplevel_wifi_eap_clientcert.onc",
+            "toplevel_wifi_eap_clientcert_with_cert_pems.onc",
             "chromeos/net/shill_for_toplevel_wifi_eap_clientcert.json",
             onc::ONC_SOURCE_USER_POLICY),
-         ImportParams("toplevel_openvpn_clientcert.onc",
+         ImportParams("toplevel_openvpn_clientcert_with_cert_pems.onc",
                       "chromeos/net/shill_for_toplevel_openvpn_clientcert.json",
                       onc::ONC_SOURCE_USER_POLICY),
          ImportParams("toplevel_wifi_remove.onc",
                       "chromeos/net/shill_for_toplevel_wifi_remove.json",
                       onc::ONC_SOURCE_USER_POLICY)));
 
 // TODO(stevenjb): Test remembered networks.
 
 // TODO(stevenjb): Test network profiles.
 
 // TODO(stevenjb): Test network devices.
 
 // TODO(stevenjb): Test data plans.
 
 // TODO(stevenjb): Test monitor network / device.
 
 }  // namespace chromeos