Replace OncNetworkParser by the new ONC translator.

chromeos/network/onc/onc_validator_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 "chromeos/network/onc/onc_validator.h"
 
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 12 matching lines @@
  public:
   // Validate |onc_object| with the given |signature|. The object is considered
   // to be managed if |managed_onc| is true. A strict validator is used if
   // |strict| is true. |onc_object| and the resulting repaired object of the
   // validation is stored, so that expectations can be checked afterwards using
   // one of the Expect* functions below.
   void Validate(bool strict,
                 scoped_ptr<base::DictionaryValue> onc_object,
                 const OncValueSignature* signature,
                 bool managed_onc) {
+    Validate(strict, onc_object.Pass(), signature, managed_onc,
+             ONC_SOURCE_NONE);
+  }
+
+  void Validate(bool strict,
+                scoped_ptr<base::DictionaryValue> onc_object,
+                const OncValueSignature* signature,
+                bool managed_onc,
+                ONCSource onc_source) {
     scoped_ptr<Validator> validator;
     if (strict) {
       // Create a strict validator that complains about every error.
       validator.reset(new Validator(true, true, true, managed_onc));
     } else {
       // Create a liberal validator that ignores or repairs non-critical errors.
       validator.reset(new Validator(false, false, false, managed_onc));
     }
+    validator->SetOncSource(onc_source);
     original_object_ = onc_object.Pass();
     repaired_object_ = validator->ValidateAndRepairObject(signature,
                                                           *original_object_,
                                                           &validation_result_);
   }
 
   void ExpectValid() {
     EXPECT_EQ(Validator::VALID, validation_result_);
     EXPECT_TRUE(test_utils::Equals(original_object_.get(),
                                    repaired_object_.get()));
@@ skipping 14 matching lines @@
   Validator::Result validation_result_;
   scoped_ptr<const base::DictionaryValue> original_object_;
   scoped_ptr<const base::DictionaryValue> repaired_object_;
 };
 
 namespace {
 
 struct OncParams {
   // |location_of_object| is a string to identify the object to be tested. It
   // may be used as a filename or as a dictionary key.
-  OncParams(std::string location_of_object,
+  OncParams(const std::string& location_of_object,
             const OncValueSignature* onc_signature,
             bool is_managed_onc)
       : location(location_of_object),
         signature(onc_signature),
         is_managed(is_managed_onc) {
   }
 
   std::string location;
   const OncValueSignature* signature;
   bool is_managed;
 };
 
 ::std::ostream& operator<<(::std::ostream& os, const OncParams& onc) {
   return os << "(" << onc.location << ", " << onc.signature << ", "
             << (onc.is_managed ? "managed" : "unmanaged") << ")";
 }
 
 }  // namespace
 
 // Ensure that the constant |kEmptyUnencryptedConfiguration| describes a valid
 // ONC toplevel object.
 TEST_F(ONCValidatorTest, EmptyUnencryptedConfiguration) {
   Validate(true, ReadDictionaryFromJson(kEmptyUnencryptedConfiguration),
            &kToplevelConfigurationSignature, false);
   ExpectValid();
 }
 
+// Ensure that VPN is rejected in device policies.
+TEST_F(ONCValidatorTest, VPNInDevicePolicyInvalid) {
+  Validate(true, test_utils::ReadTestDictionary("valid_openvpn.onc"),
+           &kNetworkConfigurationSignature, true, ONC_SOURCE_DEVICE_POLICY);
+  ExpectInvalid();
+}
+
+// Ensure that client certificate patterns are rejected in device policies.
+TEST_F(ONCValidatorTest, ClientCertPatternInDevicePolicyInvalid) {
+  Validate(true, test_utils::ReadTestDictionary("valid_wifi_clientcert.onc"),
+           &kNetworkConfigurationSignature, true, ONC_SOURCE_DEVICE_POLICY);
+  ExpectInvalid();
+}
+
+// Check that at least one configuration is accepted for device policies.
+TEST_F(ONCValidatorTest, ValidNetworkInDevicePolicy) {
+  Validate(true, test_utils::ReadTestDictionary("valid_wifi_psk.onc"),
+           &kNetworkConfigurationSignature, true, ONC_SOURCE_DEVICE_POLICY);
+  ExpectValid();
+}
+
 // This test case is about validating valid ONC objects without any errors. Both
 // the strict and the liberal validator accept the object.
 class ONCValidatorValidTest : public ONCValidatorTest,
                               public ::testing::WithParamInterface<OncParams> {
 };
 
 TEST_P(ONCValidatorValidTest, StrictValidationValid) {
   OncParams onc = GetParam();
   Validate(true, test_utils::ReadTestDictionary(onc.location), onc.signature,
            onc.is_managed);
@@ skipping 13 matching lines @@
 //           bool: true if the ONC is managed).
 INSTANTIATE_TEST_CASE_P(
     ONCValidatorValidTest,
     ONCValidatorValidTest,
     ::testing::Values(OncParams("managed_toplevel1.onc",
                                 &kToplevelConfigurationSignature,
                                 true),
                       OncParams("managed_toplevel2.onc",
                                 &kToplevelConfigurationSignature,
                                 true),
-                      // Test a configuration generated by CPanel.
-                      OncParams("managed_toplevel_cpanel.onc",
+                      OncParams("toplevel_wifi_wpa_psk.onc",
                                 &kToplevelConfigurationSignature,
-                                true),
+                                false),
                       OncParams("encrypted.onc",
                                 &kToplevelConfigurationSignature,
                                 true),
                       OncParams("managed_vpn.onc",
                                 &kNetworkConfigurationSignature,
                                 true),
                       OncParams("managed_ethernet.onc",
                                 &kNetworkConfigurationSignature,
                                 true)));
 
@@ skipping 162 matching lines @@
                         RepairParams("", "")),
          std::make_pair(OncParams("network-wrong-type",
                                   &kNetworkConfigurationSignature, false),
                         RepairParams("", "")),
          std::make_pair(OncParams("managed-network-wrong-type",
                                   &kNetworkConfigurationSignature, true),
                         RepairParams("", ""))));
 
 }  // namespace onc
 }  // namespace chromeos