Add new shill client for VPN

chromeos/dbus/shill_client_unittest_base.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/dbus/shill_client_unittest_base.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
+#include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/network/shill_property_util.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
+// TODO(kaliamoorthi): Remove inclusion of shill_third_party_vpn_driver_client
+// after the string constants in it are moved to service_constants.h
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace chromeos {
 
 namespace {
 
 // Pops a string-to-string dictionary from the reader.
@@ skipping 65 matching lines @@
 ShillClientUnittestBase::MockErrorCallback::MockErrorCallback() {}
 
 ShillClientUnittestBase::MockErrorCallback::~MockErrorCallback() {}
 
 ShillClientUnittestBase::MockPropertyChangeObserver::
   MockPropertyChangeObserver() {}
 
 ShillClientUnittestBase::MockPropertyChangeObserver::
   ~MockPropertyChangeObserver() {}
 
+ShillClientUnittestBase::MockShillThirdPartyVpnObserver::
+    MockShillThirdPartyVpnObserver() {}
+
+ShillClientUnittestBase::MockShillThirdPartyVpnObserver::
+    ~MockShillThirdPartyVpnObserver() {}
+
 ShillClientHelper::ErrorCallback
 ShillClientUnittestBase::MockErrorCallback::GetCallback() {
   return base::Bind(&MockErrorCallback::Run, base::Unretained(this));
 }
 
 
 ShillClientUnittestBase::ShillClientUnittestBase(
     const std::string& interface_name,
     const dbus::ObjectPath& object_path)
     : interface_name_(interface_name),
@@ skipping 21 matching lines @@
   EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _))
       .WillRepeatedly(Invoke(this, &ShillClientUnittestBase::OnCallMethod));
 
   // Set an expectation so mock_proxy's CallMethodWithErrorCallback() will use
   // OnCallMethodWithErrorCallback() to return responses.
   EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _))
       .WillRepeatedly(Invoke(
            this, &ShillClientUnittestBase::OnCallMethodWithErrorCallback));
 
   // Set an expectation so mock_proxy's ConnectToSignal() will use
-  // OnConnectToSignal() to run the callback.
+  // OnConnectToPropertyChanged() to run the callback.
   EXPECT_CALL(
       *mock_proxy_.get(),
       ConnectToSignal(interface_name_, shill::kMonitorPropertyChanged, _, _))
       .WillRepeatedly(
-           Invoke(this, &ShillClientUnittestBase::OnConnectToSignal));
+           Invoke(this, &ShillClientUnittestBase::OnConnectToPropertyChanged));
+
+  EXPECT_CALL(
+      *mock_proxy_.get(),
+      ConnectToSignal(interface_name_, shill::kOnPlatformMessageFunction, _, _))
+      .WillRepeatedly(
+          Invoke(this, &ShillClientUnittestBase::OnConnectToPlatformMessage));
+
+  EXPECT_CALL(
+      *mock_proxy_.get(),
+      ConnectToSignal(interface_name_, shill::kOnPacketReceivedFunction, _, _))
+      .WillRepeatedly(
+          Invoke(this, &ShillClientUnittestBase::OnConnectToPacketReceieved));
 
   // Set an expectation so mock_bus's GetObjectProxy() for the given
   // service name and the object path will return mock_proxy_.
   EXPECT_CALL(*mock_bus_.get(),
               GetObjectProxy(shill::kFlimflamServiceName, object_path_))
       .WillOnce(Return(mock_proxy_.get()));
 
   // Set an expectation so mock_bus's GetDBusTaskRunner will return the current
   // task runner.
   EXPECT_CALL(*mock_bus_.get(), GetDBusTaskRunner())
       .WillRepeatedly(Return(message_loop_.message_loop_proxy().get()));
 
   // ShutdownAndBlock() will be called in TearDown().
   EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 }
 
 void ShillClientUnittestBase::TearDown() {
   mock_bus_->ShutdownAndBlock();
 }
 
 void ShillClientUnittestBase::PrepareForMethodCall(
     const std::string& method_name,
     const ArgumentCheckCallback& argument_checker,
     dbus::Response* response) {
   expected_method_name_ = method_name;
   argument_checker_ = argument_checker;
   response_ = response;
 }
 
+void ShillClientUnittestBase::SendPlatformMessageSignal(
+    dbus::Signal* signal) {
+  ASSERT_FALSE(platform_message_handler_.is_null());
+  platform_message_handler_.Run(signal);
+}
+
+void ShillClientUnittestBase::SendPacketReceievedSignal(
+    dbus::Signal* signal) {
+  ASSERT_FALSE(packet_receieved__handler_.is_null());
+  packet_receieved__handler_.Run(signal);
+}
+
 void ShillClientUnittestBase::SendPropertyChangedSignal(
     dbus::Signal* signal) {
   ASSERT_FALSE(property_changed_handler_.is_null());
   property_changed_handler_.Run(signal);
 }
 
 // static
 void ShillClientUnittestBase::ExpectPropertyChanged(
     const std::string& expected_name,
     const base::Value* expected_value,
     const std::string& name,
     const base::Value& value) {
   EXPECT_EQ(expected_name, name);
   EXPECT_TRUE(expected_value->Equals(&value));
 }
 
 // static
 void ShillClientUnittestBase::ExpectNoArgument(dbus::MessageReader* reader) {
   EXPECT_FALSE(reader->HasMoreData());
 }
 
 // static
+void ShillClientUnittestBase::ExpectUint32Argument(
+    uint32 expected_value,
+    dbus::MessageReader* reader) {
+  uint32 value;
+  ASSERT_TRUE(reader->PopUint32(&value));
+  EXPECT_EQ(expected_value, value);
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
+void ShillClientUnittestBase::ExpectArrayOfBytesArgument(
+    const std::vector<uint8>& expected_bytes,
+    dbus::MessageReader* reader) {
+  const uint8* bytes;
+  size_t size;
+  ASSERT_TRUE(reader->PopArrayOfBytes(&bytes, &size));
+  EXPECT_EQ(expected_bytes.size(), size);
+  for (size_t i = 0; i < size; ++i) {
+    EXPECT_EQ(expected_bytes[i], bytes[i]);
+  }
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
 void ShillClientUnittestBase::ExpectStringArgument(
     const std::string& expected_string,
     dbus::MessageReader* reader) {
   std::string str;
   ASSERT_TRUE(reader->PopString(&str));
   EXPECT_EQ(expected_string, str);
   EXPECT_FALSE(reader->HasMoreData());
 }
 
 // static
@@ skipping 26 matching lines @@
   EXPECT_EQ(expected_string, str);
   scoped_ptr<base::Value> value(dbus::PopDataAsValue(reader));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(value->Equals(expected_value));
   EXPECT_FALSE(reader->HasMoreData());
 }
 
 // static
 void ShillClientUnittestBase::ExpectDictionaryValueArgument(
     const base::DictionaryValue* expected_dictionary,
+    bool string_valued,
     dbus::MessageReader* reader) {
   dbus::MessageReader array_reader(NULL);
   ASSERT_TRUE(reader->PopArray(&array_reader));
   while (array_reader.HasMoreData()) {
     dbus::MessageReader entry_reader(NULL);
     ASSERT_TRUE(array_reader.PopDictEntry(&entry_reader));
     std::string key;
     ASSERT_TRUE(entry_reader.PopString(&key));
+    if (string_valued) {
+      std::string value;
+      std::string expected_value;
+      ASSERT_TRUE(entry_reader.PopString(&value));
+      EXPECT_TRUE(expected_dictionary->GetStringWithoutPathExpansion(
+          key, &expected_value));
+      EXPECT_EQ(expected_value, value);
+      continue;
+    }
     dbus::MessageReader variant_reader(NULL);
     ASSERT_TRUE(entry_reader.PopVariant(&variant_reader));
     scoped_ptr<base::Value> value;
     // Variants in the dictionary can be basic types or string-to-string
     // dictinoary.
     switch (variant_reader.GetDataType()) {
       case dbus::Message::ARRAY:
         value.reset(PopStringToStringDictionary(&variant_reader));
         break;
       case dbus::Message::BOOL:
@@ skipping 79 matching lines @@
 
 // static
 void ShillClientUnittestBase::ExpectDictionaryValueResult(
     const base::DictionaryValue* expected_result,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& result) {
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
   ExpectDictionaryValueResultWithoutStatus(expected_result, result);
 }
 
-void ShillClientUnittestBase::OnConnectToSignal(
+void ShillClientUnittestBase::OnConnectToPlatformMessage(
     const std::string& interface_name,
     const std::string& signal_name,
     const dbus::ObjectProxy::SignalCallback& signal_callback,
+    const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
+  platform_message_handler_ = signal_callback;
+  const bool success = true;
+  message_loop_.PostTask(FROM_HERE,
+                         base::Bind(on_connected_callback,
+                                    interface_name,
+                                    signal_name,
+                                    success));
+}
+
+void ShillClientUnittestBase::OnConnectToPacketReceieved(
+    const std::string& interface_name,
+    const std::string& signal_name,
+    const dbus::ObjectProxy::SignalCallback& signal_callback,
+    const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
+  packet_receieved__handler_ = signal_callback;
+  const bool success = true;
+  message_loop_.PostTask(FROM_HERE,
+                         base::Bind(on_connected_callback,
+                                    interface_name,
+                                    signal_name,
+                                    success));
+}
+
+void ShillClientUnittestBase::OnConnectToPropertyChanged(
+    const std::string& interface_name,
+    const std::string& signal_name,
+    const dbus::ObjectProxy::SignalCallback& signal_callback,
     const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
   property_changed_handler_ = signal_callback;
   const bool success = true;
   message_loop_.PostTask(FROM_HERE,
                          base::Bind(on_connected_callback,
                                     interface_name,
                                     signal_name,
                                     success));
 }
 
@@ skipping 11 matching lines @@
 
 void ShillClientUnittestBase::OnCallMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     int timeout_ms,
     const dbus::ObjectProxy::ResponseCallback& response_callback,
     const dbus::ObjectProxy::ErrorCallback& error_callback) {
   OnCallMethod(method_call, timeout_ms, response_callback);
 }
 
 }  // namespace chromeos