Reimplement RequestNetworkServiceConnect, RequestRequirePin, RequestEnterPin, RequestEnterPin, Requ…

chrome/browser/chromeos/cros/cros_network_functions_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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_network_functions.h"
 #include "chrome/browser/chromeos/cros/gvalue_util.h"
 #include "chrome/browser/chromeos/cros/mock_chromeos_network.h"
@@ skipping 158 matching lines @@
                                    void* object) {
     OnRequestNetworkProperties2(callback, object);
   }
 
   // Does nothing.  Used as an argument.
   static void OnNetworkAction(void* object,
                               const char* path,
                               NetworkMethodErrorType error,
                               const char* error_message) {}
 
+  // Does nothing.  Used as an argument.
+  static void OnDataPlansUpdate(void* object,
+                                const char* modem_service_path,
+                                const CellularDataPlanList* dataplan) {}
+
+  // Does nothing.  Used as an argument.
+  static void OnSmsReceived(void* object,
+                            const char* modem_device_path,
+                            const SMS* message) {}
+
+
  protected:
   ScopedGValue argument_gvalue_;
   ScopedGHashTable argument_ghash_table_;
   ScopedGHashTable result_ghash_table_;
   base::Callback<void(const char* path,
                       const char* key,
                       const GValue* gvalue)> property_changed_callback_;
 };
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosSetNetworkServiceProperty) {
@@ skipping 160 matching lines @@
   g_value_set_int(gvalue.get(), kValue);
   property_changed_callback_.Run(path.c_str(), key.c_str(), gvalue.get());
 
   // Stop monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               DisconnectNetworkPropertiesMonitor(_)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorCellularDataPlan) {
-  MonitorDataPlanCallback callback =
-      reinterpret_cast<MonitorDataPlanCallback>(42);  // Dummy value.
-  void* object = reinterpret_cast<void*>(84);  // Dummy value.
+  MonitorDataPlanCallback callback = &OnDataPlansUpdate;

[satorux1, 2012/04/24 06:05:55]

maybe safer to add the class name ?

&CrosNetworkFunctionsLibcrosTest::OnDataPlansUpdate

[hashimoto, 2012/04/24 06:57:06]

Done.

+  void* object = this;
 
   // Start monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               MonitorCellularDataPlan(callback, object)).Times(1);
   CrosNetworkWatcher* watcher = CrosMonitorCellularDataPlan(callback, object);
 
   // Stop monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               DisconnectDataPlanUpdateMonitor(_)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorSMS) {
   const std::string modem_device_path = "/modem/device/path";
-  MonitorSMSCallback callback =
-      reinterpret_cast<MonitorSMSCallback>(42);  // Dummy value.
-  void* object = reinterpret_cast<void*>(84);  // Dummy value.
+  MonitorSMSCallback callback = &OnSmsReceived;
+  void* object = this;
 
   // Start monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               MonitorSMS(StrEq(modem_device_path), callback, object))
       .Times(1);
   CrosNetworkWatcher* watcher = CrosMonitorSMS(
       modem_device_path, callback, object);
 
   // Stop monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               DisconnectSMSMonitor(_)).Times(1);
   delete watcher;
 }
 
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkServiceConnect) {
+  const std::string service_path = "service path";
+  void* object = this;

[satorux1, 2012/04/24 06:05:55]

I like this idea. cool

+  EXPECT_CALL(*MockChromeOSNetwork::Get(),
+              RequestNetworkServiceConnect(StrEq(service_path),
+                                           &OnNetworkAction,
+                                           object)).Times(1);
+  CrosRequestNetworkServiceConnect(service_path, &OnNetworkAction, object);
+}
+
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkManagerProperties) {
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
@@ skipping 186 matching lines @@
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkDeviceEnable) {
   const bool kEnable = true;
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               RequestNetworkDeviceEnable(StrEq(flimflam::kTypeWifi), kEnable))
       .Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable);
 }
 
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestRequirePin) {
+  const std::string device_path = "/device/path";
+  const std::string pin = "123456";
+  const bool kEnable = true;
+  void* object = this;
+  EXPECT_CALL(*MockChromeOSNetwork::Get(), RequestRequirePin(
+      StrEq(device_path), StrEq(pin), kEnable, &OnNetworkAction, object))
+      .Times(1);
+  CrosRequestRequirePin(device_path, pin, kEnable, &OnNetworkAction, object);
+}
+
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestEnterPin) {
+  const std::string device_path = "/device/path";
+  const std::string pin = "123456";
+  void* object = this;
+  EXPECT_CALL(*MockChromeOSNetwork::Get(), RequestEnterPin(
+      StrEq(device_path), StrEq(pin), &OnNetworkAction, object)).Times(1);
+  CrosRequestEnterPin(device_path, pin, &OnNetworkAction, object);
+}
+
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestUnblockPin) {
+  const std::string device_path = "/device/path";
+  const std::string unblock_code = "987654";
+  const std::string pin = "123456";
+  void* object = this;
+  EXPECT_CALL(*MockChromeOSNetwork::Get(), RequestUnblockPin(
+      StrEq(device_path), StrEq(unblock_code), StrEq(pin), &OnNetworkAction,
+      object)).Times(1);
+  CrosRequestUnblockPin(device_path, unblock_code, pin, &OnNetworkAction,
+                        object);
+}
+
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestChangePin) {
+  const std::string device_path = "/device/path";
+  const std::string old_pin = "123456";
+  const std::string new_pin = "234567";
+  void* object = this;
+  EXPECT_CALL(*MockChromeOSNetwork::Get(), RequestChangePin(
+      StrEq(device_path), StrEq(old_pin), StrEq(new_pin), &OnNetworkAction,
+      object)).Times(1);
+  CrosRequestChangePin(device_path, old_pin, new_pin, &OnNetworkAction, object);
+}
+
+TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestCellularRegister) {
+  const std::string device_path = "/device/path";
+  const std::string network_id = "networkid";
+  void* object = this;
+  EXPECT_CALL(*MockChromeOSNetwork::Get(), RequestCellularRegister(
+      StrEq(device_path), StrEq(network_id), &OnNetworkAction, object))
+      .Times(1);
+  CrosRequestCellularRegister(device_path, network_id, &OnNetworkAction,
+                              object);
+}
+
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosAddIPConfig) {
   const std::string device_path = "/device/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               AddIPConfig(StrEq(device_path), IPCONFIG_TYPE_DHCP)).Times(1);
   CrosAddIPConfig(device_path, IPCONFIG_TYPE_DHCP);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRemoveIPConfig) {
   IPConfig config = {};
   config.path = "/path";
@@ skipping 106 matching lines @@
   }
 
   // Handles responses for GetEntry method calls.
   void OnGetEntry(
       const dbus::ObjectPath& profile_path,
       const std::string& entry_path,
       const FlimflamClientHelper::DictionaryValueCallback& callback) {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
   }
 
+  // Mock NetworkActionCallback.
+  MOCK_METHOD4(MockNetworkActionCallback, void(void* object,
+                                               const char* path,
+                                               NetworkMethodErrorType error,
+                                               const char* error_message));
+  static void MockNetworkActionCallbackThunk(void* object,
+                                             const char* path,
+                                             NetworkMethodErrorType error,
+                                             const char* error_message) {
+    static_cast<CrosNetworkFunctionsTest*>(object)->MockNetworkActionCallback(
+        object, path, error, error_message);
+  }
+
  protected:
   MockCashewClient* mock_cashew_client_;
   MockFlimflamDeviceClient* mock_device_client_;
   MockFlimflamIPConfigClient* mock_ipconfig_client_;
   MockFlimflamManagerClient* mock_manager_client_;
   MockFlimflamProfileClient* mock_profile_client_;
   MockFlimflamServiceClient* mock_service_client_;
   const base::DictionaryValue* dictionary_value_result_;
 };
 
@@ skipping 358 matching lines @@
   EXPECT_CALL(*mock_manager_client_,
               EnableTechnology(flimflam::kTypeWifi, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable);
 
   const bool kDisable = false;
   EXPECT_CALL(*mock_manager_client_,
               DisableTechnology(flimflam::kTypeWifi, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kDisable);
 }
 
+TEST_F(CrosNetworkFunctionsTest, CrosRequestRequirePin) {
+  const std::string device_path = "/device/path";
+  const std::string pin = "123456";
+  const bool kRequire = true;
+  void* object = this;
+
+  // Set expectations.
+  base::Closure callback;
+  EXPECT_CALL(*mock_device_client_,
+              RequirePin(dbus::ObjectPath(device_path), pin, kRequire, _, _))
+      .WillOnce(SaveArg<3>(&callback));
+  EXPECT_CALL(*this, MockNetworkActionCallback(
+      object, StrEq(device_path), NETWORK_METHOD_ERROR_NONE, _)).Times(1);
+  CrosRequestRequirePin(device_path, pin, kRequire,
+                        &MockNetworkActionCallbackThunk, this);
+  // Run saved callback.
+  callback.Run();
+}
+
+TEST_F(CrosNetworkFunctionsTest, CrosRequestEnterPin) {
+  const std::string device_path = "/device/path";
+  const std::string pin = "123456";
+  void* object = this;
+
+  // Set expectations.
+  base::Closure callback;
+  EXPECT_CALL(*mock_device_client_,
+              EnterPin(dbus::ObjectPath(device_path), pin, _, _))
+      .WillOnce(SaveArg<2>(&callback));
+  EXPECT_CALL(*this, MockNetworkActionCallback(
+      object, StrEq(device_path), NETWORK_METHOD_ERROR_NONE, _)).Times(1);
+  CrosRequestEnterPin(device_path, pin, &MockNetworkActionCallbackThunk, this);
+  // Run saved callback.
+  callback.Run();
+}
+
+TEST_F(CrosNetworkFunctionsTest, CrosRequestUnblockPin) {
+  const std::string device_path = "/device/path";
+  const std::string unblock_code = "987654";
+  const std::string pin = "123456";
+  void* object = this;
+
+  // Set expectations.
+  base::Closure callback;
+  EXPECT_CALL(
+      *mock_device_client_,
+      UnblockPin(dbus::ObjectPath(device_path), unblock_code, pin, _, _))
+      .WillOnce(SaveArg<3>(&callback));
+  EXPECT_CALL(*this, MockNetworkActionCallback(
+      object, StrEq(device_path), NETWORK_METHOD_ERROR_NONE, _)).Times(1);
+  CrosRequestUnblockPin(device_path, unblock_code, pin,
+                        &MockNetworkActionCallbackThunk, object);
+  // Run saved callback.
+  callback.Run();
+}
+
+TEST_F(CrosNetworkFunctionsTest, CrosRequestChangePin) {
+  const std::string device_path = "/device/path";
+  const std::string old_pin = "123456";
+  const std::string new_pin = "234567";
+  void* object = this;
+
+  // Set expectations.
+  base::Closure callback;
+  EXPECT_CALL(*mock_device_client_,
+              ChangePin(dbus::ObjectPath(device_path), old_pin, new_pin,  _, _))
+      .WillOnce(SaveArg<3>(&callback));
+  EXPECT_CALL(*this, MockNetworkActionCallback(
+      object, StrEq(device_path), NETWORK_METHOD_ERROR_NONE, _)).Times(1);
+  CrosRequestChangePin(device_path, old_pin, new_pin,
+                       &MockNetworkActionCallbackThunk, object);
+  // Run saved callback.
+  callback.Run();
+}
+
+TEST_F(CrosNetworkFunctionsTest, CrosRequestCellularRegister) {
+  const std::string device_path = "/device/path";
+  const std::string network_id = "networkid";
+  void* object = this;
+
+  // Set expectations.
+  base::Closure callback;
+  EXPECT_CALL(*mock_device_client_,
+              Register(dbus::ObjectPath(device_path), network_id, _, _))
+      .WillOnce(SaveArg<2>(&callback));
+  EXPECT_CALL(*this, MockNetworkActionCallback(
+      object, StrEq(device_path), NETWORK_METHOD_ERROR_NONE, _)).Times(1);
+  CrosRequestCellularRegister(device_path, network_id,
+                              &MockNetworkActionCallbackThunk, object);
+  // Run saved callback.
+  callback.Run();
+}
+
 TEST_F(CrosNetworkFunctionsTest, CrosAddIPConfig) {
   const std::string device_path = "/device/path";
   const dbus::ObjectPath result_path("/result/path");
   EXPECT_CALL(*mock_device_client_,
               CallAddIPConfigAndBlock(dbus::ObjectPath(device_path),
                                       flimflam::kTypeDHCP))
       .WillOnce(Return(result_path));
   EXPECT_TRUE(CrosAddIPConfig(device_path, IPCONFIG_TYPE_DHCP));
 }
 
@@ skipping 12 matching lines @@
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   EXPECT_CALL(*mock_manager_client_, ConfigureService(IsEqualTo(&value), _))
       .Times(1);
   CrosConfigureService(value);
 }
 
 }  // namespace chromeos