chrome/browser/extensions/api/image_writer_private/operation_manager_unittest.cc

   1 // Copyright 2013 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 "base/command_line.h"
   6 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
   7 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
   8 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
   9 #include "chrome/browser/extensions/extension_service.h"
  10 #include "chrome/browser/extensions/extension_system_factory.h"
  11 #include "chrome/browser/extensions/test_extension_system.h"
  12 #include "chrome/test/base/testing_profile.h"
  13 #include "extensions/browser/event_router.h"
  14
  15 #if defined(OS_CHROMEOS)
  16 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
  17 #include "chrome/browser/chromeos/settings/cros_settings.h"
  18 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  19 #endif
  20
  21 namespace extensions {
  22 namespace image_writer {
  23
  24 // A fake for the EventRouter. If tests require monitoring of interaction with
  25 // the event router put the logic here.
  26 class FakeEventRouter : public extensions::EventRouter {
  27  public:
  28   explicit FakeEventRouter(Profile* profile) : EventRouter(profile, NULL) {}
  29
  30   void DispatchEventToExtension(const std::string& extension_id,
  31                                 scoped_ptr<extensions::Event> event) override {
  32     // Do nothing with the event as no tests currently care.
  33   }
  34 };
  35
  36 // A fake ExtensionSystem that returns a FakeEventRouter for event_router().
  37 class FakeExtensionSystem : public extensions::TestExtensionSystem {
  38  public:
  39   explicit FakeExtensionSystem(Profile* profile)
  40       : TestExtensionSystem(profile) {
  41     fake_event_router_.reset(new FakeEventRouter(profile));
  42   }
  43
  44   EventRouter* event_router() override { return fake_event_router_.get(); }
  45
  46  private:
  47   scoped_ptr<FakeEventRouter> fake_event_router_;
  48 };
  49
  50 // Factory function to register for the ExtensionSystem.
  51 KeyedService* BuildFakeExtensionSystem(content::BrowserContext* profile) {
  52   return new FakeExtensionSystem(static_cast<Profile*>(profile));
  53 }
  54
  55 namespace {
  56
  57 class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
  58  public:
  59   void StartCallback(bool success, const std::string& error) {
  60     started_ = true;
  61     start_success_ = success;
  62     start_error_ = error;
  63   }
  64
  65   void CancelCallback(bool success, const std::string& error) {
  66     cancelled_ = true;
  67     cancel_success_ = true;
  68     cancel_error_ = error;
  69   }
  70
  71  protected:
  72   ImageWriterOperationManagerTest()
  73       : started_(false),
  74         start_success_(false) {
  75   }
  76
  77   void SetUp() override {
  78     ImageWriterUnitTestBase::SetUp();
  79     extension_system_ = static_cast<FakeExtensionSystem*>(
  80         ExtensionSystemFactory::GetInstance()->
  81             SetTestingFactoryAndUse(&test_profile_, &BuildFakeExtensionSystem));
  82     event_router_ = static_cast<FakeEventRouter*>(
  83         extension_system_->event_router());
  84   }
  85
  86   bool started_;
  87   bool start_success_;
  88   std::string start_error_;
  89
  90   bool cancelled_;
  91   bool cancel_success_;
  92   std::string cancel_error_;
  93
  94   TestingProfile test_profile_;
  95   FakeExtensionSystem* extension_system_;
  96   FakeEventRouter* event_router_;
  97
  98 #if defined(OS_CHROMEOS)
  99   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 100   chromeos::ScopedTestCrosSettings test_cros_settings_;
 101   chromeos::ScopedTestUserManager test_user_manager_;
 102 #endif
 103 };
 104
 105 TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
 106   OperationManager manager(&test_profile_);
 107
 108   manager.StartWriteFromFile(
 109       kDummyExtensionId,
 110       test_utils_.GetImagePath(),
 111       test_utils_.GetDevicePath().AsUTF8Unsafe(),
 112       base::Bind(&ImageWriterOperationManagerTest::StartCallback,
 113                  base::Unretained(this)));
 114
 115   EXPECT_TRUE(started_);
 116   EXPECT_TRUE(start_success_);
 117   EXPECT_EQ("", start_error_);
 118
 119   manager.CancelWrite(
 120       kDummyExtensionId,
 121       base::Bind(&ImageWriterOperationManagerTest::CancelCallback,
 122                  base::Unretained(this)));
 123
 124   EXPECT_TRUE(cancelled_);
 125   EXPECT_TRUE(cancel_success_);
 126   EXPECT_EQ("", cancel_error_);
 127
 128   base::RunLoop().RunUntilIdle();
 129 }
 130
 131 TEST_F(ImageWriterOperationManagerTest, DestroyPartitions) {
 132   OperationManager manager(&test_profile_);
 133
 134   manager.DestroyPartitions(
 135       kDummyExtensionId,
 136       test_utils_.GetDevicePath().AsUTF8Unsafe(),
 137       base::Bind(&ImageWriterOperationManagerTest::StartCallback,
 138                  base::Unretained(this)));
 139
 140   EXPECT_TRUE(started_);
 141   EXPECT_TRUE(start_success_);
 142   EXPECT_EQ("", start_error_);
 143
 144   manager.CancelWrite(
 145       kDummyExtensionId,
 146       base::Bind(&ImageWriterOperationManagerTest::CancelCallback,
 147                  base::Unretained(this)));
 148
 149   EXPECT_TRUE(cancelled_);
 150   EXPECT_TRUE(cancel_success_);
 151   EXPECT_EQ("", cancel_error_);
 152
 153   base::RunLoop().RunUntilIdle();
 154 }
 155
 156 } // namespace
 157 } // namespace image_writer
 158 } // namespace extensions