Base infrastructure for Networking Private API on Windows and Mac.

chrome/utility/wifi/wifi_service_test.cc

+// 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 "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "chrome/utility/wifi/wifi_service.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace wifi {

[stevenjb, 2013/09/25 19:09:15]

We should be consistent and either use 'namespace wifi' for all of the classes
in this directory, or none. I slightly prefer using the namespace.

[mef, 2013/10/08 21:46:26]

Done.

+
+class WiFiServiceTest : public testing::Test {
+public:
+  void LogError(const std::string& error_name,
+                scoped_ptr<base::DictionaryValue> error_data) {
+    LOG(ERROR) << "WiFi Error: " << error_name;
+    QuitRunLoop();
+  }
+
+  void TestError(const std::string& error_name,
+                 scoped_ptr<base::DictionaryValue> error_data) {
+    LOG(ERROR) << "WiFi Error: " << error_name;
+    FAIL();
+  }
+
+  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 OnNetworksChangedEventWaitingForConnect(
+      const WiFiService::NetworkGuidList& network_guid_list) {
+    LOG(INFO) << "Networks Changed: " << network_guid_list.front();
+    // Check that network is now connected.
+    wifi_service_->GetProperties(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::WaitForConnect, base::Unretained(this)),
+        base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+  }
+
+  void OnNetworkConnectStarted(const std::string& network_guid) {
+    LOG(INFO) << "Started Network Connect:" << network_guid;
+    wifi_service_->SetNetworksChangedObserver(
+        base::Bind(&WiFiServiceTest::OnNetworksChangedEventWaitingForConnect,
+                   base::Unretained(this)));
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::MessageLoop::QuitClosure(),
+        base::TimeDelta::FromSeconds(10));
+  }
+
+  void WaitForConnect(const std::string& network_guid,
+                      const WiFiService::NetworkProperties& properties) {
+    LOG(INFO) << "WaitForConnect" << *properties.ToValue(false).release();
+    if (WiFiService::kConnectionStateConnected == properties.connection_state)
+      QuitRunLoop();
+  }
+
+  void WaitForDisconnect(const std::string& network_guid,
+                         const WiFiService::NetworkProperties& properties) {
+    LOG(INFO) << "WaitForDisconnect" << *properties.ToValue(false).release();
+    EXPECT_EQ(WiFiService::kConnectionStateNotConnected,
+              properties.connection_state);
+  }
+
+  void OnNetworkDisconnectStarted(const std::string& network_guid) {
+    LOG(INFO) << "Started Network Disconnect:" << network_guid;
+    // Check that Network state has changed to 'Not Connected'.
+    wifi_service_->GetProperties(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::WaitForDisconnect, base::Unretained(this)),
+        base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+    // Start connect back to the same network.
+    wifi_service_->StartConnect(
+        connected_network_guid_,
+        base::Bind(&WiFiServiceTest::OnNetworkConnectStarted,
+                   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();
+  }
+
+  void FindConnectedNetwork(const WiFiService::NetworkList& network_list) {
+    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::OnNetworkDisconnectStarted,
+                     base::Unretained(this)),
+          base::Bind(&WiFiServiceTest::TestError, base::Unretained(this)));
+    } else {
+      LOG(INFO) << "No Connected Networks, skipping disconnect.";
+      QuitRunLoop();
+    }
+  }
+
+  void QuitRunLoop() {
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
+  }
+
+private:
+ protected:
+  virtual void SetUp() { wifi_service_.reset(WiFiService::CreateService()); }
+  virtual void TearDown() {}
+
+  std::string connected_network_guid_;
+  scoped_ptr<WiFiService> wifi_service_;
+  base::MessageLoop loop_;
+};
+
+// Test getting properties of network with invalid network guid.
+TEST_F(WiFiServiceTest, GetProperties) {
+  wifi_service_.reset(WiFiService::CreateServiceMock());
+  wifi_service_->GetProperties(
+      "invalid network_guid",
+      base::Bind(&WiFiServiceTest::OnNetworkProperties, base::Unretained(this)),
+      base::Bind(&WiFiServiceTest::LogError, base::Unretained(this)));
+}
+
+// Test getting list of visible networks.
+TEST_F(WiFiServiceTest, GetVisibleNetworks) {
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&WiFiServiceTest::OnVisibleNetworks, base::Unretained(this)),
+      base::Bind(&WiFiServiceTest::LogError, base::Unretained(this)));
+}
+
+// Test that connected WiFi network can be disconnected and reconnected.
+// Disabled to avoid network connection interruption unless enabled explicitly.
+TEST_F(WiFiServiceTest, DISABLED_Reconnect) {
+  base::RunLoop run_loop;
+  wifi_service_->GetVisibleNetworks(
+      base::Bind(&WiFiServiceTest::FindConnectedNetwork,
+                 base::Unretained(this)),
+      base::Bind(&WiFiServiceTest::LogError, base::Unretained(this)));
+  run_loop.Run();
+}
+
+}  // namespace wifi