Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/wifi/wifi_service_test.cc

Index: chrome/utility/wifi/wifi_service_test.cc
diff --git a/chrome/utility/wifi/wifi_service_test.cc b/chrome/utility/wifi/wifi_service_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3e02b513e0e014ca77e06800e944f1b40bb41057
--- /dev/null
+++ b/chrome/utility/wifi/wifi_service_test.cc
@@ -0,0 +1,118 @@
+// Copyright 2013 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 "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/logging.h"
+#include "chrome/utility/wifi/wifi_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace wifi {
+
+namespace {
+
+class WiFiServiceTest : public testing::Test {
+
+ protected:
+  virtual void SetUp() { wifi_service_.reset(WiFiService::CreateService()); }
+
+  virtual void TearDown() {}
+
+ public:
+
+  void LogError(const std::string& error_name,
+                scoped_ptr<base::DictionaryValue> error_data) {
+    LOG(ERROR) << "WiFi Error: " << error_name;
+  }
+
+  void TestError(const std::string& error_name,
+                 scoped_ptr<base::DictionaryValue> error_data) {
+    LOG(ERROR) << "WiFi Error: " << error_name;
+    EXPECT_TRUE(false);
+  }
+
+  void OnDictionaryResult(const std::string& network_guid,
+                          const base::DictionaryValue& dictionary) {}
+
+  void OnNetworkProperties(const std::string& network_guid,
+                           const WiFiService::NetworkProperties& properties) {
+    LOG(INFO) << "OnNetworkProperties" << *properties.ToValue(false).release();
+  }
+
+  void OnNetworkConnected(const std::string& network_guid) {
+    LOG(INFO) << "Connected Network:" << network_guid;
+    wifi_service_->GetProperties(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::CheckNetworkState,
+                   base::Unretained(this),
+                   WiFiService::kConnectionStateConnected),
+        base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+  }
+
+  void CheckNetworkState(WiFiService::ConnectionState expected_state,
+                         const std::string& network_guid,
+                         const WiFiService::NetworkProperties& properties) {
+    LOG(INFO) << "CheckNetworkState" << *properties.ToValue(false).release();
+    EXPECT_EQ(expected_state, properties.connection_state);
+  }
+
+  void OnNetworkDisconnected(const std::string& network_guid) {
+    LOG(INFO) << "Disconnected Network:" << network_guid;
+    wifi_service_->GetProperties(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::CheckNetworkState,
+                   base::Unretained(this),
+                   WiFiService::kConnectionStateNotConnected),
+        base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+
+    wifi_service_->StartConnect(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::OnNetworkConnected,
+                   base::Unretained(this)),
+        base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+  }
+
+  void OnVisibleNetworks(const WiFiService::NetworkList& network_list) {
+    LOG(INFO) << "Visible WiFi Networks: " << network_list.size();
+    for (WiFiService::NetworkList::const_iterator net = network_list.begin();
+         net != network_list.end();
+         ++net) {
+      if (net->connection_state == WiFiService::kConnectionStateConnected) {
+        connected_network_guid_ = net->guid;
+        LOG(INFO) << "Connected Network:\n" << *(net->ToValue(false).release());
+      }
+    }
+
+    if (!connected_network_guid_.empty()) {
+      wifi_service_->StartDisconnect(
+          connected_network_guid_,
+          base::Bind(&WiFiServiceTest::OnNetworkDisconnected,
+                     base::Unretained(this)),
+          base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+    } else {
+      LOG(INFO) << "No Connected Networks, skipping disconnect.";
+    }
+  }
+
+  std::string connected_network_guid_;
+  scoped_ptr<WiFiService> wifi_service_;
+};
+
+TEST_F(WiFiServiceTest, GetProperties) {
+  wifi_service_.reset(WiFiService::CreateServiceMock());
+  wifi_service_->GetProperties(
+      "network_guid",
+      base::Bind(&WiFiServiceTest::OnNetworkProperties, base::Unretained(this)),
+      base::Bind(&WiFiServiceTest::LogError, base::Unretained(this)));
+}
+
+TEST_F(WiFiServiceTest, Reconnect) {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&WiFiServiceTest::OnVisibleNetworks, base::Unretained(this)),
+      base::Bind(&WiFiServiceTest::LogError, base::Unretained(this)));
+}
+
+}  // namespace
+
+}  // namespace wifi