wifi_sync: add ability to convert WifiCredential to onc properties

There will be a couple of places where we need to convert from
a WifiCredential, to a DictionaryValue of ONC properties. So let's
put the conversion code someplace where it can be re-used.

The two places we'll need to convert a WifiCredential to ONC
properties will be WifiConfigDelegate and sync integration tests.
Both will need ONC properties to create a network in the
platform-specific network configuration for ChromeOS.

BUG=chromium:431435
TEST=components_unittests --gtest_filter="Wifi*"

Review URL: https://codereview.chromium.org/809803005

Cr-Commit-Position: refs/heads/master@{#310930}

1 files changed, 140 insertions, 0 deletions

diff --git a/components/wifi_sync/wifi_credential_unittest.cc b/components/wifi_sync/wifi_credential_unittest.cc
new file mode 100644
index 0000000..b737217
--- /dev/null
+++ b/components/wifi_sync/wifi_credential_unittest.cc
@@ -0,0 +1,140 @@
+// Copyright 2015 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 "components/wifi_sync/wifi_credential.h"
+
+#include "base/logging.h"
+#include "base/values.h"
+#include "components/onc/onc_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace wifi_sync {
+
+namespace {
+
+const char kSsid[] = "fake-ssid";
+const char kSsidNonUtf8[] = "\xc0";
+const char kPassphraseWep[] = "abcde";
+const char kPassphraseWepNonUtf8[] = "\xc0\xc0\xc0\xc0\xc0";
+const char kPassphrasePsk[] = "fake-psk-passphrase";
+const char kPassphrase8021X[] = "fake-8021X-passphrase";
+
+WifiCredential MakeCredential(const std::string& ssid,
+                              WifiSecurityClass security_class,
+                              const std::string& passphrase) {
+  scoped_ptr<WifiCredential> credential =
+      WifiCredential::Create(
+          WifiCredential::MakeSsidBytesForTest(ssid),
+          security_class,
+          passphrase);
+  CHECK(credential);
+  return *credential;
+}
+
+bool TypeIsWifi(const base::DictionaryValue& onc_properties) {
+  std::string network_type;
+  EXPECT_TRUE(onc_properties.GetString(
+      onc::toplevel_config::kType, &network_type));
+  return network_type == onc::network_type::kWiFi;
+}
+
+std::string GetSsid(const base::DictionaryValue& onc_properties) {
+  std::string ssid;
+  EXPECT_TRUE(onc_properties.GetString(
+      onc::network_config::WifiProperty(onc::wifi::kSSID), &ssid));
+  return ssid;
+}
+
+std::string GetOncSecurity(const base::DictionaryValue& onc_properties) {
+  std::string onc_security;
+  EXPECT_TRUE(onc_properties.GetString(
+      onc::network_config::WifiProperty(onc::wifi::kSecurity), &onc_security));
+  return onc_security;
+}
+
+std::string GetPassphrase(const base::DictionaryValue& onc_properties) {
+  std::string passphrase;
+  EXPECT_TRUE(onc_properties.GetString(
+      onc::network_config::WifiProperty(onc::wifi::kPassphrase), &passphrase));
+  return passphrase;
+}
+
+}  // namespace
+
+TEST(WifiCredentialTest, CreateWithSecurityClassInvalid) {
+  scoped_ptr<WifiCredential> credential =
+      WifiCredential::Create(
+          WifiCredential::MakeSsidBytesForTest(kSsid),
+          SECURITY_CLASS_INVALID,
+          "");
+  EXPECT_FALSE(credential);
+}
+
+TEST(WifiCredentialTest, CreateWithPassphraseNonUtf8) {
+  scoped_ptr<WifiCredential> credential =
+      WifiCredential::Create(
+          WifiCredential::MakeSsidBytesForTest(kSsid),
+          SECURITY_CLASS_WEP,
+          kPassphraseWepNonUtf8);
+  EXPECT_FALSE(credential);
+}
+
+TEST(WifiCredentialTest, ToOncPropertiesSecurityNone) {
+  const WifiCredential credential(
+      MakeCredential(kSsid, SECURITY_CLASS_NONE, ""));
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  ASSERT_TRUE(onc_properties);
+  EXPECT_TRUE(TypeIsWifi(*onc_properties));
+  EXPECT_EQ(kSsid, GetSsid(*onc_properties));
+  EXPECT_EQ(onc::wifi::kSecurityNone, GetOncSecurity(*onc_properties));
+}
+
+TEST(WifiCredentialTest, ToOncPropertiesSecurityWep) {
+  const WifiCredential credential(
+      MakeCredential(kSsid, SECURITY_CLASS_WEP, kPassphraseWep));
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  ASSERT_TRUE(onc_properties);
+  EXPECT_TRUE(TypeIsWifi(*onc_properties));
+  EXPECT_EQ(kSsid, GetSsid(*onc_properties));
+  EXPECT_EQ(onc::wifi::kWEP_PSK, GetOncSecurity(*onc_properties));
+  EXPECT_EQ(kPassphraseWep, GetPassphrase(*onc_properties));
+}
+
+TEST(WifiCredentialTest, ToOncPropertiesSecurityPsk) {
+  const WifiCredential credential(
+      MakeCredential(kSsid, SECURITY_CLASS_PSK, kPassphrasePsk));
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  ASSERT_TRUE(onc_properties);
+  EXPECT_TRUE(TypeIsWifi(*onc_properties));
+  EXPECT_EQ(kSsid, GetSsid(*onc_properties));
+  EXPECT_EQ(onc::wifi::kWPA_PSK, GetOncSecurity(*onc_properties));
+  EXPECT_EQ(kPassphrasePsk, GetPassphrase(*onc_properties));
+}
+
+TEST(WifiCredentialTest, ToOncPropertiesSecurity8021X) {
+  const WifiCredential credential(
+      MakeCredential(kSsid, SECURITY_CLASS_802_1X, kPassphrase8021X));
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  ASSERT_TRUE(onc_properties);
+  EXPECT_TRUE(TypeIsWifi(*onc_properties));
+  EXPECT_EQ(kSsid, GetSsid(*onc_properties));
+  EXPECT_EQ(onc::wifi::kWPA_EAP, GetOncSecurity(*onc_properties));
+  EXPECT_EQ(kPassphrase8021X, GetPassphrase(*onc_properties));
+}
+
+// TODO(quiche): Update this test, once ONC suports non-UTF-8 SSIDs.
+// crbug.com/432546.
+TEST(WifiCredentialTest, ToOncPropertiesSsidNonUtf8) {
+  const WifiCredential credential(
+      MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, ""));
+  scoped_ptr<base::DictionaryValue> onc_properties =
+      credential.ToOncProperties();
+  EXPECT_FALSE(onc_properties);
+}
+
+}  // namespace wifi_sync