wimax_unittest.cc revision c3d707d1ae4198d5538ff4deccd729a83f1bc805 
1// Copyright (c) 2012 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/wimax/wimax.h"
6
7#include <memory>
8#include <string>
9
10#include "shill/event_dispatcher.h"
11#include "shill/mock_dhcp_config.h"
12#include "shill/mock_dhcp_provider.h"
13#include "shill/mock_manager.h"
14#include "shill/mock_metrics.h"
15#include "shill/mock_proxy_factory.h"
16#include "shill/nice_mock_control.h"
17#include "shill/testing.h"
18#include "shill/wimax/mock_wimax_device_proxy.h"
19#include "shill/wimax/mock_wimax_provider.h"
20#include "shill/wimax/mock_wimax_service.h"
21
22using base::Bind;
23using base::Unretained;
24using std::string;
25using testing::_;
26using testing::NiceMock;
27using testing::Return;
28
29namespace shill {
30
31namespace {
32
33const char kTestLinkName[] = "wm0";
34const char kTestAddress[] = "01:23:45:67:89:ab";
35const int kTestInterfaceIndex = 5;
36const char kTestPath[] = "/org/chromium/WiMaxManager/Device/6";
37
38}  // namespace
39
40class WiMaxTest : public testing::Test {
41 public:
42  WiMaxTest()
43      : proxy_(new MockWiMaxDeviceProxy()),
44        metrics_(&dispatcher_),
45        manager_(&control_, &dispatcher_, &metrics_, nullptr),
46        dhcp_config_(new MockDHCPConfig(&control_,
47                                        kTestLinkName)),
48        device_(new WiMax(&control_, &dispatcher_, &metrics_, &manager_,
49                          kTestLinkName, kTestAddress, kTestInterfaceIndex,
50                          kTestPath)) {}
51
52  virtual ~WiMaxTest() {}
53
54 protected:
55  class Target {
56   public:
57    virtual ~Target() {}
58
59    MOCK_METHOD1(EnabledStateChanged, void(const Error &error));
60  };
61
62  virtual void SetUp() {
63    device_->proxy_factory_ = &proxy_factory_;
64    device_->set_dhcp_provider(&dhcp_provider_);
65  }
66
67  virtual void TearDown() {
68    device_->SelectService(nullptr);
69    device_->pending_service_ = nullptr;
70    device_->proxy_factory_ = nullptr;
71  }
72
73  std::unique_ptr<MockWiMaxDeviceProxy> proxy_;
74  MockProxyFactory proxy_factory_;
75  NiceMockControl control_;
76  EventDispatcher dispatcher_;
77  NiceMock<MockMetrics> metrics_;
78  MockManager manager_;
79  MockDHCPProvider dhcp_provider_;
80  scoped_refptr<MockDHCPConfig> dhcp_config_;
81  WiMaxRefPtr device_;
82};
83
84TEST_F(WiMaxTest, Constructor) {
85  EXPECT_EQ(kTestPath, device_->path());
86  EXPECT_FALSE(device_->scanning());
87}
88
89TEST_F(WiMaxTest, StartStop) {
90  EXPECT_FALSE(device_->proxy_.get());
91  EXPECT_CALL(proxy_factory_, CreateWiMaxDeviceProxy(_))
92      .WillOnce(ReturnAndReleasePointee(&proxy_));
93  EXPECT_CALL(*proxy_, Enable(_, _, _));
94  EXPECT_CALL(*proxy_, set_networks_changed_callback(_));
95  EXPECT_CALL(*proxy_, set_status_changed_callback(_));
96  EXPECT_CALL(*proxy_, Disable(_, _, _));
97  device_->Start(nullptr, EnabledStateChangedCallback());
98  ASSERT_TRUE(device_->proxy_.get());
99
100  scoped_refptr<MockWiMaxService> service(
101      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
102  device_->pending_service_ = service;
103  EXPECT_CALL(*service, SetState(Service::kStateIdle));
104  device_->networks_.insert("path");
105  MockWiMaxProvider provider;
106  EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
107  EXPECT_CALL(provider, OnNetworksChanged());
108  device_->StartConnectTimeout();
109  device_->Stop(nullptr, EnabledStateChangedCallback());
110  EXPECT_TRUE(device_->networks_.empty());
111  EXPECT_FALSE(device_->IsConnectTimeoutStarted());
112  EXPECT_FALSE(device_->pending_service_);
113}
114
115TEST_F(WiMaxTest, OnServiceStopped) {
116  scoped_refptr<NiceMock<MockWiMaxService>> service0(
117      new NiceMock<MockWiMaxService>(&control_, nullptr, &metrics_, &manager_));
118  scoped_refptr<MockWiMaxService> service1(
119      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
120  device_->SelectService(service0);
121  device_->pending_service_ = service1;
122
123  device_->OnServiceStopped(nullptr);
124  EXPECT_TRUE(device_->selected_service());
125  EXPECT_TRUE(device_->pending_service_);
126
127  device_->OnServiceStopped(service0);
128  EXPECT_FALSE(device_->selected_service());
129  EXPECT_TRUE(device_->pending_service_);
130
131  device_->OnServiceStopped(service1);
132  EXPECT_FALSE(device_->selected_service());
133  EXPECT_FALSE(device_->pending_service_);
134}
135
136TEST_F(WiMaxTest, OnNetworksChanged) {
137  MockWiMaxProvider provider;
138  EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
139  EXPECT_CALL(provider, OnNetworksChanged());
140  device_->networks_.insert("foo");
141  RpcIdentifiers networks;
142  networks.push_back("bar");
143  networks.push_back("zoo");
144  networks.push_back("bar");
145  device_->OnNetworksChanged(networks);
146  EXPECT_EQ(2, device_->networks_.size());
147  EXPECT_TRUE(ContainsKey(device_->networks_, "bar"));
148  EXPECT_TRUE(ContainsKey(device_->networks_, "zoo"));
149}
150
151TEST_F(WiMaxTest, OnConnectComplete) {
152  scoped_refptr<MockWiMaxService> service(
153      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
154  device_->pending_service_ = service;
155  EXPECT_CALL(*service, SetState(_)).Times(0);
156  EXPECT_TRUE(device_->pending_service_);
157  EXPECT_CALL(*service, SetState(Service::kStateFailure));
158  device_->OnConnectComplete(Error(Error::kOperationFailed));
159  EXPECT_FALSE(device_->pending_service_);
160}
161
162TEST_F(WiMaxTest, OnStatusChanged) {
163  scoped_refptr<MockWiMaxService> service(
164      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
165
166  EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
167  device_->pending_service_ = service;
168  EXPECT_CALL(*service, SetState(_)).Times(0);
169  EXPECT_CALL(*service, ClearPassphrase()).Times(0);
170  device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
171  EXPECT_TRUE(device_->pending_service_);
172  EXPECT_EQ(wimax_manager::kDeviceStatusScanning, device_->status_);
173
174  device_->status_ = wimax_manager::kDeviceStatusConnecting;
175  EXPECT_CALL(*service, SetState(Service::kStateFailure));
176  EXPECT_CALL(*service, ClearPassphrase()).Times(0);
177  device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
178  EXPECT_FALSE(device_->pending_service_);
179
180  device_->status_ = wimax_manager::kDeviceStatusConnecting;
181  device_->SelectService(service);
182  EXPECT_CALL(*service, SetState(Service::kStateFailure));
183  EXPECT_CALL(*service, SetState(Service::kStateIdle));
184  EXPECT_CALL(*service, ClearPassphrase()).Times(0);
185  device_->OnStatusChanged(wimax_manager::kDeviceStatusScanning);
186  EXPECT_FALSE(device_->selected_service());
187
188  device_->pending_service_ = service;
189  device_->SelectService(service);
190  EXPECT_CALL(*service, SetState(_)).Times(0);
191  EXPECT_CALL(*service, ClearPassphrase()).Times(0);
192  device_->OnStatusChanged(wimax_manager::kDeviceStatusConnecting);
193  EXPECT_TRUE(device_->pending_service_);
194  EXPECT_TRUE(device_->selected_service());
195  EXPECT_EQ(wimax_manager::kDeviceStatusConnecting, device_->status_);
196
197  EXPECT_CALL(*service, SetState(Service::kStateIdle));
198  device_->SelectService(nullptr);
199}
200
201TEST_F(WiMaxTest, UseNoArpGateway) {
202  EXPECT_CALL(dhcp_provider_, CreateConfig(kTestLinkName, _, _, false))
203      .WillOnce(Return(dhcp_config_));
204  device_->AcquireIPConfig();
205}
206
207TEST_F(WiMaxTest, DropService) {
208  scoped_refptr<NiceMock<MockWiMaxService>> service0(
209      new NiceMock<MockWiMaxService>(&control_, nullptr, &metrics_, &manager_));
210  scoped_refptr<MockWiMaxService> service1(
211      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
212  device_->SelectService(service0);
213  device_->pending_service_ = service1;
214  device_->StartConnectTimeout();
215
216  EXPECT_CALL(*service0, SetState(Service::kStateIdle)).Times(2);
217  EXPECT_CALL(*service1, SetState(Service::kStateIdle));
218  device_->DropService(Service::kStateIdle);
219  EXPECT_FALSE(device_->selected_service());
220  EXPECT_FALSE(device_->pending_service_);
221  EXPECT_FALSE(device_->IsConnectTimeoutStarted());
222
223  // Expect no crash.
224  device_->DropService(Service::kStateFailure);
225}
226
227TEST_F(WiMaxTest, OnDeviceVanished) {
228  device_->proxy_.reset(proxy_.release());
229  scoped_refptr<MockWiMaxService> service(
230      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
231  device_->pending_service_ = service;
232  EXPECT_CALL(*service, SetState(Service::kStateIdle));
233  device_->OnDeviceVanished();
234  EXPECT_FALSE(device_->proxy_.get());
235  EXPECT_FALSE(device_->pending_service_);
236}
237
238TEST_F(WiMaxTest, OnEnableComplete) {
239  MockWiMaxProvider provider;
240  EXPECT_CALL(manager_, wimax_provider()).WillOnce(Return(&provider));
241  RpcIdentifiers networks(1, "path");
242  EXPECT_CALL(*proxy_, Networks(_)).WillOnce(Return(networks));
243  device_->proxy_.reset(proxy_.release());
244  EXPECT_CALL(provider, OnNetworksChanged());
245  Target target;
246  EXPECT_CALL(target, EnabledStateChanged(_));
247  EnabledStateChangedCallback callback(
248      Bind(&Target::EnabledStateChanged, Unretained(&target)));
249  Error error;
250  device_->OnEnableComplete(callback, error);
251  EXPECT_EQ(1, device_->networks_.size());
252  EXPECT_TRUE(ContainsKey(device_->networks_, "path"));
253
254  EXPECT_TRUE(device_->proxy_.get());
255  error.Populate(Error::kOperationFailed);
256  EXPECT_CALL(target, EnabledStateChanged(_));
257  device_->OnEnableComplete(callback, error);
258  EXPECT_FALSE(device_->proxy_.get());
259}
260
261TEST_F(WiMaxTest, ConnectTimeout) {
262  EXPECT_EQ(&dispatcher_, device_->dispatcher());
263  EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
264  EXPECT_FALSE(device_->IsConnectTimeoutStarted());
265  EXPECT_EQ(WiMax::kDefaultConnectTimeoutSeconds,
266            device_->connect_timeout_seconds_);
267  device_->connect_timeout_seconds_ = 0;
268  device_->StartConnectTimeout();
269  EXPECT_FALSE(device_->connect_timeout_callback_.IsCancelled());
270  EXPECT_TRUE(device_->IsConnectTimeoutStarted());
271  device_->dispatcher_ = nullptr;
272  device_->StartConnectTimeout();  // Expect no crash.
273  scoped_refptr<MockWiMaxService> service(
274      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
275  device_->pending_service_ = service;
276  EXPECT_CALL(*service, SetState(Service::kStateFailure));
277  dispatcher_.DispatchPendingEvents();
278  EXPECT_TRUE(device_->connect_timeout_callback_.IsCancelled());
279  EXPECT_FALSE(device_->IsConnectTimeoutStarted());
280  EXPECT_FALSE(device_->pending_service_);
281}
282
283TEST_F(WiMaxTest, ConnectTo) {
284  static const char kPath[] = "/network/path";
285  scoped_refptr<MockWiMaxService> service(
286      new MockWiMaxService(&control_, nullptr, &metrics_, &manager_));
287  EXPECT_CALL(*service, SetState(Service::kStateAssociating));
288  device_->status_ = wimax_manager::kDeviceStatusScanning;
289  EXPECT_CALL(*service, GetNetworkObjectPath()).WillOnce(Return(kPath));
290  EXPECT_CALL(*proxy_, Connect(kPath, _, _, _, _))
291      .WillOnce(SetErrorTypeInArgument<2>(Error::kSuccess));
292  device_->proxy_.reset(proxy_.release());
293  Error error;
294  device_->ConnectTo(service, &error);
295  EXPECT_TRUE(error.IsSuccess());
296  EXPECT_EQ(service.get(), device_->pending_service_.get());
297  EXPECT_EQ(wimax_manager::kDeviceStatusUninitialized, device_->status_);
298  EXPECT_TRUE(device_->IsConnectTimeoutStarted());
299
300  device_->ConnectTo(service, &error);
301  EXPECT_EQ(Error::kInProgress, error.type());
302
303  device_->pending_service_ = nullptr;
304}
305
306TEST_F(WiMaxTest, IsIdle) {
307  EXPECT_TRUE(device_->IsIdle());
308  scoped_refptr<NiceMock<MockWiMaxService>> service(
309      new NiceMock<MockWiMaxService>(&control_, nullptr, &metrics_, &manager_));
310  device_->pending_service_ = service;
311  EXPECT_FALSE(device_->IsIdle());
312  device_->pending_service_ = nullptr;
313  device_->SelectService(service);
314  EXPECT_FALSE(device_->IsIdle());
315}
316
317}  // namespace shill
318