chromeos/dbus/shill_third_party_vpn_driver_client_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/bind.h"
   8 #include "base/stl_util.h"
   9 #include "chromeos/dbus/shill_client_unittest_base.h"
  10 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
  11 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
  12 #include "third_party/cros_system_api/dbus/service_constants.h"
  13
  14 using testing::_;
  15
  16 namespace chromeos {
  17
  18 namespace {
  19
  20 const char kExampleIPConfigPath[] = "/foo/bar";
  21
  22 class MockShillThirdPartyVpnObserver : public ShillThirdPartyVpnObserver {
  23  public:
  24   MockShillThirdPartyVpnObserver() {}
  25   ~MockShillThirdPartyVpnObserver() override {}
  26   MOCK_METHOD1(OnPacketReceived, void(const std::vector<char>& data));
  27   MOCK_METHOD1(OnPlatformMessage, void(uint32_t message));
  28 };
  29
  30 }  // namespace
  31
  32 class ShillThirdPartyVpnDriverClientTest : public ShillClientUnittestBase {
  33  public:
  34   ShillThirdPartyVpnDriverClientTest()
  35       : ShillClientUnittestBase(shill::kFlimflamThirdPartyVpnInterface,
  36                                 dbus::ObjectPath(kExampleIPConfigPath)) {}
  37
  38   void SetUp() override {
  39     ShillClientUnittestBase::SetUp();
  40
  41     // Create a client with the mock bus.
  42     client_.reset(ShillThirdPartyVpnDriverClient::Create());
  43     client_->Init(mock_bus_.get());
  44     // Run the message loop to run the signal connection result callback.
  45     message_loop_.RunUntilIdle();
  46   }
  47
  48   void TearDown() override { ShillClientUnittestBase::TearDown(); }
  49
  50   MOCK_METHOD0(MockSuccess, void());
  51   static void Failure(const std::string& error_name,
  52                       const std::string& error_message) {
  53     ADD_FAILURE() << error_name << ": " << error_message;
  54   }
  55
  56  protected:
  57   scoped_ptr<ShillThirdPartyVpnDriverClient> client_;
  58 };
  59
  60 TEST_F(ShillThirdPartyVpnDriverClientTest, PlatformSignal) {
  61   uint32_t connected_state = 123456;
  62   const size_t kPacketSize = 5;
  63   std::vector<char> data_packet(kPacketSize, 1);
  64   dbus::Signal pmessage_signal(shill::kFlimflamThirdPartyVpnInterface,
  65                                shill::kOnPlatformMessageFunction);
  66   {
  67     dbus::MessageWriter writer(&pmessage_signal);
  68     writer.AppendUint32(connected_state);
  69   }
  70
  71   dbus::Signal preceived_signal(shill::kFlimflamThirdPartyVpnInterface,
  72                                 shill::kOnPacketReceivedFunction);
  73   {
  74     dbus::MessageWriter writer(&preceived_signal);
  75     writer.AppendArrayOfBytes(
  76         reinterpret_cast<const uint8_t*>(vector_as_array(&data_packet)),
  77         data_packet.size());
  78   }
  79
  80   // Expect each signal to be triggered once.
  81   MockShillThirdPartyVpnObserver observer;
  82   EXPECT_CALL(observer, OnPlatformMessage(connected_state)).Times(1);
  83   EXPECT_CALL(observer, OnPacketReceived(data_packet)).Times(1);
  84
  85   client_->AddShillThirdPartyVpnObserver(kExampleIPConfigPath, &observer);
  86
  87   // Run the signal callback.
  88   SendPlatformMessageSignal(&pmessage_signal);
  89   SendPacketReceievedSignal(&preceived_signal);
  90
  91   testing::Mock::VerifyAndClearExpectations(&observer);
  92
  93   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  94   uint32_t connection_state = 2;
  95
  96   PrepareForMethodCall(shill::kUpdateConnectionStateFunction,
  97                        base::Bind(&ExpectUint32Argument, connection_state),
  98                        response.get());
  99
 100   EXPECT_CALL(*this, MockSuccess()).Times(0);
 101   client_->UpdateConnectionState(
 102       kExampleIPConfigPath, connection_state,
 103       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
 104                  base::Unretained(this)),
 105       base::Bind(&Failure));
 106
 107   client_->RemoveShillThirdPartyVpnObserver(kExampleIPConfigPath);
 108   testing::Mock::VerifyAndClearExpectations(this);
 109
 110   EXPECT_CALL(*this, MockSuccess()).Times(1);
 111
 112   // Check after removing the observer that there is no further signals.
 113   EXPECT_CALL(observer, OnPlatformMessage(connected_state)).Times(0);
 114   EXPECT_CALL(observer, OnPacketReceived(data_packet)).Times(0);
 115
 116   // Run the signal callback.
 117   SendPlatformMessageSignal(&pmessage_signal);
 118   SendPacketReceievedSignal(&preceived_signal);
 119
 120   testing::Mock::VerifyAndClearExpectations(&observer);
 121
 122   message_loop_.RunUntilIdle();
 123 }
 124
 125 TEST_F(ShillThirdPartyVpnDriverClientTest, SetParameters) {
 126   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 127
 128   base::DictionaryValue parameters;
 129   const std::string kAddress("1.1.1.1");
 130   parameters.SetStringWithoutPathExpansion(
 131       shill::kAddressParameterThirdPartyVpn, kAddress);
 132
 133   EXPECT_CALL(*this, MockSuccess()).Times(1);
 134
 135   PrepareForMethodCall(
 136       shill::kSetParametersFunction,
 137       base::Bind(&ExpectDictionaryValueArgument, &parameters, true),
 138       response.get());
 139
 140   client_->SetParameters(
 141       kExampleIPConfigPath, parameters,
 142       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
 143                  base::Unretained(this)),
 144       base::Bind(&Failure));
 145
 146   message_loop_.RunUntilIdle();
 147 }
 148
 149 TEST_F(ShillThirdPartyVpnDriverClientTest, UpdateConnectionState) {
 150   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 151   uint32_t connection_state = 2;
 152
 153   EXPECT_CALL(*this, MockSuccess()).Times(1);
 154
 155   PrepareForMethodCall(shill::kUpdateConnectionStateFunction,
 156                        base::Bind(&ExpectUint32Argument, connection_state),
 157                        response.get());
 158
 159   client_->UpdateConnectionState(
 160       kExampleIPConfigPath, connection_state,
 161       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
 162                  base::Unretained(this)),
 163       base::Bind(&Failure));
 164
 165   message_loop_.RunUntilIdle();
 166 }
 167
 168 TEST_F(ShillThirdPartyVpnDriverClientTest, SendPacket) {
 169   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 170
 171   const size_t kPacketSize = 5;
 172   const std::vector<char> data(kPacketSize, 0);
 173
 174   EXPECT_CALL(*this, MockSuccess()).Times(1);
 175
 176   PrepareForMethodCall(shill::kSendPacketFunction,
 177                        base::Bind(&ExpectArrayOfBytesArgument,
 178                                   std::string(data.begin(), data.end())),
 179                        response.get());
 180
 181   client_->SendPacket(
 182       kExampleIPConfigPath, data,
 183       base::Bind(&ShillThirdPartyVpnDriverClientTest::MockSuccess,
 184                  base::Unretained(this)),
 185       base::Bind(&Failure));
 186
 187   message_loop_.RunUntilIdle();
 188 }
 189
 190 }  // namespace chromeos