third_party_vpn_driver_unittest.cc revision e0e205bf5e625398d02be89bda076ea9fd761896
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 std::string warning; 171 driver_->SetParameters(parameters, &error, &warning); 172 EXPECT_EQ(error, "Unexpected call"); 173 174 error.clear(); 175 ThirdPartyVpnDriver::active_client_ = driver_; 176 driver_->parameters_expected_ = true; 177 driver_->SetParameters(parameters, &error, &warning); 178 EXPECT_EQ(error, 179 "address is missing;subnet_prefix is missing;" 180 "dns_servers is missing;" 181 "exclusion_list is missing;inclusion_list is missing;"); 182 EXPECT_TRUE(warning.empty()); 183 184 error.clear(); 185 parameters["address"] = "1234.1.1.1"; 186 driver_->SetParameters(parameters, &error, &warning); 187 EXPECT_EQ(error, 188 "address is not a valid IP;subnet_prefix is missing;" 189 "dns_servers is missing;" 190 "exclusion_list is missing;inclusion_list is missing;"); 191 EXPECT_TRUE(warning.empty()); 192 193 error.clear(); 194 parameters["address"] = "123.211.21.18"; 195 driver_->SetParameters(parameters, &error, &warning); 196 EXPECT_EQ(error, 197 "subnet_prefix is missing;dns_servers is missing;" 198 "exclusion_list is missing;inclusion_list is missing;"); 199 EXPECT_TRUE(warning.empty()); 200 201 error.clear(); 202 parameters["subnet_prefix"] = "123"; 203 driver_->SetParameters(parameters, &error, &warning); 204 EXPECT_EQ(error, 205 "subnet_prefix not in expected range;dns_servers is missing;" 206 "exclusion_list is missing;inclusion_list is missing;"); 207 EXPECT_TRUE(warning.empty()); 208 209 error.clear(); 210 parameters["subnet_prefix"] = "12"; 211 driver_->SetParameters(parameters, &error, &warning); 212 EXPECT_EQ(error, "dns_servers is missing;" 213 "exclusion_list is missing;inclusion_list is missing;"); 214 EXPECT_TRUE(warning.empty()); 215 216 error.clear(); 217 parameters["dns_servers"] = "12 123123 43902374"; 218 driver_->SetParameters(parameters, &error, &warning); 219 EXPECT_EQ(error, "dns_servers has no valid values or is empty;" 220 "exclusion_list is missing;inclusion_list is missing;"); 221 EXPECT_EQ(warning, "12 for dns_servers is invalid;" 222 "123123 for dns_servers is invalid;" 223 "43902374 for dns_servers is invalid;"); 224 225 driver_->device_ = 226 new MockVirtualDevice(&control_, &dispatcher_, &metrics_, &manager_, 227 kInterfaceName, kInterfaceIndex, Technology::kVPN); 228 error.clear(); 229 warning.clear(); 230 parameters["exclusion_list"] = 231 "400.400.400.400/12 1.1.1.1/44 1.1.1.1/-1 " 232 "123.211.21.0/23 123.211.21.1/23 123.211.21.0/25 " 233 "1.1.1.1.1/12 1.1.1/13"; 234 parameters["dns_servers"] = ""; 235 driver_->SetParameters(parameters, &error, &warning); 236 EXPECT_EQ(error, "dns_servers has no valid values or is empty;" 237 "inclusion_list is missing;"); 238 EXPECT_EQ(warning, 239 "400.400.400.400/12 for exclusion_list is invalid;" 240 "1.1.1.1/44 for exclusion_list is invalid;" 241 "1.1.1.1/-1 for exclusion_list is invalid;" 242 "Duplicate entry for 123.211.21.1/23 in exclusion_list found;" 243 "1.1.1.1.1/12 for exclusion_list is invalid;" 244 "1.1.1/13 for exclusion_list is invalid;"); 245 246 error.clear(); 247 warning.clear(); 248 parameters["exclusion_list"] = "123.211.21.29/31 123.211.21.1/24"; 249 parameters["inclusion_list"] = 250 "400.400.400.400/12 1.1.1.1/44 1.1.1.1/-1 " 251 "123.211.22.0/24 123.211.22.1/24 " 252 "1.1.1.1.1/12 1.1.1/13 123.211.21.0/24"; 253 driver_->SetParameters(parameters, &error, &warning); 254 EXPECT_EQ(error, "dns_servers has no valid values or is empty;"); 255 EXPECT_EQ(warning, 256 "400.400.400.400/12 for inclusion_list is invalid;" 257 "1.1.1.1/44 for inclusion_list is invalid;" 258 "1.1.1.1/-1 for inclusion_list is invalid;" 259 "Duplicate entry for 123.211.22.1/24 in inclusion_list found;" 260 "1.1.1.1.1/12 for inclusion_list is invalid;" 261 "1.1.1/13 for inclusion_list is invalid;" 262 "Duplicate entry for 123.211.21.0/24 in inclusion_list found;"); 263 264 error.clear(); 265 warning.clear(); 266 parameters["dns_servers"] = "123.211.21.18 123.211.21.19"; 267 parameters["inclusion_list"] = "123.211.61.29/7 123.211.42.29/17"; 268 driver_->SetParameters(parameters, &error, &warning); 269 EXPECT_EQ(driver_->ip_properties_.exclusion_list.size(), 2); 270 EXPECT_EQ(driver_->ip_properties_.exclusion_list[0], "123.211.21.29/31"); 271 EXPECT_EQ(driver_->ip_properties_.exclusion_list[1], "123.211.21.1/24"); 272 EXPECT_EQ(driver_->ip_properties_.routes.size(), 2); 273 EXPECT_EQ(driver_->ip_properties_.routes[0].host, "123.211.61.29"); 274 EXPECT_EQ(driver_->ip_properties_.routes[1].host, "123.211.42.29"); 275 EXPECT_EQ(driver_->ip_properties_.routes[0].netmask, "254.0.0.0"); 276 EXPECT_EQ(driver_->ip_properties_.routes[1].netmask, "255.255.128.0"); 277 EXPECT_EQ(driver_->ip_properties_.routes[0].gateway, parameters["address"]); 278 EXPECT_EQ(driver_->ip_properties_.routes[1].gateway, parameters["address"]); 279 EXPECT_TRUE(error.empty()); 280 EXPECT_TRUE(warning.empty()); 281 EXPECT_FALSE(driver_->parameters_expected_); 282 driver_->device_ = nullptr; 283} 284 285} // namespace shill 286