Replace OncNetworkParser by the new ONC translator.

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 <cert.h>
 #include <pk11pub.h>
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #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"
 #include "net/base/nss_cert_database.h"
 #include "net/base/x509_certificate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Return;
+using ::testing::AtLeast;
 
 namespace chromeos {
 
 namespace {
 
 // Have to do a stub here because MOCK can't handle closure arguments.
 class StubEnrollmentDelegate : public EnrollmentDelegate {
  public:
   explicit StubEnrollmentDelegate()
       : did_enroll(false),
         correct_args(false) {}
 
   void Enroll(const std::vector<std::string>& uri_list,
               const base::Closure& closure) {
     std::vector<std::string> expected_uri_list;
     expected_uri_list.push_back("http://youtu.be/dQw4w9WgXcQ");
     expected_uri_list.push_back("chrome-extension://abc/keygen-cert.html");
     if (uri_list == expected_uri_list)
       correct_args = true;
 
     did_enroll = true;
     closure.Run();
   }
 
   bool did_enroll;
   bool correct_args;
 };
 
 void WifiNetworkConnectCallback(NetworkLibrary* cros, WifiNetwork* wifi) {
-  cros->ConnectToWifiNetwork(wifi);
+  cros->ConnectToWifiNetwork(wifi, false);
 }
 
 void VirtualNetworkConnectCallback(NetworkLibrary* cros, VirtualNetwork* vpn) {
   cros->ConnectToVirtualNetwork(vpn);
 }
 
 }  // namespace
 
 TEST(NetworkLibraryTest, DecodeNonAsciiSSID) {
 
@@ skipping 51 matching lines @@
   }
 }
 
 // Create a stub libcros for testing NetworkLibrary functionality through
 // NetworkLibraryStubImpl.
 // NOTE: It would be of little value to test stub functions that simply return
 // predefined values, e.g. ethernet_available(). However, many other functions
 // 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) {}
 
  protected:
   virtual void SetUp() {
     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();
+  // 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));
 
-      scoped_ptr<base::DictionaryValue> root =
-          onc::ReadDictionaryFromJson(contents);
-      CHECK(root.get() != NULL) << "ONC is not a valid JSON dictionary.";
+    std::string onc_blob =
+        onc::test_utils::ReadTestData(onc_file);
 
-      base::ListValue* certificates_ptr;
-      CHECK(root->GetListWithoutPathExpansion(onc::kCertificates,
-                                              &certificates_ptr));
-      certificates->reset(certificates_ptr->DeepCopy());
+    scoped_ptr<base::Value> expected_value =
+        google_apis::test_util::LoadJSONFile(shill_json);
+    base::DictionaryValue* expected_configs;
+    expected_value->GetAsDictionary(&expected_configs);
 
-      base::ListValue* network_configs_ptr;
-      CHECK(root->GetListWithoutPathExpansion(onc::kNetworkConfigurations,
-                                              &network_configs_ptr));
-      network_configs->reset(network_configs_ptr->DeepCopy());
+    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);
     for (CERTCertListNode* node = CERT_LIST_HEAD(cert_list);
          !CERT_LIST_END(node, cert_list);
          node = CERT_LIST_NEXT(node)) {
       result.push_back(net::X509Certificate::CreateFromHandle(
           node->cert, net::X509Certificate::OSCertHandles()));
     }
     CERT_DestroyCertList(cert_list);
@@ skipping 94 matching lines @@
   WifiNetwork* wifi1 = cros_->FindWifiNetworkByPath("wifi1");
   ASSERT_NE(static_cast<const WifiNetwork*>(NULL), wifi1);
   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, 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);
 }
 
 TEST_F(NetworkLibraryStubTest, NetworkConnectVPN) {
   VirtualNetwork* vpn1 = cros_->FindVirtualNetworkByPath("vpn1");
   EXPECT_NE(static_cast<const VirtualNetwork*>(NULL), vpn1);
   EXPECT_FALSE(vpn1->connected());
   EXPECT_TRUE(cros_->CanConnectToNetwork(vpn1));
   cros_->ConnectToVirtualNetwork(vpn1);
   EXPECT_TRUE(vpn1->connected());
   ASSERT_NE(static_cast<const VirtualNetwork*>(NULL), cros_->virtual_network());
   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.
 
 // TODO(stevenjb): Test network devices.
 
 // TODO(stevenjb): Test data plans.
 
 // TODO(stevenjb): Test monitor network / device.
 
 }  // namespace chromeos