Peter Qiu | c0beca5 | 2015-09-03 11:25:46 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2015 The Android Open Source Project |
| 3 | // |
| 4 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | // you may not use this file except in compliance with the License. |
| 6 | // You may obtain a copy of the License at |
| 7 | // |
| 8 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | // |
| 10 | // Unless required by applicable law or agreed to in writing, software |
| 11 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | // See the License for the specific language governing permissions and |
| 14 | // limitations under the License. |
| 15 | // |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 16 | |
| 17 | #include <stdint.h> |
| 18 | |
| 19 | #include <memory> |
| 20 | #include <vector> |
| 21 | |
| 22 | #include <base/bind.h> |
| 23 | #include <base/memory/ref_counted.h> |
| 24 | #include <gmock/gmock.h> |
| 25 | #include <gtest/gtest.h> |
| 26 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 27 | #include "shill/daemon_task.h" |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 28 | #include "shill/dhcp/mock_dhcp_provider.h" |
| 29 | #include "shill/logging.h" |
| 30 | #include "shill/mock_control.h" |
| 31 | #include "shill/mock_manager.h" |
| 32 | #include "shill/mock_metrics.h" |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 33 | #include "shill/mock_process_manager.h" |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 34 | #include "shill/mock_routing_table.h" |
| 35 | #include "shill/net/io_handler.h" |
| 36 | #include "shill/net/mock_rtnl_handler.h" |
| 37 | #include "shill/net/ndisc.h" |
| 38 | #include "shill/shill_test_config.h" |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 39 | #include "shill/test_event_dispatcher.h" |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 40 | |
| 41 | #if !defined(DISABLE_WIFI) |
| 42 | #include "shill/net/mock_netlink_manager.h" |
| 43 | #include "shill/net/nl80211_message.h" |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 44 | #include "shill/wifi/callback80211_metrics.h" |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 45 | #endif // DISABLE_WIFI |
| 46 | |
| 47 | using base::Bind; |
| 48 | using base::Callback; |
| 49 | using base::Unretained; |
| 50 | using std::string; |
| 51 | using std::vector; |
| 52 | |
| 53 | using ::testing::Expectation; |
| 54 | using ::testing::Mock; |
| 55 | using ::testing::Return; |
| 56 | using ::testing::Test; |
| 57 | using ::testing::_; |
| 58 | |
| 59 | namespace shill { |
| 60 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 61 | class DaemonTaskForTest : public DaemonTask { |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 62 | public: |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 63 | DaemonTaskForTest(const Settings& setttings, Config* config) |
| 64 | : DaemonTask(Settings(), config) {} |
| 65 | virtual ~DaemonTaskForTest() {} |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 66 | |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 67 | bool quit_result() { return quit_result_; } |
| 68 | |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 69 | void RunMessageLoop() { dispatcher_->DispatchForever(); } |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 70 | |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 71 | bool Quit(const base::Closure& completion_callback) override { |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 72 | quit_result_ = DaemonTask::Quit(completion_callback); |
Alex Vakulenko | 3a62e23 | 2016-01-20 07:47:40 -0800 | [diff] [blame] | 73 | dispatcher_->PostTask(base::MessageLoop::QuitWhenIdleClosure()); |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 74 | return quit_result_; |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 75 | } |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 76 | |
| 77 | private: |
| 78 | bool quit_result_; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 79 | }; |
| 80 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 81 | class DaemonTaskTest : public Test { |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 82 | public: |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 83 | DaemonTaskTest() |
| 84 | : daemon_(DaemonTask::Settings(), &config_), |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 85 | dispatcher_(new EventDispatcherForTest()), |
| 86 | control_(new MockControl()), |
| 87 | metrics_(new MockMetrics(dispatcher_)), |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 88 | manager_(new MockManager(control_, dispatcher_, metrics_)), |
Samuel Tan | 7370e4f | 2016-01-07 15:25:23 -0800 | [diff] [blame] | 89 | #if !defined(DISABLE_WIFI) |
| 90 | callback_metrics_(new Callback80211Metrics(metrics_)), |
| 91 | #endif // DISABLE_WIFI |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 92 | device_info_(control_, dispatcher_, metrics_, manager_) { |
| 93 | } |
| 94 | virtual ~DaemonTaskTest() {} |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 95 | virtual void SetUp() { |
| 96 | // Tests initialization done by the daemon's constructor |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 97 | daemon_.rtnl_handler_ = &rtnl_handler_; |
| 98 | daemon_.routing_table_ = &routing_table_; |
| 99 | daemon_.dhcp_provider_ = &dhcp_provider_; |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 100 | daemon_.process_manager_ = &process_manager_; |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 101 | daemon_.metrics_.reset(metrics_); // Passes ownership |
| 102 | daemon_.manager_.reset(manager_); // Passes ownership |
| 103 | daemon_.control_.reset(control_); // Passes ownership |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 104 | daemon_.dispatcher_.reset(dispatcher_); // Passes ownership |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 105 | |
| 106 | #if !defined(DISABLE_WIFI) |
| 107 | daemon_.netlink_manager_ = &netlink_manager_; |
Samuel Tan | 7370e4f | 2016-01-07 15:25:23 -0800 | [diff] [blame] | 108 | // Passes ownership |
| 109 | daemon_.callback80211_metrics_.reset(callback_metrics_); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 110 | #endif // DISABLE_WIFI |
| 111 | } |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 112 | void StartDaemon() { daemon_.Start(); } |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 113 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 114 | void StopDaemon() { daemon_.Stop(); } |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 115 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 116 | void RunDaemon() { daemon_.RunMessageLoop(); } |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 117 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 118 | void ApplySettings(const DaemonTask::Settings& settings) { |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 119 | daemon_.settings_ = settings; |
| 120 | daemon_.ApplySettings(); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | MOCK_METHOD0(TerminationAction, void()); |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 124 | MOCK_METHOD0(BreakTerminationLoop, void()); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 125 | |
| 126 | protected: |
| 127 | TestConfig config_; |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 128 | DaemonTaskForTest daemon_; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 129 | MockRTNLHandler rtnl_handler_; |
| 130 | MockRoutingTable routing_table_; |
| 131 | MockDHCPProvider dhcp_provider_; |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 132 | MockProcessManager process_manager_; |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 133 | EventDispatcherForTest* dispatcher_; |
| 134 | MockControl* control_; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 135 | MockMetrics* metrics_; |
| 136 | MockManager* manager_; |
| 137 | #if !defined(DISABLE_WIFI) |
| 138 | MockNetlinkManager netlink_manager_; |
Samuel Tan | 7370e4f | 2016-01-07 15:25:23 -0800 | [diff] [blame] | 139 | Callback80211Metrics* callback_metrics_; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 140 | #endif // DISABLE_WIFI |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 141 | DeviceInfo device_info_; |
| 142 | }; |
| 143 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 144 | TEST_F(DaemonTaskTest, StartStop) { |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 145 | // To ensure we do not have any stale routes, we flush a device's routes |
| 146 | // when it is started. This requires that the routing table is fully |
| 147 | // populated before we create and start devices. So test to make sure that |
| 148 | // the RoutingTable starts before the Manager (which in turn starts |
| 149 | // DeviceInfo who is responsible for creating and starting devices). |
| 150 | // The result is that we request the dump of the routing table and when that |
| 151 | // completes, we request the dump of the links. For each link found, we |
| 152 | // create and start the device. |
| 153 | EXPECT_CALL(*metrics_, Start()); |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 154 | EXPECT_CALL(rtnl_handler_, Start(RTMGRP_LINK | RTMGRP_IPV4_IFADDR | |
| 155 | RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_IFADDR | |
| 156 | RTMGRP_IPV6_ROUTE | RTMGRP_ND_USEROPT)); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 157 | Expectation routing_table_started = EXPECT_CALL(routing_table_, Start()); |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 158 | EXPECT_CALL(dhcp_provider_, Init(_, _, _)); |
Peter Qiu | dde57ef | 2015-08-14 09:58:51 -0700 | [diff] [blame] | 159 | EXPECT_CALL(process_manager_, Init(_)); |
Peter Qiu | 29875ff | 2015-08-27 21:24:56 -0700 | [diff] [blame] | 160 | #if !defined(DISABLE_WIFI) |
| 161 | EXPECT_CALL(netlink_manager_, Init()); |
| 162 | const uint16_t kNl80211MessageType = 42; // Arbitrary. |
| 163 | EXPECT_CALL(netlink_manager_, |
| 164 | GetFamily(Nl80211Message::kMessageTypeString, _)) |
| 165 | .WillOnce(Return(kNl80211MessageType)); |
| 166 | EXPECT_CALL(netlink_manager_, Start()); |
| 167 | #endif // DISABLE_WIFI |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 168 | EXPECT_CALL(*manager_, Start()).After(routing_table_started); |
| 169 | StartDaemon(); |
| 170 | Mock::VerifyAndClearExpectations(metrics_); |
| 171 | Mock::VerifyAndClearExpectations(manager_); |
| 172 | |
| 173 | EXPECT_CALL(*manager_, Stop()); |
| 174 | EXPECT_CALL(*metrics_, Stop()); |
Peter Qiu | 89dfada | 2015-09-16 12:04:07 -0700 | [diff] [blame] | 175 | EXPECT_CALL(process_manager_, Stop()); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 176 | StopDaemon(); |
| 177 | } |
| 178 | |
| 179 | ACTION_P2(CompleteAction, manager, name) { |
| 180 | manager->TerminationActionComplete(name); |
| 181 | } |
| 182 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 183 | TEST_F(DaemonTaskTest, QuitWithTerminationAction) { |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 184 | // This expectation verifies that the termination actions are invoked. |
| 185 | EXPECT_CALL(*this, TerminationAction()) |
| 186 | .WillOnce(CompleteAction(manager_, "daemon test")); |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 187 | EXPECT_CALL(*this, BreakTerminationLoop()).Times(1); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 188 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 189 | manager_->AddTerminationAction( |
| 190 | "daemon test", |
| 191 | Bind(&DaemonTaskTest::TerminationAction, Unretained(this))); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 192 | |
| 193 | // Run Daemon::Quit() after the daemon starts running. |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 194 | dispatcher_->PostTask( |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 195 | Bind(IgnoreResult(&DaemonTask::Quit), Unretained(&daemon_), |
| 196 | Bind(&DaemonTaskTest::BreakTerminationLoop, Unretained(this)))); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 197 | |
| 198 | RunDaemon(); |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 199 | EXPECT_FALSE(daemon_.quit_result()); |
| 200 | } |
| 201 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 202 | TEST_F(DaemonTaskTest, QuitWithoutTerminationActions) { |
Samuel Tan | 646c7e8 | 2015-12-28 15:43:46 -0800 | [diff] [blame] | 203 | EXPECT_CALL(*this, BreakTerminationLoop()).Times(0); |
mukesh agrawal | e6b4192 | 2015-09-24 16:52:14 -0700 | [diff] [blame] | 204 | EXPECT_TRUE(daemon_.Quit( |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 205 | Bind(&DaemonTaskTest::BreakTerminationLoop, Unretained(this)))); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 206 | } |
| 207 | |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 208 | TEST_F(DaemonTaskTest, ApplySettings) { |
| 209 | DaemonTask::Settings settings; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 210 | vector<string> kEmptyStringList; |
Peter Qiu | 91b7150 | 2015-11-09 13:55:18 -0800 | [diff] [blame] | 211 | EXPECT_CALL(*manager_, SetBlacklistedDevices(kEmptyStringList)); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 212 | EXPECT_CALL(*manager_, SetDHCPv6EnabledDevices(kEmptyStringList)); |
| 213 | EXPECT_CALL(*manager_, SetTechnologyOrder("", _)); |
| 214 | EXPECT_CALL(*manager_, SetIgnoreUnknownEthernet(false)); |
| 215 | EXPECT_CALL(*manager_, SetStartupPortalList(_)).Times(0); |
| 216 | EXPECT_CALL(*manager_, SetPassiveMode()).Times(0); |
| 217 | EXPECT_CALL(*manager_, SetPrependDNSServers("")); |
| 218 | EXPECT_CALL(*manager_, SetMinimumMTU(_)).Times(0); |
| 219 | EXPECT_CALL(*manager_, SetAcceptHostnameFrom("")); |
| 220 | ApplySettings(settings); |
| 221 | Mock::VerifyAndClearExpectations(manager_); |
| 222 | |
Peter Qiu | 91b7150 | 2015-11-09 13:55:18 -0800 | [diff] [blame] | 223 | vector<string> kBlacklistedDevices = {"eth0", "eth1"}; |
| 224 | settings.device_blacklist = kBlacklistedDevices; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 225 | settings.default_technology_order = "wifi,ethernet"; |
Samuel Tan | 59b397b | 2016-01-20 11:25:21 -0800 | [diff] [blame] | 226 | vector<string> kDHCPv6EnabledDevices{"eth2", "eth3"}; |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 227 | settings.dhcpv6_enabled_devices = kDHCPv6EnabledDevices; |
| 228 | settings.ignore_unknown_ethernet = false; |
| 229 | settings.portal_list = "wimax"; |
| 230 | settings.use_portal_list = true; |
| 231 | settings.passive_mode = true; |
| 232 | settings.prepend_dns_servers = "8.8.8.8,8.8.4.4"; |
| 233 | settings.minimum_mtu = 256; |
| 234 | settings.accept_hostname_from = "eth*"; |
Peter Qiu | 91b7150 | 2015-11-09 13:55:18 -0800 | [diff] [blame] | 235 | EXPECT_CALL(*manager_, SetBlacklistedDevices(kBlacklistedDevices)); |
Peter Qiu | 24b34a0 | 2015-06-30 10:22:26 -0700 | [diff] [blame] | 236 | EXPECT_CALL(*manager_, SetDHCPv6EnabledDevices(kDHCPv6EnabledDevices)); |
| 237 | EXPECT_CALL(*manager_, SetTechnologyOrder("wifi,ethernet", _)); |
| 238 | EXPECT_CALL(*manager_, SetIgnoreUnknownEthernet(false)); |
| 239 | EXPECT_CALL(*manager_, SetStartupPortalList("wimax")); |
| 240 | EXPECT_CALL(*manager_, SetPassiveMode()); |
| 241 | EXPECT_CALL(*manager_, SetPrependDNSServers("8.8.8.8,8.8.4.4")); |
| 242 | EXPECT_CALL(*manager_, SetMinimumMTU(256)); |
| 243 | EXPECT_CALL(*manager_, SetAcceptHostnameFrom("eth*")); |
| 244 | ApplySettings(settings); |
| 245 | Mock::VerifyAndClearExpectations(manager_); |
| 246 | } |
| 247 | |
| 248 | } // namespace shill |