kiosk: Add status report for os update and running app

chrome/browser/chromeos/policy/device_status_collector_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/sys_info.h"
+#include "base/test/scoped_path_override.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
+#include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/fake_update_engine_client.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/disks/mock_disk_mount_manager.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/system/fake_statistics_provider.h"
@@ skipping 208 matching lines @@
         install_attributes_("managed.com",
                             "user@managed.com",
                             "device_id",
                             DEVICE_MODE_ENTERPRISE),
         settings_helper_(false),
         user_manager_(new chromeos::MockUserManager()),
         user_manager_enabler_(user_manager_),
         fake_device_local_account_(policy::DeviceLocalAccount::TYPE_KIOSK_APP,
                                    kKioskAccountId,
                                    kKioskAppId,
-                                   std::string() /* kiosk_app_update_url */) {
+                                   std::string() /* kiosk_app_update_url */),
+        user_data_dir_override_(chrome::DIR_USER_DATA),
+        update_engine_client_(new chromeos::FakeUpdateEngineClient) {
     // Run this test with a well-known timezone so that Time::LocalMidnight()
     // returns the same values on all machines.
     std::unique_ptr<base::Environment> env(base::Environment::Create());
     env->SetVar("TZ", "UTC");
 
     // Initialize our mock mounted disk volumes.
     std::unique_ptr<chromeos::disks::MockDiskMountManager>
         mock_disk_mount_manager =
             base::WrapUnique(new chromeos::disks::MockDiskMountManager());
     AddMountPoint("/mount/volume1");
@@ skipping 18 matching lines @@
     DiskMountManager::InitializeForTesting(mock_disk_mount_manager.release());
     TestingDeviceStatusCollector::RegisterPrefs(prefs_.registry());
 
     settings_helper_.ReplaceProvider(chromeos::kReportDeviceActivityTimes);
     owner_settings_service_ =
         settings_helper_.CreateOwnerSettingsService(nullptr);
 
     RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                            base::Bind(&GetEmptyCPUStatistics),
                            base::Bind(&GetEmptyCPUTempInfo));
+
+    // Set up a fake local state for KioskAppManager.
+    TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
+    chromeos::KioskAppManager::RegisterPrefs(local_state_.registry());
+
+    // Use FakeUpdateEngineClient.
+    std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
+        chromeos::DBusThreadManager::GetSetterForTesting();
+    dbus_setter->SetUpdateEngineClient(
+        base::WrapUnique<chromeos::UpdateEngineClient>(update_engine_client_));
   }
 
   void AddMountPoint(const std::string& mount_point) {
     mount_point_map_.insert(DiskMountManager::MountPointMap::value_type(
         mount_point,
         DiskMountManager::MountPointInfo(
             mount_point, mount_point, chromeos::MOUNT_TYPE_DEVICE,
             chromeos::disks::MOUNT_CONDITION_NONE)));
   }
 
   ~DeviceStatusCollectorTest() override {
+    chromeos::KioskAppManager::Shutdown();
+    TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
+
     // Finish pending tasks.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     message_loop_.RunUntilIdle();
     storage::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
     DiskMountManager::Shutdown();
   }
 
   void SetUp() override {
     // Disable network interface reporting since it requires additional setup.
     settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces,
                                 false);
   }
 
-  void TearDown() override { settings_helper_.RestoreProvider(); }
+  void TearDown() override {
+    settings_helper_.RestoreProvider();
+  }
 
   void RestartStatusCollector(
       const policy::DeviceStatusCollector::VolumeInfoFetcher& volume_info,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_stats,
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher) {
     policy::DeviceStatusCollector::LocationUpdateRequester callback =
         base::Bind(&MockPositionUpdateRequester);
     std::vector<em::VolumeInfo> expected_volume_info;
     status_collector_.reset(new TestingDeviceStatusCollector(
         &prefs_, &fake_statistics_provider_, callback, volume_info, cpu_stats,
@@ skipping 47 matching lines @@
   void MockRunningKioskApp(const DeviceLocalAccount& account) {
     std::vector<DeviceLocalAccount> accounts;
     accounts.push_back(account);
     SetDeviceLocalAccounts(owner_settings_service_.get(), accounts);
     user_manager_->CreateKioskAppUser(
         AccountId::FromUserEmail(account.user_id));
     EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp()).WillRepeatedly(
         Return(true));
   }
 
+  void MockPlatformVersion(const std::string& platform_version) {
+    const std::string lsb_release = base::StringPrintf(
+        "CHROMEOS_RELEASE_VERSION=%s", platform_version.c_str());
+    base::SysInfo::SetChromeOSVersionInfoForTest(lsb_release,
+                                                 base::Time::Now());
+  }
+
+  void MockAutoLaunchKioskAppWithRequiredPlatformVersion(
+      const DeviceLocalAccount& auto_launch_app_account,
+      const std::string& required_platform_version) {
+    chromeos::KioskAppManager* manager = chromeos::KioskAppManager::Get();
+    manager->AddAppForTest(
+        auto_launch_app_account.kiosk_app_id,
+        AccountId::FromUserEmail(auto_launch_app_account.user_id),
+        GURL("http://cws/"),  // Dummy URL to avoid setup ExtensionsClient.
+        required_platform_version);
+    manager->SetEnableAutoLaunch(true);
+
+    std::vector<DeviceLocalAccount> accounts;
+    accounts.push_back(auto_launch_app_account);
+    SetDeviceLocalAccounts(owner_settings_service_.get(), accounts);
+
+    owner_settings_service_->SetString(
+        chromeos::kAccountsPrefDeviceLocalAccountAutoLoginId,
+        auto_launch_app_account.account_id);
+
+    message_loop_.RunUntilIdle();
+
+    ASSERT_EQ(required_platform_version,
+              manager->GetAutoLaunchAppRequiredPlatformVersion());
+  }
+
  protected:
   // Convenience method.
   int64_t ActivePeriodMilliseconds() {
     return policy::DeviceStatusCollector::kIdlePollIntervalSeconds * 1000;
   }
 
   // Since this is a unit test running in browser_tests we must do additional
   // unit test setup and make a TestingBrowserProcess. Must be first member.
   TestingBrowserProcessInitializer initializer_;
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   TestingPrefServiceSimple prefs_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   DiskMountManager::MountPointMap mount_point_map_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   std::unique_ptr<chromeos::FakeOwnerSettingsService> owner_settings_service_;
-  chromeos::MockUserManager* user_manager_;
+  chromeos::MockUserManager* const user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   em::DeviceStatusReportRequest status_;
   std::unique_ptr<TestingDeviceStatusCollector> status_collector_;
   const policy::DeviceLocalAccount fake_device_local_account_;
+  base::ScopedPathOverride user_data_dir_override_;
+  TestingPrefServiceSimple local_state_;
+  chromeos::FakeUpdateEngineClient* const update_engine_client_;
 };
 
 TEST_F(DeviceStatusCollectorTest, AllIdle) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
@@ skipping 580 matching lines @@
   ASSERT_EQ(1, session_status.installed_apps_size());
   EXPECT_EQ(kKioskAccountId, session_status.device_local_account_id());
   const em::AppStatus app = session_status.installed_apps(0);
   EXPECT_EQ(kKioskAppId, app.app_id());
   // Test code just sets the version to the app ID.
   EXPECT_EQ(kKioskAppId, app.extension_version());
   EXPECT_FALSE(app.has_status());
   EXPECT_FALSE(app.has_error());
 }
 
+TEST_F(DeviceStatusCollectorTest, NoOsUpdateStatusByDefault) {
+  MockPlatformVersion("1234.0.0");
+  MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
+                                                    "1234.0.0");
+
+  GetStatus();
+  EXPECT_FALSE(status_.has_os_update_status());
+}
+
+TEST_F(DeviceStatusCollectorTest, ReportOsUpdateStatusUpToDate) {
+  MockPlatformVersion("1234.0.0");
+  settings_helper_.SetBoolean(chromeos::kReportOsUpdateStatus, true);
+
+  const char* kRequiredPlatformVersions[] = {"1234", "1234.0", "1234.0.0"};
+
+  for (size_t i = 0; i < arraysize(kRequiredPlatformVersions); ++i) {
+    MockAutoLaunchKioskAppWithRequiredPlatformVersion(
+        fake_device_local_account_, kRequiredPlatformVersions[i]);
+
+    GetStatus();
+    ASSERT_TRUE(status_.has_os_update_status()) << "Required platform version="
+                                                << kRequiredPlatformVersions[i];
+    EXPECT_EQ(em::OsUpdateStatus::OS_UP_TO_DATE,
+              status_.os_update_status().update_status())
+        << "Required platform version=" << kRequiredPlatformVersions[i];
+    EXPECT_EQ(kRequiredPlatformVersions[i],
+              status_.os_update_status().new_required_platform_version())
+        << "Required platform version=" << kRequiredPlatformVersions[i];
+  }
+}
+
+TEST_F(DeviceStatusCollectorTest, ReportOsUpdateStatus) {
+  MockPlatformVersion("1234.0.0");
+  settings_helper_.SetBoolean(chromeos::kReportOsUpdateStatus, true);
+  MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
+                                                    "1235");
+
+  chromeos::UpdateEngineClient::Status update_status;
+  update_status.status = chromeos::UpdateEngineClient::UPDATE_STATUS_IDLE;
+
+  GetStatus();
+  ASSERT_TRUE(status_.has_os_update_status());
+  EXPECT_EQ(em::OsUpdateStatus::OS_IMAGE_DOWNLOAD_NOT_STARTED,
+            status_.os_update_status().update_status());
+
+  const chromeos::UpdateEngineClient::UpdateStatusOperation kUpdateEngineOps[] =
+      {
+          chromeos::UpdateEngineClient::UPDATE_STATUS_DOWNLOADING,
+          chromeos::UpdateEngineClient::UPDATE_STATUS_VERIFYING,
+          chromeos::UpdateEngineClient::UPDATE_STATUS_FINALIZING,
+      };
+
+  for (size_t i = 0; i < arraysize(kUpdateEngineOps); ++i) {
+    update_status.status = kUpdateEngineOps[i];
+    update_status.new_version = "1235.1.2";
+    update_engine_client_->PushLastStatus(update_status);
+
+    GetStatus();
+    ASSERT_TRUE(status_.has_os_update_status());
+    EXPECT_EQ(em::OsUpdateStatus::OS_IMAGE_DOWNLOAD_IN_PROGRESS,
+              status_.os_update_status().update_status());
+    EXPECT_EQ("1235.1.2", status_.os_update_status().new_platform_version());
+    EXPECT_EQ("1235",
+              status_.os_update_status().new_required_platform_version());
+  }
+
+  update_status.status =
+      chromeos::UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT;
+  update_engine_client_->PushLastStatus(update_status);
+  GetStatus();
+  ASSERT_TRUE(status_.has_os_update_status());
+  EXPECT_EQ(em::OsUpdateStatus::OS_UPDATE_NEED_REBOOT,
+            status_.os_update_status().update_status());
+}
+
+TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppByDefault) {
+  MockPlatformVersion("1234.0.0");
+  MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
+                                                    "1234.0.0");
+  status_collector_->set_kiosk_account(base::WrapUnique(
+      new policy::DeviceLocalAccount(fake_device_local_account_)));
+  MockRunningKioskApp(fake_device_local_account_);
+
+  GetStatus();
+  EXPECT_FALSE(status_.has_running_kiosk_app());
+}
+
+TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppWhenNotInKioskSession) {
+  settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
+  MockPlatformVersion("1234.0.0");
+  MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
+                                                    "1234.0.0");
+
+  GetStatus();
+  EXPECT_FALSE(status_.has_running_kiosk_app());
+}
+
+TEST_F(DeviceStatusCollectorTest, ReportRunningKioskApp) {
+  settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
+  MockPlatformVersion("1234.0.0");
+  MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
+                                                    "1235");
+  MockRunningKioskApp(fake_device_local_account_);
+  status_collector_->set_kiosk_account(base::WrapUnique(
+      new policy::DeviceLocalAccount(fake_device_local_account_)));
+
+  GetStatus();
+  ASSERT_TRUE(status_.has_running_kiosk_app());
+  const em::AppStatus app = status_.running_kiosk_app();
+  EXPECT_EQ(kKioskAppId, app.app_id());
+  EXPECT_EQ("1235", app.required_platform_version());
+  EXPECT_FALSE(app.has_status());
+  EXPECT_FALSE(app.has_error());
+}
+
 // Fake device state.
 struct FakeDeviceData {
   const char* device_path;
   const char* type;
   const char* object_path;
   const char* mac_address;
   const char* meid;
   const char* imei;
   int expected_type;  // proto enum type value, -1 for not present.
 };
@@ skipping 283 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy