Add more browser tests for Kiosk update from usb stick.

chrome/browser/chromeos/login/kiosk_browsertest.cc

 // Copyright (c) 2013 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 "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 79 matching lines @@
 //   chrome/test/data/chromeos/app_mode/webstore/downloads/
 const char kTestOfflineEnabledKioskApp[] = "ajoggoflpgplnnjkjamcmbepjdjdnpdp";
 
 // An app to test local fs data persistence across app update. V1 app writes
 // data into local fs. V2 app reads and verifies the data.
 // Webstore data json is in
 //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/
 //       detail/bmbpicmpniaclbbpdkfglgipkkebnbjf
 const char kTestLocalFsKioskApp[] = "bmbpicmpniaclbbpdkfglgipkkebnbjf";
 
-const char kFakeUsbStickMountPath[] = "chromeos/app_mode/external_update/";
+// Fake usb stick mount path.
+const char kFakeUsbMountPathUpdatePass[] =
+    "chromeos/app_mode/external_update/update_pass";
+const char kFakeUsbMountPathNoManifest[] =
+    "chromeos/app_mode/external_update/no_manifest";
+const char kFakeUsbMountPathBadManifest[] =
+    "chromeos/app_mode/external_update/bad_manifest";
+const char kFakeUsbMountPathLowerAppVersion[] =
+    "chromeos/app_mode/external_update/lower_app_version";
+const char kFakeUsbMountPathLowerCrxVersion[] =
+    "chromeos/app_mode/external_update/lower_crx_version";
+const char kFakeUsbMountPathBadCrx[] =
+    "chromeos/app_mode/external_update/bad_crx";
 
 // Timeout while waiting for network connectivity during tests.
 const int kTestNetworkTimeoutSeconds = 1;
 
 // Email of owner account for test.
 const char kTestOwnerEmail[] = "owner@example.com";
 
 const char kTestEnterpriseAccountId[] = "enterprise-kiosk-app@localhost";
 const char kTestEnterpriseServiceAccountId[] = "service_account@example.com";
 const char kTestRefreshToken[] = "fake-refresh-token";
@@ skipping 126 matching lines @@
 
   content::WebContents* web_contents_;
   const std::string js_;
   scoped_refptr<content::MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(JsConditionWaiter);
 };
 
 class KioskFakeDiskMountManager : public file_manager::FakeDiskMountManager {
  public:
-  explicit KioskFakeDiskMountManager(const std::string& usb_mount_path)
-      : usb_mount_path_(usb_mount_path) {}
+  KioskFakeDiskMountManager() {}
 
   virtual ~KioskFakeDiskMountManager() {}
 
+  void set_usb_mount_path(const std::string& usb_mount_path) {
+    usb_mount_path_ = usb_mount_path;
+  }
+
   void MountUsbStick() {
+    DCHECK(!usb_mount_path_.empty());
     MountPath(usb_mount_path_, "", "", chromeos::MOUNT_TYPE_DEVICE);
   }
 
   void UnMountUsbStick() {
+    DCHECK(!usb_mount_path_.empty());
     UnmountPath(usb_mount_path_,
                 UNMOUNT_OPTIONS_NONE,
                 disks::DiskMountManager::UnmountPathCallback());
   }
 
  private:
   std::string usb_mount_path_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskFakeDiskMountManager);
 };
@@ skipping 678 matching lines @@
       content::NotificationService::AllSources()).Wait();
 }
 
 class KioskUpdateTest : public KioskTest {
  public:
   KioskUpdateTest() {}
   virtual ~KioskUpdateTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
-    base::FilePath test_data_dir;
-    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
-    test_data_dir = test_data_dir.AppendASCII(kFakeUsbStickMountPath);
-    fake_disk_mount_manager_ =
-        new KioskFakeDiskMountManager(test_data_dir.value());
+    fake_disk_mount_manager_ = new KioskFakeDiskMountManager();
     disks::DiskMountManager::InitializeForTesting(fake_disk_mount_manager_);
 
     KioskTest::SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     disks::DiskMountManager::Shutdown();
 
     KioskTest::TearDown();
   }
@@ skipping 31 matching lines @@
     KioskAppManager::Get()->UpdateExternalCache();
     waiter.Wait();
     EXPECT_TRUE(waiter.loaded());
     std::string cached_version;
     base::FilePath file_path;
     EXPECT_TRUE(
         manager->GetCachedCrx(test_app_id(), &file_path, &cached_version));
     EXPECT_EQ(version, cached_version);
   }
 
-  void SimulateUpdateAppFromUsbStick() {
+  void SetupFakeDiskMountManagerMountPath(const std::string mount_path) {
+    base::FilePath test_data_dir;
+    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
+    test_data_dir = test_data_dir.AppendASCII(mount_path);
+    fake_disk_mount_manager_->set_usb_mount_path(test_data_dir.value());
+  }
+
+  void SimulateUpdateAppFromUsbStick(const std::string& usb_mount_path,
+                                     bool* app_update_notified,
+                                     bool* update_success) {
+    SetupFakeDiskMountManagerMountPath(usb_mount_path);
     KioskAppExternalUpdateWaiter waiter(KioskAppManager::Get(), test_app_id());
     fake_disk_mount_manager_->MountUsbStick();
     waiter.Wait();
     fake_disk_mount_manager_->UnMountUsbStick();
+    *update_success = waiter.update_success();
+    *app_update_notified = waiter.app_update_notified();
   }
 
   void PreCacheAndLaunchApp(const std::string& app_id,
                             const std::string& version,
                             const std::string& crx_file) {
     set_test_app_id(app_id);
     set_test_app_version(version);
     set_test_crx_file(crx_file);
     PrepareAppLaunch();
     SimulateNetworkOnline();
     LaunchApp(test_app_id(), false);
     WaitForAppLaunchSuccess();
     EXPECT_EQ(version, GetInstalledAppVersion().GetString());
   }
 
  private:
-  class KioskAppExternalUpdateWaiter : KioskAppManagerObserver {
+  class KioskAppExternalUpdateWaiter : public KioskAppManagerObserver {
    public:
     KioskAppExternalUpdateWaiter(KioskAppManager* manager,
                                  const std::string& app_id)
-        : runner_(NULL), manager_(manager), app_id_(app_id), quit_(false) {
+        : runner_(NULL),
+          manager_(manager),
+          app_id_(app_id),
+          quit_(false),
+          update_success_(false),
+          app_update_notified_(false) {
       manager_->AddObserver(this);
     }
 
     virtual ~KioskAppExternalUpdateWaiter() { manager_->RemoveObserver(this); }
 
     void Wait() {
       if (quit_)
         return;
       runner_ = new content::MessageLoopRunner;
       runner_->Run();
     }
 
+    bool update_success() const { return update_success_; }
+
+    bool app_update_notified() const { return app_update_notified_; }
+
    private:
     // KioskAppManagerObserver overrides:
     virtual void OnKioskAppCacheUpdated(const std::string& app_id) OVERRIDE {
       if (app_id_ != app_id)
         return;
+      app_update_notified_ = true;
+    }
+
+    virtual void OnKioskAppExternalUpdateComplete(bool success) OVERRIDE {
       quit_ = true;
+      update_success_ = success;
       if (runner_)
         runner_->Quit();
     }
 
     scoped_refptr<content::MessageLoopRunner> runner_;
     KioskAppManager* manager_;
+    bool wait_for_update_success_;
     const std::string app_id_;
     bool quit_;
+    bool update_success_;
+    bool app_update_notified_;
 
     DISALLOW_COPY_AND_ASSIGN(KioskAppExternalUpdateWaiter);
   };
 
   class AppDataLoadWaiter : public KioskAppManagerObserver {
    public:
     AppDataLoadWaiter(KioskAppManager* manager,
                       const std::string& app_id,
                       const std::string& version)
         : runner_(NULL),
@@ skipping 166 matching lines @@
               std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
 
   set_test_app_id(kTestOfflineEnabledKioskApp);
   StartUIForAppLaunch();
   SimulateNetworkOffline();
   LaunchApp(test_app_id(), false);
   WaitForAppLaunchSuccess();
   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
 
   // Simulate mounting of usb stick with v2 app on the stick.
-  SimulateUpdateAppFromUsbStick();
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathUpdatePass, &app_update_notified, &update_success);
+  EXPECT_TRUE(update_success);
+  EXPECT_TRUE(app_update_notified);
 
-  // The v2 kiosk app is copied into external cache, but won't be loaded
+  // The v2 kiosk app is loaded into external cache, but won't be installed
   // until next time the device is started.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("2.0.0", cached_version);
   EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
 }
 
 // Restart the device, verify the app has been updated to v2.
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppNoNetwork) {
   // Verify the kiosk app has been updated to v2.
   set_test_app_id(kTestOfflineEnabledKioskApp);
   StartUIForAppLaunch();
   SimulateNetworkOffline();
   LaunchApp(test_app_id(), false);
   WaitForAppLaunchSuccess();
   EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
 }
 
+// Usb stick is plugged in without a manifest file on it.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppNoManifest) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v2 app on the stick.
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathNoManifest, &app_update_notified, &update_success);
+  EXPECT_FALSE(update_success);
+
+  // Kiosk app is not updated.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("1.0.0", cached_version);
+}
+
+// Usb stick is plugged in with a bad manifest file on it.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppBadManifest) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v2 app on the stick.
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathBadManifest, &app_update_notified, &update_success);
+  EXPECT_FALSE(update_success);
+
+  // Kiosk app is not updated.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("1.0.0", cached_version);
+}
+
+// Usb stick is plugged in with a lower version of crx file specified in
+// manifest.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppLowerAppVersion) {
+  // Precache v2 version of app.
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "2.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + ".crx");
+  EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v1 app on the stick.
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathLowerAppVersion, &app_update_notified, &update_success);
+  EXPECT_FALSE(update_success);
+
+  // Kiosk app is NOT updated to the lower version.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("2.0.0", cached_version);
+}
+
+// Usb stick is plugged in with a v1 crx file, although the manifest says
+// this is a v3 version.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppLowerCrxVersion) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "2.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + ".crx");
+  EXPECT_EQ("2.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v1 crx file on the stick, although
+  // the manifest says it is v3 app.
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathLowerCrxVersion, &app_update_notified, &update_success);
+  EXPECT_FALSE(update_success);
+
+  // Kiosk app is NOT updated to the lower version.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("2.0.0", cached_version);
+}
+
+// Usb stick is plugged in with a bad crx file.
+IN_PROC_BROWSER_TEST_F(KioskUpdateTest, UsbStickUpdateAppBadCrx) {
+  PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
+                       "1.0.0",
+                       std::string(kTestOfflineEnabledKioskApp) + "_v1.crx");
+  EXPECT_EQ("1.0.0", GetInstalledAppVersion().GetString());
+
+  // Simulate mounting of usb stick with v1 crx file on the stick, although
+  // the manifest says it is v3 app.
+  bool update_success;
+  bool app_update_notified;
+  SimulateUpdateAppFromUsbStick(
+      kFakeUsbMountPathBadCrx, &app_update_notified, &update_success);
+  EXPECT_FALSE(update_success);
+
+  // Kiosk app is NOT updated.
+  base::FilePath crx_path;
+  std::string cached_version;
+  EXPECT_TRUE(KioskAppManager::Get()->GetCachedCrx(
+      test_app_id(), &crx_path, &cached_version));
+  EXPECT_EQ("1.0.0", cached_version);
+}
+
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PRE_PermissionChange) {
   PreCacheAndLaunchApp(kTestOfflineEnabledKioskApp,
                        "2.0.0",
                        std::string(kTestOfflineEnabledKioskApp) + ".crx");
 }
 
 IN_PROC_BROWSER_TEST_F(KioskUpdateTest, PermissionChange) {
   set_test_app_id(kTestOfflineEnabledKioskApp);
   set_test_app_version("2.0.0");
   set_test_crx_file(test_app_id() + "_v2_permission_change.crx");
@@ skipping 251 matching lines @@
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_KIOSK_AUTOLAUNCH_WARNING_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
   // Wait for the wallpaper to load.
   WaitForWallpaper();
   EXPECT_TRUE(wallpaper_loaded());
 }
 
 }  // namespace chromeos