Replace OncNetworkParser by the new ONC translator.

chrome/browser/chromeos/cros/network_library_unittest.cc

Index: chrome/browser/chromeos/cros/network_library_unittest.cc
diff --git a/chrome/browser/chromeos/cros/network_library_unittest.cc b/chrome/browser/chromeos/cros/network_library_unittest.cc
index c5e8949acde9f06bef39751b94bcbfe3774a2fe7..8365039432dc751861ac6899d9a4f9e4b834b6b0 100644
--- a/chrome/browser/chromeos/cros/network_library_unittest.cc
+++ b/chrome/browser/chromeos/cros/network_library_unittest.cc
@@ -17,10 +17,13 @@
 #include "base/path_service.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
-#include "chrome/browser/chromeos/cros/onc_network_parser.h"
+#include "chrome/browser/chromeos/cros/network_library_impl_stub.h"
+#include "chrome/browser/chromeos/login/mock_user_manager.h"
+#include "chrome/browser/google_apis/test_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chromeos/network/onc/onc_certificate_importer.h"
 #include "chromeos/network/onc/onc_constants.h"
+#include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "crypto/nss_util.h"
 #include "net/base/crypto_module.h"
@@ -30,6 +33,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Return;
+using ::testing::AtLeast;
 
 namespace chromeos {
 
@@ -59,7 +63,7 @@ class StubEnrollmentDelegate : public EnrollmentDelegate {
 };
 
 void WifiNetworkConnectCallback(NetworkLibrary* cros, WifiNetwork* wifi) {
-  cros->ConnectToWifiNetwork(wifi);
+  cros->ConnectToWifiNetwork(wifi, false);
 }
 
 void VirtualNetworkConnectCallback(NetworkLibrary* cros, VirtualNetwork* vpn) {
@@ -131,7 +135,7 @@ TEST(NetworkLibraryTest, DecodeNonAsciiSSID) {
 // such as connected_network() return values which are set indirectly and thus
 // we can test the logic of those setters.
 
-class NetworkLibraryStubTest : public testing::Test {
+class NetworkLibraryStubTest : public ::testing::Test {
  public:
   NetworkLibraryStubTest() : cros_(NULL) {}
 
@@ -140,48 +144,65 @@ class NetworkLibraryStubTest : public testing::Test {
     ASSERT_TRUE(test_nssdb_.is_open());
 
     slot_ = net::NSSCertDatabase::GetInstance()->GetPublicModule();
-    cros_ = CrosLibrary::Get()->GetNetworkLibrary();
+    cros_ = static_cast<NetworkLibraryImplStub*>(
+        CrosLibrary::Get()->GetNetworkLibrary());
     ASSERT_TRUE(cros_) << "GetNetworkLibrary() Failed!";
 
     // Test db should be empty at start of test.
     EXPECT_EQ(0U, ListCertsInSlot(slot_->os_module_handle()).size());
   }
+
   virtual void TearDown() {
     cros_ = NULL;
     EXPECT_TRUE(CleanupSlotContents(slot_->os_module_handle()));
     EXPECT_EQ(0U, ListCertsInSlot(slot_->os_module_handle()).size());
   }
 
-  virtual void GetTestData(const std::string& filename,
-                           scoped_ptr<base::ListValue>* certificates,
-                           scoped_ptr<base::ListValue>* network_configs) {
-      FilePath path;
-      PathService::Get(chrome::DIR_TEST_DATA, &path);
-      path = path.AppendASCII("chromeos").AppendASCII("cros").Append(filename);
-      ASSERT_TRUE(file_util::PathExists(path))
-        << "Couldn't find test data file " << path.value();
-      std::string contents;
-      ASSERT_TRUE(file_util::ReadFileToString(path, &contents))
-        << "Unable to read test data file " << path.value();
-
-      scoped_ptr<base::DictionaryValue> root =
-          onc::ReadDictionaryFromJson(contents);
-      CHECK(root.get() != NULL) << "ONC is not a valid JSON dictionary.";
-
-      base::ListValue* certificates_ptr;
-      CHECK(root->GetListWithoutPathExpansion(onc::kCertificates,
-                                              &certificates_ptr));
-      certificates->reset(certificates_ptr->DeepCopy());
-
-      base::ListValue* network_configs_ptr;
-      CHECK(root->GetListWithoutPathExpansion(onc::kNetworkConfigurations,
-                                              &network_configs_ptr));
-      network_configs->reset(network_configs_ptr->DeepCopy());
+  // 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) {
+    ScopedMockUserManagerEnabler mock_user_manager;
+    mock_user_manager.user_manager()->SetLoggedInUser("madmax@my.domain.com");
+    EXPECT_CALL(*mock_user_manager.user_manager(), IsUserLoggedIn())
+        .Times(AtLeast(0))
+        .WillRepeatedly(Return(true));
+
+    std::string onc_blob =
+        onc::test_utils::ReadTestData(onc_file);
+
+    scoped_ptr<base::Value> expected_value =
+        google_apis::test_util::LoadJSONFile(shill_json);
+    base::DictionaryValue* expected_configs;
+    expected_value->GetAsDictionary(&expected_configs);
+
+    EXPECT_EQ(expect_successful_import,
+              cros_->LoadOncNetworks(onc_blob, "", source, true));
+
+    const std::map<std::string, base::DictionaryValue*>& configs =
+        cros_->GetConfigurations();
+
+    EXPECT_EQ(expected_configs->size(), configs.size());
+
+    for (base::DictionaryValue::Iterator it(*expected_configs); it.HasNext();
+         it.Advance()) {
+      const base::DictionaryValue* expected_config;
+      it.value().GetAsDictionary(&expected_config);
+
+      std::map<std::string, base::DictionaryValue*>::const_iterator entry =
+          configs.find(it.key());
+      EXPECT_NE(entry, configs.end());
+      base::DictionaryValue* actual_config = entry->second;
+      EXPECT_TRUE(onc::test_utils::Equals(expected_config, actual_config));
+    }
   }
 
   ScopedStubCrosEnabler cros_stub_;
-  NetworkLibrary* cros_;
- private:
+  NetworkLibraryImplStub* cros_;
+ protected:
   net::CertificateList ListCertsInSlot(PK11SlotInfo* slot) {
     net::CertificateList result;
     CERTCertList* cert_list = PK11_ListCertsInSlot(slot);
@@ -296,76 +317,60 @@ TEST_F(NetworkLibraryStubTest, NetworkConnectWifi) {
   EXPECT_TRUE(wifi1->connected());
 }
 
-TEST_F(NetworkLibraryStubTest, NetworkConnectOncWifi) {
-  // Import a wireless network via loading an ONC file.
-  scoped_ptr<base::ListValue> network_configs;
-  scoped_ptr<base::ListValue> certificates;
-  GetTestData("cert-pattern.onc", &certificates, &network_configs);
+TEST_F(NetworkLibraryStubTest, NetworkConnectWifiWithCertPattern) {
+  scoped_ptr<base::DictionaryValue> onc_root =
+      onc::test_utils::ReadTestDictionary("toplevel_wifi_eap_clientcert.onc");
+  base::ListValue* certificates;
+  onc_root->GetListWithoutPathExpansion(onc::kCertificates, &certificates);
 
   onc::CertificateImporter importer(onc::ONC_SOURCE_USER_IMPORT,
                                     false /* don't allow webtrust */);
-  EXPECT_EQ(onc::CertificateImporter::IMPORT_OK,
+  ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
             importer.ParseAndStoreCertificates(*certificates));
 
-  OncNetworkParser parser(*network_configs,
-                          onc::ONC_SOURCE_USER_IMPORT);
-  ASSERT_TRUE(parser.parse_error().empty());
-  EXPECT_EQ(1, parser.GetNetworkConfigsSize());
-  scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
-  ASSERT_TRUE(network.get());
-  EXPECT_EQ(CLIENT_CERT_TYPE_PATTERN, network->client_cert_type());
+  WifiNetwork* wifi = cros_->FindWifiNetworkByPath("wifi_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
-
-  network->SetEnrollmentDelegate(enrollment_delegate);
+  wifi->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
-  WifiNetwork* wifi1 = static_cast<WifiNetwork*>(network.get());
 
-  ASSERT_NE(static_cast<const WifiNetwork*>(NULL), wifi1);
-  EXPECT_FALSE(wifi1->connected());
-  EXPECT_TRUE(cros_->CanConnectToNetwork(wifi1));
-  EXPECT_FALSE(wifi1->connected());
-  wifi1->AttemptConnection(
-      base::Bind(&WifiNetworkConnectCallback, cros_, wifi1));
-  EXPECT_TRUE(wifi1->connected());
+  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, NetworkConnectOncVPN) {
-  // Import a wireless network via loading an ONC file.
-  scoped_ptr<base::ListValue> network_configs;
-  scoped_ptr<base::ListValue> certificates;
-  GetTestData("cert-pattern-vpn.onc", &certificates, &network_configs);
+TEST_F(NetworkLibraryStubTest, NetworkConnectVPNWithCertPattern) {
+  scoped_ptr<base::DictionaryValue> onc_root =
+      onc::test_utils::ReadTestDictionary("toplevel_openvpn_clientcert.onc");
+  base::ListValue* certificates;
+  onc_root->GetListWithoutPathExpansion(onc::kCertificates, &certificates);
 
   onc::CertificateImporter importer(onc::ONC_SOURCE_USER_IMPORT,
                                     false /* don't allow webtrust */);
-  EXPECT_EQ(onc::CertificateImporter::IMPORT_OK,
+  ASSERT_EQ(onc::CertificateImporter::IMPORT_OK,
             importer.ParseAndStoreCertificates(*certificates));
 
-  OncNetworkParser parser(*network_configs,
-                          onc::ONC_SOURCE_USER_IMPORT);
-  ASSERT_TRUE(parser.parse_error().empty());
-  EXPECT_EQ(1, parser.GetNetworkConfigsSize());
-  scoped_ptr<Network> network(parser.ParseNetwork(0, NULL));
-  ASSERT_TRUE(network.get());
-  EXPECT_EQ(CLIENT_CERT_TYPE_PATTERN, network->client_cert_type());
+  VirtualNetwork* vpn = cros_->FindVirtualNetworkByPath("vpn_cert_pattern");
 
   StubEnrollmentDelegate* enrollment_delegate = new StubEnrollmentDelegate();
-
-  network->SetEnrollmentDelegate(enrollment_delegate);
+  vpn->SetEnrollmentDelegate(enrollment_delegate);
   EXPECT_FALSE(enrollment_delegate->did_enroll);
   EXPECT_FALSE(enrollment_delegate->correct_args);
-  VirtualNetwork* vpn1 = static_cast<VirtualNetwork*>(network.get());
 
-  ASSERT_NE(static_cast<const VirtualNetwork*>(NULL), vpn1);
-  EXPECT_FALSE(vpn1->connected());
-  EXPECT_TRUE(cros_->CanConnectToNetwork(vpn1));
-  EXPECT_FALSE(vpn1->connected());
-  vpn1->AttemptConnection(
-      base::Bind(&VirtualNetworkConnectCallback, cros_, vpn1));
-  EXPECT_TRUE(vpn1->connected());
+  ASSERT_NE(static_cast<const VirtualNetwork*>(NULL), vpn);
+  EXPECT_FALSE(vpn->connected());
+  EXPECT_TRUE(cros_->CanConnectToNetwork(vpn));
+  EXPECT_FALSE(vpn->connected());
+  vpn->AttemptConnection(
+      base::Bind(&VirtualNetworkConnectCallback, cros_, vpn));
+  EXPECT_TRUE(vpn->connected());
   EXPECT_TRUE(enrollment_delegate->did_enroll);
   EXPECT_TRUE(enrollment_delegate->correct_args);
 }
@@ -381,6 +386,110 @@ TEST_F(NetworkLibraryStubTest, NetworkConnectVPN) {
   EXPECT_EQ("vpn1", cros_->virtual_network()->service_path());
 }
 
+TEST_F(NetworkLibraryStubTest, LoadOncNetworksWithInvalidConfig) {
+  LoadOncAndVerifyNetworks(
+      "toplevel_partially_invalid.onc",
+      "net/shill_for_toplevel_partially_invalid.json",
+      onc::ONC_SOURCE_USER_POLICY,
+      false  /* expect import to fail */);
+
+  EXPECT_EQ(ListCertsInSlot(slot_->os_module_handle()).size(), 1U);
+}
+
+namespace {
+
+struct ImportParams {
+  // |onc_file|: Filename of source ONC, relative to
+  //             chromeos/test/data/network.
+  // |shill_file|: Filename of expected Shill config, relative to
+  //               chrome/test/data/chromeos).
+  // |onc_source|: The source of the ONC.
+  // |expect_import_result|: The expected return value of LoadOncNetworks.
+  ImportParams(const std::string& onc_file,
+               const std::string& shill_file,
+               onc::ONCSource onc_source,
+               bool expect_import_result = true)
+      : onc_file(onc_file),
+        shill_file(shill_file),
+        onc_source(onc_source),
+        expect_import_result(expect_import_result) {
+  }
+
+  std::string onc_file, shill_file;
+  onc::ONCSource onc_source;
+  bool expect_import_result;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const ImportParams& params) {
+  return os << "(" << params.onc_file << ", " << params.shill_file << ", "
+            << onc::GetSourceAsString(params.onc_source) << ", "
+            << (params.expect_import_result ? "valid" : "invalid") << ")";
+}
+
+}  // namespace
+
+class LoadOncNetworksTest
+    : public NetworkLibraryStubTest,
+      public ::testing::WithParamInterface<ImportParams> {
+};
+
+TEST_P(LoadOncNetworksTest, VerifyNetworksAndCertificates) {
+  LoadOncAndVerifyNetworks(GetParam().onc_file,
+                           GetParam().shill_file,
+                           GetParam().onc_source,
+                           GetParam().expect_import_result);
+
+  scoped_ptr<base::DictionaryValue> onc_dict =
+      onc::test_utils::ReadTestDictionary(GetParam().onc_file);
+  base::ListValue* onc_certs;
+  onc_dict->GetListWithoutPathExpansion(onc::kCertificates, &onc_certs);
+
+  EXPECT_EQ(onc_certs->GetSize(),
+            ListCertsInSlot(slot_->os_module_handle()).size());
+}
+
+INSTANTIATE_TEST_CASE_P(
+    LoadOncNetworksTest,
+    LoadOncNetworksTest,
+    ::testing::Values(
+         ImportParams("managed_toplevel1.onc",
+                      "net/shill_for_managed_toplevel1.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("managed_toplevel2.onc",
+                      "net/shill_for_managed_toplevel2.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("managed_toplevel_l2tpipsec.onc",
+                      "net/shill_for_managed_toplevel_l2tpipsec.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("managed_toplevel_wifi_peap.onc",
+                      "net/shill_for_managed_toplevel_wifi_peap.json",
+                      onc::ONC_SOURCE_DEVICE_POLICY),
+         ImportParams("toplevel_wifi_open.onc",
+                      "net/shill_for_toplevel_wifi_open.json",
+                      onc::ONC_SOURCE_DEVICE_POLICY),
+         ImportParams("toplevel_wifi_wep_proxy.onc",
+                      "net/shill_for_toplevel_wifi_wep_proxy.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_wifi_wpa_psk.onc",
+                      "net/shill_for_toplevel_wifi_wpa_psk.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_wifi_leap.onc",
+                      "net/shill_for_toplevel_wifi_leap.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_wifi_eap_clientcert.onc",
+                      "net/shill_for_toplevel_wifi_eap_clientcert.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_openvpn_clientcert.onc",
+                      "net/shill_for_toplevel_openvpn_clientcert.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_wifi_remove.onc",
+                      "net/shill_for_toplevel_wifi_remove.json",
+                      onc::ONC_SOURCE_USER_POLICY),
+         ImportParams("toplevel_with_unknown_fields.onc",
+                      "net/shill_for_toplevel_with_unknown_fields.json",
+                      onc::ONC_SOURCE_USER_POLICY,
+                      false)));
+
 // TODO(stevenjb): Test remembered networks.
 
 // TODO(stevenjb): Test network profiles.