device_status_collector_browsertest.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
1// Copyright (c) 2012 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 "chrome/browser/chromeos/policy/device_status_collector.h"
6
7#include "base/environment.h"
8#include "base/logging.h"
9#include "base/memory/scoped_ptr.h"
10#include "base/message_loop/message_loop.h"
11#include "base/prefs/pref_service.h"
12#include "base/prefs/testing_pref_service.h"
13#include "base/run_loop.h"
14#include "base/threading/sequenced_worker_pool.h"
15#include "chrome/browser/chromeos/login/mock_user_manager.h"
16#include "chrome/browser/chromeos/login/user_manager.h"
17#include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
18#include "chrome/browser/chromeos/settings/cros_settings.h"
19#include "chrome/browser/chromeos/settings/device_settings_service.h"
20#include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
21#include "chrome/browser/policy/browser_policy_connector.h"
22#include "chrome/common/pref_names.h"
23#include "chrome/test/base/testing_browser_process.h"
24#include "chromeos/dbus/dbus_thread_manager.h"
25#include "chromeos/dbus/shill_device_client.h"
26#include "chromeos/network/network_handler.h"
27#include "chromeos/settings/cros_settings_names.h"
28#include "chromeos/settings/cros_settings_provider.h"
29#include "chromeos/system/mock_statistics_provider.h"
30#include "content/public/browser/browser_thread.h"
31#include "content/public/browser/geolocation_provider.h"
32#include "content/public/test/test_browser_thread.h"
33#include "content/public/test/test_utils.h"
34#include "policy/proto/device_management_backend.pb.h"
35#include "testing/gmock/include/gmock/gmock.h"
36#include "testing/gtest/include/gtest/gtest.h"
37#include "third_party/cros_system_api/dbus/service_constants.h"
38
39using ::testing::DoAll;
40using ::testing::NotNull;
41using ::testing::Return;
42using ::testing::SetArgPointee;
43using ::testing::_;
44using base::Time;
45using base::TimeDelta;
46
47namespace em = enterprise_management;
48
49namespace {
50
51const int64 kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
52
53scoped_ptr<content::Geoposition> mock_position_to_return_next;
54
55void SetMockPositionToReturnNext(const content::Geoposition &position) {
56  mock_position_to_return_next.reset(new content::Geoposition(position));
57}
58
59void MockPositionUpdateRequester(
60    const content::GeolocationProvider::LocationUpdateCallback& callback) {
61  if (!mock_position_to_return_next.get())
62    return;
63
64  // If the fix is invalid, the DeviceStatusCollector will immediately request
65  // another update when it receives the callback. This is desirable and safe in
66  // real life where geolocation updates arrive asynchronously. In this testing
67  // harness, the callback is invoked synchronously upon request, leading to a
68  // request-callback loop. The loop is broken by returning the mock position
69  // only once.
70  scoped_ptr<content::Geoposition> position(
71      mock_position_to_return_next.release());
72  callback.Run(*position);
73}
74
75class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
76 public:
77  TestingDeviceStatusCollector(
78      PrefService* local_state,
79      chromeos::system::StatisticsProvider* provider,
80      policy::DeviceStatusCollector::LocationUpdateRequester*
81          location_update_requester)
82      : policy::DeviceStatusCollector(
83          local_state,
84          provider,
85          location_update_requester) {
86    // Set the baseline time to a fixed value (1 AM) to prevent test flakiness
87    // due to a single activity period spanning two days.
88    SetBaselineTime(Time::Now().LocalMidnight() + TimeDelta::FromHours(1));
89  }
90
91  void Simulate(IdleState* states, int len) {
92    for (int i = 0; i < len; i++)
93      IdleStateCallback(states[i]);
94  }
95
96  void set_max_stored_past_activity_days(unsigned int value) {
97    max_stored_past_activity_days_ = value;
98  }
99
100  void set_max_stored_future_activity_days(unsigned int value) {
101    max_stored_future_activity_days_ = value;
102  }
103
104  // Reset the baseline time.
105  void SetBaselineTime(Time time) {
106    baseline_time_ = time;
107    baseline_offset_periods_ = 0;
108  }
109
110 protected:
111  virtual void CheckIdleState() OVERRIDE {
112    // This should never be called in testing, as it results in a dbus call.
113    ADD_FAILURE();
114  }
115
116  // Each time this is called, returns a time that is a fixed increment
117  // later than the previous time.
118  virtual Time GetCurrentTime() OVERRIDE {
119    int poll_interval = policy::DeviceStatusCollector::kIdlePollIntervalSeconds;
120    return baseline_time_ +
121        TimeDelta::FromSeconds(poll_interval * baseline_offset_periods_++);
122  }
123
124 private:
125  // Baseline time for the fake times returned from GetCurrentTime().
126  Time baseline_time_;
127
128  // The number of simulated periods since the baseline time.
129  int baseline_offset_periods_;
130};
131
132// Return the total number of active milliseconds contained in a device
133// status report.
134int64 GetActiveMilliseconds(em::DeviceStatusReportRequest& status) {
135  int64 active_milliseconds = 0;
136  for (int i = 0; i < status.active_period_size(); i++) {
137    active_milliseconds += status.active_period(i).active_duration();
138  }
139  return active_milliseconds;
140}
141
142}  // namespace
143
144namespace policy {
145
146// Though it is a unit test, this test is linked with browser_tests so that it
147// runs in a separate process. The intention is to avoid overriding the timezone
148// environment variable for other tests.
149class DeviceStatusCollectorTest : public testing::Test {
150 public:
151  DeviceStatusCollectorTest()
152    : message_loop_(base::MessageLoop::TYPE_UI),
153      ui_thread_(content::BrowserThread::UI, &message_loop_),
154      file_thread_(content::BrowserThread::FILE, &message_loop_),
155      io_thread_(content::BrowserThread::IO, &message_loop_),
156      user_manager_(new chromeos::MockUserManager()),
157      user_manager_enabler_(user_manager_) {
158    // Run this test with a well-known timezone so that Time::LocalMidnight()
159    // returns the same values on all machines.
160    scoped_ptr<base::Environment> env(base::Environment::Create());
161    env->SetVar("TZ", "UTC");
162
163    TestingDeviceStatusCollector::RegisterPrefs(prefs_.registry());
164
165    EXPECT_CALL(statistics_provider_, GetMachineStatistic(_, NotNull()))
166        .WillRepeatedly(Return(false));
167
168    // Remove the real DeviceSettingsProvider and replace it with a stub.
169    cros_settings_ = chromeos::CrosSettings::Get();
170    device_settings_provider_ =
171        cros_settings_->GetProvider(chromeos::kReportDeviceVersionInfo);
172    EXPECT_TRUE(device_settings_provider_ != NULL);
173    EXPECT_TRUE(
174        cros_settings_->RemoveSettingsProvider(device_settings_provider_));
175    cros_settings_->AddSettingsProvider(&stub_settings_provider_);
176
177    // Set up fake install attributes.
178    StubEnterpriseInstallAttributes* attributes =
179        new StubEnterpriseInstallAttributes();
180    attributes->SetDomain("managed.com");
181    attributes->SetRegistrationUser("user@managed.com");
182    BrowserPolicyConnector::SetInstallAttributesForTesting(attributes);
183
184    RestartStatusCollector();
185  }
186
187  virtual ~DeviceStatusCollectorTest() {
188    // Finish pending tasks.
189    content::BrowserThread::GetBlockingPool()->FlushForTesting();
190    message_loop_.RunUntilIdle();
191
192    // Restore the real DeviceSettingsProvider.
193    EXPECT_TRUE(
194      cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
195    cros_settings_->AddSettingsProvider(device_settings_provider_);
196  }
197
198  void RestartStatusCollector() {
199    policy::DeviceStatusCollector::LocationUpdateRequester callback =
200        base::Bind(&MockPositionUpdateRequester);
201    status_collector_.reset(
202        new TestingDeviceStatusCollector(&prefs_,
203                                         &statistics_provider_,
204                                         &callback));
205  }
206
207  void GetStatus() {
208    status_.Clear();
209    status_collector_->GetDeviceStatus(&status_);
210  }
211
212  void CheckThatNoLocationIsReported() {
213    GetStatus();
214    EXPECT_FALSE(status_.has_device_location());
215  }
216
217  void CheckThatAValidLocationIsReported() {
218    // Checks that a location is being reported which matches the valid fix
219    // set using SetMockPositionToReturnNext().
220    GetStatus();
221    EXPECT_TRUE(status_.has_device_location());
222    em::DeviceLocation location = status_.device_location();
223    if (location.has_error_code())
224      EXPECT_EQ(em::DeviceLocation::ERROR_CODE_NONE, location.error_code());
225    EXPECT_TRUE(location.has_latitude());
226    EXPECT_TRUE(location.has_longitude());
227    EXPECT_TRUE(location.has_accuracy());
228    EXPECT_TRUE(location.has_timestamp());
229    EXPECT_FALSE(location.has_altitude());
230    EXPECT_FALSE(location.has_altitude_accuracy());
231    EXPECT_FALSE(location.has_heading());
232    EXPECT_FALSE(location.has_speed());
233    EXPECT_FALSE(location.has_error_message());
234    EXPECT_DOUBLE_EQ(4.3, location.latitude());
235    EXPECT_DOUBLE_EQ(-7.8, location.longitude());
236    EXPECT_DOUBLE_EQ(3., location.accuracy());
237    // Check that the timestamp is not older than ten minutes.
238    EXPECT_TRUE(Time::Now() - Time::FromDoubleT(location.timestamp() / 1000.) <
239                TimeDelta::FromMinutes(10));
240  }
241
242  void CheckThatALocationErrorIsReported() {
243    GetStatus();
244    EXPECT_TRUE(status_.has_device_location());
245    em::DeviceLocation location = status_.device_location();
246    EXPECT_TRUE(location.has_error_code());
247    EXPECT_EQ(em::DeviceLocation::ERROR_CODE_POSITION_UNAVAILABLE,
248              location.error_code());
249  }
250
251 protected:
252  // Convenience method.
253  int64 ActivePeriodMilliseconds() {
254    return policy::DeviceStatusCollector::kIdlePollIntervalSeconds * 1000;
255  }
256
257  // Since this is a unit test running in browser_tests we must do additional
258  // unit test setup and make a TestingBrowserProcess. Must be first member.
259  TestingBrowserProcessInitializer initializer_;
260  base::MessageLoop message_loop_;
261  content::TestBrowserThread ui_thread_;
262  content::TestBrowserThread file_thread_;
263  content::TestBrowserThread io_thread_;
264
265  TestingPrefServiceSimple prefs_;
266  chromeos::system::MockStatisticsProvider statistics_provider_;
267  chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
268  chromeos::ScopedTestCrosSettings test_cros_settings_;
269  chromeos::CrosSettings* cros_settings_;
270  chromeos::CrosSettingsProvider* device_settings_provider_;
271  chromeos::StubCrosSettingsProvider stub_settings_provider_;
272  chromeos::MockUserManager* user_manager_;
273  chromeos::ScopedUserManagerEnabler user_manager_enabler_;
274  em::DeviceStatusReportRequest status_;
275  scoped_ptr<TestingDeviceStatusCollector> status_collector_;
276};
277
278TEST_F(DeviceStatusCollectorTest, AllIdle) {
279  IdleState test_states[] = {
280    IDLE_STATE_IDLE,
281    IDLE_STATE_IDLE,
282    IDLE_STATE_IDLE
283  };
284  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
285
286  // Test reporting with no data.
287  GetStatus();
288  EXPECT_EQ(0, status_.active_period_size());
289  EXPECT_EQ(0, GetActiveMilliseconds(status_));
290
291  // Test reporting with a single idle sample.
292  status_collector_->Simulate(test_states, 1);
293  GetStatus();
294  EXPECT_EQ(0, status_.active_period_size());
295  EXPECT_EQ(0, GetActiveMilliseconds(status_));
296
297  // Test reporting with multiple consecutive idle samples.
298  status_collector_->Simulate(test_states,
299                              sizeof(test_states) / sizeof(IdleState));
300  GetStatus();
301  EXPECT_EQ(0, status_.active_period_size());
302  EXPECT_EQ(0, GetActiveMilliseconds(status_));
303}
304
305TEST_F(DeviceStatusCollectorTest, AllActive) {
306  IdleState test_states[] = {
307    IDLE_STATE_ACTIVE,
308    IDLE_STATE_ACTIVE,
309    IDLE_STATE_ACTIVE
310  };
311  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
312
313  // Test a single active sample.
314  status_collector_->Simulate(test_states, 1);
315  GetStatus();
316  EXPECT_EQ(1, status_.active_period_size());
317  EXPECT_EQ(1 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
318  status_.clear_active_period(); // Clear the result protobuf.
319
320  // Test multiple consecutive active samples.
321  status_collector_->Simulate(test_states,
322                              sizeof(test_states) / sizeof(IdleState));
323  GetStatus();
324  EXPECT_EQ(1, status_.active_period_size());
325  EXPECT_EQ(4 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
326}
327
328TEST_F(DeviceStatusCollectorTest, MixedStates) {
329  IdleState test_states[] = {
330    IDLE_STATE_ACTIVE,
331    IDLE_STATE_IDLE,
332    IDLE_STATE_ACTIVE,
333    IDLE_STATE_ACTIVE,
334    IDLE_STATE_IDLE,
335    IDLE_STATE_IDLE,
336    IDLE_STATE_ACTIVE
337  };
338  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
339  status_collector_->Simulate(test_states,
340                              sizeof(test_states) / sizeof(IdleState));
341  GetStatus();
342  EXPECT_EQ(4 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
343}
344
345TEST_F(DeviceStatusCollectorTest, StateKeptInPref) {
346  IdleState test_states[] = {
347    IDLE_STATE_ACTIVE,
348    IDLE_STATE_IDLE,
349    IDLE_STATE_ACTIVE,
350    IDLE_STATE_ACTIVE,
351    IDLE_STATE_IDLE,
352    IDLE_STATE_IDLE
353  };
354  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
355  status_collector_->Simulate(test_states,
356                              sizeof(test_states) / sizeof(IdleState));
357
358  // Process the list a second time after restarting the collector. It should be
359  // able to count the active periods found by the original collector, because
360  // the results are stored in a pref.
361  RestartStatusCollector();
362  status_collector_->Simulate(test_states,
363                              sizeof(test_states) / sizeof(IdleState));
364
365  GetStatus();
366  EXPECT_EQ(6 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
367}
368
369TEST_F(DeviceStatusCollectorTest, Times) {
370  IdleState test_states[] = {
371    IDLE_STATE_ACTIVE,
372    IDLE_STATE_IDLE,
373    IDLE_STATE_ACTIVE,
374    IDLE_STATE_ACTIVE,
375    IDLE_STATE_IDLE,
376    IDLE_STATE_IDLE
377  };
378  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
379  status_collector_->Simulate(test_states,
380                              sizeof(test_states) / sizeof(IdleState));
381  GetStatus();
382  EXPECT_EQ(3 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
383}
384
385TEST_F(DeviceStatusCollectorTest, MaxStoredPeriods) {
386  IdleState test_states[] = {
387    IDLE_STATE_ACTIVE,
388    IDLE_STATE_IDLE
389  };
390  const int kMaxDays = 10;
391
392  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
393  status_collector_->set_max_stored_past_activity_days(kMaxDays - 1);
394  status_collector_->set_max_stored_future_activity_days(1);
395  Time baseline = Time::Now().LocalMidnight();
396
397  // Simulate 12 active periods.
398  for (int i = 0; i < kMaxDays + 2; i++) {
399    status_collector_->Simulate(test_states,
400                                sizeof(test_states) / sizeof(IdleState));
401    // Advance the simulated clock by a day.
402    baseline += TimeDelta::FromDays(1);
403    status_collector_->SetBaselineTime(baseline);
404  }
405
406  // Check that we don't exceed the max number of periods.
407  GetStatus();
408  EXPECT_EQ(kMaxDays - 1, status_.active_period_size());
409
410  // Simulate some future times.
411  for (int i = 0; i < kMaxDays + 2; i++) {
412    status_collector_->Simulate(test_states,
413                                sizeof(test_states) / sizeof(IdleState));
414    // Advance the simulated clock by a day.
415    baseline += TimeDelta::FromDays(1);
416    status_collector_->SetBaselineTime(baseline);
417  }
418  // Set the clock back so the previous simulated times are in the future.
419  baseline -= TimeDelta::FromDays(20);
420  status_collector_->SetBaselineTime(baseline);
421
422  // Collect one more data point to trigger pruning.
423  status_collector_->Simulate(test_states, 1);
424
425  // Check that we don't exceed the max number of periods.
426  status_.clear_active_period();
427  GetStatus();
428  EXPECT_LT(status_.active_period_size(), kMaxDays);
429}
430
431TEST_F(DeviceStatusCollectorTest, ActivityTimesDisabledByDefault) {
432  // If the pref for collecting device activity times isn't explicitly turned
433  // on, no data on activity times should be reported.
434
435  IdleState test_states[] = {
436    IDLE_STATE_ACTIVE,
437    IDLE_STATE_ACTIVE,
438    IDLE_STATE_ACTIVE
439  };
440  status_collector_->Simulate(test_states,
441                              sizeof(test_states) / sizeof(IdleState));
442  GetStatus();
443  EXPECT_EQ(0, status_.active_period_size());
444  EXPECT_EQ(0, GetActiveMilliseconds(status_));
445}
446
447TEST_F(DeviceStatusCollectorTest, ActivityCrossingMidnight) {
448  IdleState test_states[] = {
449    IDLE_STATE_ACTIVE
450  };
451  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
452
453  // Set the baseline time to 10 seconds after midnight.
454  status_collector_->SetBaselineTime(
455      Time::Now().LocalMidnight() + TimeDelta::FromSeconds(10));
456
457  status_collector_->Simulate(test_states, 1);
458  GetStatus();
459  ASSERT_EQ(2, status_.active_period_size());
460
461  em::ActiveTimePeriod period0 = status_.active_period(0);
462  em::ActiveTimePeriod period1 = status_.active_period(1);
463  EXPECT_EQ(ActivePeriodMilliseconds() - 10000, period0.active_duration());
464  EXPECT_EQ(10000, period1.active_duration());
465
466  em::TimePeriod time_period0 = period0.time_period();
467  em::TimePeriod time_period1 = period1.time_period();
468
469  EXPECT_EQ(time_period0.end_timestamp(), time_period1.start_timestamp());
470
471  // Ensure that the start and end times for the period are a day apart.
472  EXPECT_EQ(time_period0.end_timestamp() - time_period0.start_timestamp(),
473            kMillisecondsPerDay);
474  EXPECT_EQ(time_period1.end_timestamp() - time_period1.start_timestamp(),
475            kMillisecondsPerDay);
476}
477
478TEST_F(DeviceStatusCollectorTest, ActivityTimesKeptUntilSubmittedSuccessfully) {
479  IdleState test_states[] = {
480    IDLE_STATE_ACTIVE,
481    IDLE_STATE_ACTIVE,
482  };
483  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
484
485  status_collector_->Simulate(test_states, 2);
486  GetStatus();
487  EXPECT_EQ(2 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
488  em::DeviceStatusReportRequest first_status(status_);
489
490  // The collector returns the same status again.
491  GetStatus();
492  EXPECT_EQ(first_status.SerializeAsString(), status_.SerializeAsString());
493
494  // After indicating a successful submit, the submitted status gets cleared,
495  // but what got collected meanwhile sticks around.
496  status_collector_->Simulate(test_states, 1);
497  status_collector_->OnSubmittedSuccessfully();
498  GetStatus();
499  EXPECT_EQ(ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
500}
501
502TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
503  // Test that boot mode data is not reported if the pref is not turned on.
504  EXPECT_CALL(statistics_provider_,
505              GetMachineStatistic("devsw_boot", NotNull()))
506      .WillRepeatedly(DoAll(SetArgPointee<1>("0"), Return(true)));
507  GetStatus();
508  EXPECT_FALSE(status_.has_boot_mode());
509
510  // Turn the pref on, and check that the status is reported iff the
511  // statistics provider returns valid data.
512  cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, true);
513
514  EXPECT_CALL(statistics_provider_,
515              GetMachineStatistic("devsw_boot", NotNull()))
516      .WillOnce(DoAll(SetArgPointee<1>("(error)"), Return(true)));
517  GetStatus();
518  EXPECT_FALSE(status_.has_boot_mode());
519
520  EXPECT_CALL(statistics_provider_,
521              GetMachineStatistic("devsw_boot", NotNull()))
522      .WillOnce(DoAll(SetArgPointee<1>(" "), Return(true)));
523  GetStatus();
524  EXPECT_FALSE(status_.has_boot_mode());
525
526  EXPECT_CALL(statistics_provider_,
527              GetMachineStatistic("devsw_boot", NotNull()))
528      .WillOnce(DoAll(SetArgPointee<1>("0"), Return(true)));
529  GetStatus();
530  EXPECT_EQ("Verified", status_.boot_mode());
531
532  EXPECT_CALL(statistics_provider_,
533              GetMachineStatistic("devsw_boot", NotNull()))
534      .WillOnce(DoAll(SetArgPointee<1>("1"), Return(true)));
535  GetStatus();
536  EXPECT_EQ("Dev", status_.boot_mode());
537}
538
539TEST_F(DeviceStatusCollectorTest, VersionInfo) {
540  // When the pref to collect this data is not enabled, expect that none of
541  // the fields are present in the protobuf.
542  GetStatus();
543  EXPECT_FALSE(status_.has_browser_version());
544  EXPECT_FALSE(status_.has_os_version());
545  EXPECT_FALSE(status_.has_firmware_version());
546
547  cros_settings_->SetBoolean(chromeos::kReportDeviceVersionInfo, true);
548  GetStatus();
549  EXPECT_TRUE(status_.has_browser_version());
550  EXPECT_TRUE(status_.has_os_version());
551  EXPECT_TRUE(status_.has_firmware_version());
552
553  // Check that the browser version is not empty. OS version & firmware
554  // don't have any reasonable values inside the unit test, so those
555  // aren't checked.
556  EXPECT_NE("", status_.browser_version());
557}
558
559TEST_F(DeviceStatusCollectorTest, Location) {
560  content::Geoposition valid_fix;
561  valid_fix.latitude = 4.3;
562  valid_fix.longitude = -7.8;
563  valid_fix.accuracy = 3.;
564  valid_fix.timestamp = Time::Now();
565
566  content::Geoposition invalid_fix;
567  invalid_fix.error_code =
568      content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
569  invalid_fix.timestamp = Time::Now();
570
571  // Check that when device location reporting is disabled, no location is
572  // reported.
573  SetMockPositionToReturnNext(valid_fix);
574  CheckThatNoLocationIsReported();
575
576  // Check that when device location reporting is enabled and a valid fix is
577  // available, the location is reported and is stored in local state.
578  SetMockPositionToReturnNext(valid_fix);
579  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, true);
580  EXPECT_FALSE(prefs_.GetDictionary(prefs::kDeviceLocation)->empty());
581  CheckThatAValidLocationIsReported();
582
583  // Restart the status collector. Check that the last known location has been
584  // retrieved from local state without requesting a geolocation update.
585  SetMockPositionToReturnNext(valid_fix);
586  RestartStatusCollector();
587  CheckThatAValidLocationIsReported();
588  EXPECT_TRUE(mock_position_to_return_next.get());
589
590  // Check that after disabling location reporting again, the last known
591  // location has been cleared from local state and is no longer reported.
592  SetMockPositionToReturnNext(valid_fix);
593  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, false);
594  // Allow the new pref to propagate to the status collector.
595  message_loop_.RunUntilIdle();
596  EXPECT_TRUE(prefs_.GetDictionary(prefs::kDeviceLocation)->empty());
597  CheckThatNoLocationIsReported();
598
599  // Check that after enabling location reporting again, an error is reported
600  // if no valid fix is available.
601  SetMockPositionToReturnNext(invalid_fix);
602  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, true);
603  // Allow the new pref to propagate to the status collector.
604  message_loop_.RunUntilIdle();
605  CheckThatALocationErrorIsReported();
606}
607
608TEST_F(DeviceStatusCollectorTest, ReportUsers) {
609  user_manager_->CreatePublicAccountUser("public@localhost");
610  user_manager_->AddUser("user0@managed.com");
611  user_manager_->AddUser("user1@managed.com");
612  user_manager_->AddUser("user2@managed.com");
613  user_manager_->AddUser("user3@unmanaged.com");
614  user_manager_->AddUser("user4@managed.com");
615  user_manager_->AddUser("user5@managed.com");
616
617  // Verify that users are not reported by default.
618  GetStatus();
619  EXPECT_EQ(0, status_.user_size());
620
621  // Verify that users are reported after enabling the setting.
622  cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, true);
623  GetStatus();
624  EXPECT_EQ(5, status_.user_size());
625  EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(0).type());
626  EXPECT_EQ("user0@managed.com", status_.user(0).email());
627  EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(1).type());
628  EXPECT_EQ("user1@managed.com", status_.user(1).email());
629  EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(2).type());
630  EXPECT_EQ("user2@managed.com", status_.user(2).email());
631  EXPECT_EQ(em::DeviceUser::USER_TYPE_UNMANAGED, status_.user(3).type());
632  EXPECT_FALSE(status_.user(3).has_email());
633  EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(4).type());
634  EXPECT_EQ("user4@managed.com", status_.user(4).email());
635
636  // Verify that users are no longer reported if setting is disabled.
637  cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, false);
638  GetStatus();
639  EXPECT_EQ(0, status_.user_size());
640}
641
642TEST_F(DeviceStatusCollectorTest, ReportManagedUser) {
643  // Verify that at least one managed user is reported regardless of list size.
644  user_manager_->AddUser("user0@unmanaged.com");
645  user_manager_->AddUser("user1@unmanaged.com");
646  user_manager_->AddUser("user2@unmanaged.com");
647  user_manager_->AddUser("user3@unmanaged.com");
648  user_manager_->AddUser("user4@unmanaged.com");
649  user_manager_->AddUser("user5@unmanaged.com");
650  user_manager_->AddUser("user6@managed.com");
651  user_manager_->AddUser("user7@managed.com");
652
653  cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, true);
654  GetStatus();
655  EXPECT_EQ(7, status_.user_size());
656  for (int i = 0; i < 6; ++i)
657    EXPECT_EQ(em::DeviceUser::USER_TYPE_UNMANAGED, status_.user(i).type());
658  EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(6).type());
659  EXPECT_EQ("user6@managed.com", status_.user(6).email());
660}
661
662// Fake device state.
663struct FakeDeviceData {
664  const char* device_path;
665  const char* type;
666  const char* object_path;
667  const char* mac_address;
668  const char* meid;
669  const char* imei;
670  int expected_type; // proto enum type value, -1 for not present.
671};
672
673static const FakeDeviceData kFakeDevices[] = {
674  { "/device/ethernet", shill::kTypeEthernet, "ethernet",
675    "112233445566", "", "",
676    em::NetworkInterface::TYPE_ETHERNET },
677  { "/device/cellular1", shill::kTypeCellular, "cellular1",
678    "abcdefabcdef", "A10000009296F2", "",
679    em::NetworkInterface::TYPE_CELLULAR },
680  { "/device/cellular2", shill::kTypeCellular, "cellular2",
681    "abcdefabcdef", "", "352099001761481",
682    em::NetworkInterface::TYPE_CELLULAR },
683  { "/device/wifi", shill::kTypeWifi, "wifi",
684    "aabbccddeeff", "", "",
685    em::NetworkInterface::TYPE_WIFI },
686  { "/device/bluetooth", shill::kTypeBluetooth, "bluetooth",
687    "", "", "",
688    em::NetworkInterface::TYPE_BLUETOOTH },
689  { "/device/vpn", shill::kTypeVPN, "vpn",
690    "", "", "",
691    -1 },
692};
693
694class DeviceStatusCollectorNetworkInterfacesTest
695    : public DeviceStatusCollectorTest {
696 protected:
697  virtual void SetUp() OVERRIDE {
698    chromeos::DBusThreadManager::InitializeWithStub();
699    chromeos::NetworkHandler::Initialize();
700    chromeos::ShillDeviceClient::TestInterface* test_device_client =
701        chromeos::DBusThreadManager::Get()->GetShillDeviceClient()->
702            GetTestInterface();
703    test_device_client->ClearDevices();
704    for (size_t i = 0; i < arraysize(kFakeDevices); ++i) {
705      const FakeDeviceData& dev = kFakeDevices[i];
706      test_device_client->AddDevice(dev.device_path, dev.type,
707                                    dev.object_path);
708      if (*dev.mac_address) {
709        test_device_client->SetDeviceProperty(
710            dev.device_path, shill::kAddressProperty,
711            base::StringValue(dev.mac_address));
712      }
713      if (*dev.meid) {
714        test_device_client->SetDeviceProperty(
715            dev.device_path, shill::kMeidProperty,
716            base::StringValue(dev.meid));
717      }
718      if (*dev.imei) {
719        test_device_client->SetDeviceProperty(
720            dev.device_path, shill::kImeiProperty,
721            base::StringValue(dev.imei));
722      }
723    }
724
725    // Flush out pending state updates.
726    base::RunLoop().RunUntilIdle();
727  }
728
729  virtual void TearDown() OVERRIDE {
730    chromeos::NetworkHandler::Shutdown();
731    chromeos::DBusThreadManager::Shutdown();
732  }
733};
734
735TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
736  // No interfaces should be reported if the policy is off.
737  GetStatus();
738  EXPECT_EQ(0, status_.network_interface_size());
739
740  // Switch the policy on and verify the interface list is present.
741  cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
742  GetStatus();
743
744  int count = 0;
745  for (size_t i = 0; i < arraysize(kFakeDevices); ++i) {
746    const FakeDeviceData& dev = kFakeDevices[i];
747    if (dev.expected_type == -1)
748      continue;
749
750    // Find the corresponding entry in reporting data.
751    bool found_match = false;
752    google::protobuf::RepeatedPtrField<em::NetworkInterface>::const_iterator
753        iface;
754    for (iface = status_.network_interface().begin();
755         iface != status_.network_interface().end();
756         ++iface) {
757      // Check whether type, field presence and field values match.
758      if (dev.expected_type == iface->type() &&
759          iface->has_mac_address() == !!*dev.mac_address &&
760          iface->has_meid() == !!*dev.meid &&
761          iface->has_imei() == !!*dev.imei &&
762          iface->mac_address() == dev.mac_address &&
763          iface->meid() == dev.meid &&
764          iface->imei() == dev.imei) {
765        found_match = true;
766        break;
767      }
768    }
769
770    EXPECT_TRUE(found_match) << "No matching interface for fake device " << i;
771    count++;
772  }
773
774  EXPECT_EQ(count, status_.network_interface_size());
775}
776
777}  // namespace policy
778