third_party_vpn_driver_unittest.cc revision 2240e8c03451c6b6f21eb8944d8a1c0747ac10b3 
1// Copyright 2014 The Chromium OS 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 "shill/vpn/third_party_vpn_driver.h"
6
7#include <gtest/gtest.h>
8
9#include "shill/mock_adaptors.h"
10#include "shill/mock_device_info.h"
11#include "shill/mock_event_dispatcher.h"
12#include "shill/mock_file_io.h"
13#include "shill/mock_glib.h"
14#include "shill/mock_manager.h"
15#include "shill/mock_metrics.h"
16#include "shill/mock_service.h"
17#include "shill/mock_store.h"
18#include "shill/mock_virtual_device.h"
19#include "shill/nice_mock_control.h"
20#include "shill/vpn/mock_vpn_service.h"
21
22using testing::_;
23using testing::Mock;
24using testing::NiceMock;
25using testing::Return;
26using testing::SetArgumentPointee;
27
28namespace shill {
29
30class ThirdPartyVpnDriverTest : public testing::Test {
31 public:
32  ThirdPartyVpnDriverTest()
33      : device_info_(&control_, &dispatcher_, &metrics_, &manager_),
34        metrics_(&dispatcher_),
35        manager_(&control_, &dispatcher_, &metrics_, &glib_),
36        driver_(new ThirdPartyVpnDriver(&control_, &dispatcher_, &metrics_,
37                                        &manager_, &device_info_)),
38        adaptor_interface_(new ThirdPartyVpnMockAdaptor()),
39        service_(new MockVPNService(&control_, &dispatcher_, &metrics_,
40                                    &manager_, driver_)),
41        device_(new MockVirtualDevice(&control_, &dispatcher_, &metrics_,
42                                      &manager_, kInterfaceName,
43                                      kInterfaceIndex, Technology::kVPN)) {}
44
45  virtual ~ThirdPartyVpnDriverTest() {}
46
47  virtual void SetUp() {
48    driver_->adaptor_interface_.reset(adaptor_interface_);
49    driver_->file_io_ = &mock_file_io_;
50  }
51
52  virtual void TearDown() {
53    driver_->device_ = nullptr;
54    driver_->service_ = nullptr;
55    driver_->file_io_ = nullptr;
56  }
57
58 protected:
59  static const char kConfigName[];
60  static const char kInterfaceName[];
61  static const int kInterfaceIndex;
62
63  NiceMockControl control_;
64  NiceMock<MockDeviceInfo> device_info_;
65  MockEventDispatcher dispatcher_;
66  MockMetrics metrics_;
67  MockFileIO mock_file_io_;
68  MockGLib glib_;
69  MockManager manager_;
70  ThirdPartyVpnDriver *driver_;                  // Owned by |service_|
71  ThirdPartyVpnMockAdaptor *adaptor_interface_;  // Owned by |driver_|
72  scoped_refptr<MockVPNService> service_;
73  scoped_refptr<MockVirtualDevice> device_;
74};
75
76const char ThirdPartyVpnDriverTest::kConfigName[] = "default-1";
77const char ThirdPartyVpnDriverTest::kInterfaceName[] = "tun0";
78const int ThirdPartyVpnDriverTest::kInterfaceIndex = 123;
79
80TEST_F(ThirdPartyVpnDriverTest, ConnectAndDisconnect) {
81  const std::string interface = kInterfaceName;
82  IOHandler *io_handler = new IOHandler();  // Owned by |driver_|
83  int fd = 1;
84
85  EXPECT_CALL(*service_, SetState(Service::kStateConfiguring)).Times(1);
86  EXPECT_CALL(device_info_, CreateTunnelInterface(_))
87      .WillOnce(DoAll(SetArgumentPointee<0>(interface), Return(true)));
88  Error error;
89  driver_->Connect(service_, &error);
90  EXPECT_TRUE(error.IsSuccess());
91  EXPECT_EQ(kInterfaceName, driver_->tunnel_interface_);
92  EXPECT_TRUE(driver_->IsConnectTimeoutStarted());
93
94  EXPECT_CALL(device_info_, OpenTunnelInterface(interface))
95      .WillOnce(Return(fd));
96  EXPECT_CALL(dispatcher_, CreateInputHandler(fd, _, _))
97      .WillOnce(Return(io_handler));
98  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
99                                       ThirdPartyVpnDriver::kConnected)));
100  EXPECT_FALSE(driver_->ClaimInterface("eth1", kInterfaceIndex));
101  EXPECT_TRUE(driver_->ClaimInterface(interface, kInterfaceIndex));
102  EXPECT_EQ(driver_->active_client_, driver_);
103  EXPECT_TRUE(driver_->parameters_expected_);
104  EXPECT_EQ(driver_->io_handler_.get(), io_handler);
105  ASSERT_TRUE(driver_->device_);
106  EXPECT_EQ(kInterfaceIndex, driver_->device_->interface_index());
107
108  EXPECT_CALL(*service_, SetState(Service::kStateIdle)).Times(1);
109  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
110                                       ThirdPartyVpnDriver::kDisconnected)));
111  EXPECT_CALL(mock_file_io_, Close(fd));
112  driver_->Disconnect();
113  EXPECT_EQ(driver_->io_handler_.get(), nullptr);
114}
115
116TEST_F(ThirdPartyVpnDriverTest, SendPacket) {
117  int fd = 1;
118  std::string error;
119  std::vector<uint8_t> ip_packet(5, 0);
120  driver_->SendPacket(ip_packet, &error);
121  EXPECT_EQ(error, "Unexpected call");
122
123  error.clear();
124  ThirdPartyVpnDriver::active_client_ = driver_;
125  driver_->SendPacket(ip_packet, &error);
126  EXPECT_EQ(error, "Device not open");
127
128  driver_->tun_fd_ = fd;
129  error.clear();
130  EXPECT_CALL(mock_file_io_, Write(fd, ip_packet.data(), ip_packet.size()))
131      .WillOnce(Return(ip_packet.size() - 1));
132  EXPECT_CALL(
133      *adaptor_interface_,
134      EmitPlatformMessage(static_cast<uint32_t>(ThirdPartyVpnDriver::kError)));
135  driver_->SendPacket(ip_packet, &error);
136  EXPECT_EQ(error, "Partial write");
137
138  error.clear();
139  EXPECT_CALL(mock_file_io_, Write(fd, ip_packet.data(), ip_packet.size()))
140      .WillOnce(Return(ip_packet.size()));
141  driver_->SendPacket(ip_packet, &error);
142  EXPECT_TRUE(error.empty());
143
144  driver_->tun_fd_ = -1;
145
146  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
147                                       ThirdPartyVpnDriver::kDisconnected)));
148}
149
150TEST_F(ThirdPartyVpnDriverTest, UpdateConnectionState) {
151  std::string error;
152  driver_->UpdateConnectionState(Service::kStateConfiguring, &error);
153  EXPECT_EQ(error, "Unexpected call");
154
155  error.clear();
156  ThirdPartyVpnDriver::active_client_ = driver_;
157  driver_->UpdateConnectionState(Service::kStateConfiguring, &error);
158  EXPECT_EQ(error, "Invalid argument");
159
160  error.clear();
161  driver_->service_ = service_;
162  EXPECT_CALL(*service_, SetState(Service::kStateConnected)).Times(1);
163  driver_->UpdateConnectionState(Service::kStateConnected, &error);
164  EXPECT_TRUE(error.empty());
165}
166
167TEST_F(ThirdPartyVpnDriverTest, SetParameters) {
168  std::map<std::string, std::string> parameters;
169  std::string error;
170  driver_->SetParameters(parameters, &error);
171  EXPECT_EQ(error, "Unexpected call");
172
173  error.clear();
174  ThirdPartyVpnDriver::active_client_ = driver_;
175  driver_->parameters_expected_ = true;
176  driver_->SetParameters(parameters, &error);
177  EXPECT_EQ(error,
178            "address is missing;subnet_prefix is missing;"
179            "dns_servers is missing;bypass_tunnel_for_ip is missing;");
180
181  error.clear();
182  parameters["address"] = "1234.1.1.1";
183  driver_->SetParameters(parameters, &error);
184  EXPECT_EQ(error,
185            "address is not a valid IP;subnet_prefix is missing;"
186            "dns_servers is missing;bypass_tunnel_for_ip is missing;");
187
188  error.clear();
189  parameters["address"] = "123.211.21.18";
190  driver_->SetParameters(parameters, &error);
191  EXPECT_EQ(error,
192            "subnet_prefix is missing;dns_servers is missing;"
193            "bypass_tunnel_for_ip is missing;");
194
195  error.clear();
196  parameters["bypass_tunnel_for_ip"] = "1234.1.1.1";
197  driver_->SetParameters(parameters, &error);
198  EXPECT_EQ(error,
199            "subnet_prefix is missing;dns_servers is missing;"
200            "bypass_tunnel_for_ip has no valid values or is empty;");
201
202  error.clear();
203  parameters["bypass_tunnel_for_ip"] = "123.211.21.18";
204  driver_->SetParameters(parameters, &error);
205  EXPECT_EQ(error, "subnet_prefix is missing;dns_servers is missing;");
206
207  error.clear();
208  parameters["subnet_prefix"] = "123";
209  driver_->SetParameters(parameters, &error);
210  EXPECT_EQ(error,
211            "subnet_prefix not in expected range;dns_servers is missing;");
212
213  error.clear();
214  parameters["subnet_prefix"] = "12";
215  driver_->SetParameters(parameters, &error);
216  EXPECT_EQ(error, "dns_servers is missing;");
217
218  error.clear();
219  parameters["dns_servers"] = "12 123123 43902374";
220  driver_->SetParameters(parameters, &error);
221  EXPECT_EQ(error, "dns_servers has no valid values or is empty;");
222
223  driver_->device_ =
224      new MockVirtualDevice(&control_, &dispatcher_, &metrics_, &manager_,
225                            kInterfaceName, kInterfaceIndex, Technology::kVPN);
226  error.clear();
227  parameters["dns_servers"] = "123.211.21.18 123.211.21.19";
228  driver_->SetParameters(parameters, &error);
229  EXPECT_TRUE(error.empty());
230  EXPECT_FALSE(driver_->parameters_expected_);
231  driver_->device_ = nullptr;
232}
233
234}  // namespace shill
235