src/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   virtual void DispatchEventToExtension(
  31       const std::string& extension_id,
  32       scoped_ptr<extensions::Event> event) OVERRIDE {
  33     // Do nothing with the event as no tests currently care.
  34   }
  35 };
  36
  37 // A fake ExtensionSystem that returns a FakeEventRouter for event_router().
  38 class FakeExtensionSystem : public extensions::TestExtensionSystem {
  39  public:
  40   explicit FakeExtensionSystem(Profile* profile)
  41       : TestExtensionSystem(profile) {
  42     fake_event_router_.reset(new FakeEventRouter(profile));
  43   }
  44
  45   virtual EventRouter* event_router() OVERRIDE {
  46     return fake_event_router_.get();
  47   }
  48
  49  private:
  50   scoped_ptr<FakeEventRouter> fake_event_router_;
  51 };
  52
  53 // Factory function to register for the ExtensionSystem.
  54 KeyedService* BuildFakeExtensionSystem(content::BrowserContext* profile) {
  55   return new FakeExtensionSystem(static_cast<Profile*>(profile));
  56 }
  57
  58 namespace {
  59
  60 class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
  61  public:
  62   void StartCallback(bool success, const std::string& error) {
  63     started_ = true;
  64     start_success_ = success;
  65     start_error_ = error;
  66   }
  67
  68   void CancelCallback(bool success, const std::string& error) {
  69     cancelled_ = true;
  70     cancel_success_ = true;
  71     cancel_error_ = error;
  72   }
  73
  74  protected:
  75   ImageWriterOperationManagerTest()
  76       : started_(false),
  77         start_success_(false) {
  78   }
  79
  80   virtual void SetUp() OVERRIDE {
  81     ImageWriterUnitTestBase::SetUp();
  82     extension_system_ = static_cast<FakeExtensionSystem*>(
  83         ExtensionSystemFactory::GetInstance()->
  84             SetTestingFactoryAndUse(&test_profile_, &BuildFakeExtensionSystem));
  85     event_router_ = static_cast<FakeEventRouter*>(
  86         extension_system_->event_router());
  87   }
  88
  89   bool started_;
  90   bool start_success_;
  91   std::string start_error_;
  92
  93   bool cancelled_;
  94   bool cancel_success_;
  95   std::string cancel_error_;
  96
  97   TestingProfile test_profile_;
  98   FakeExtensionSystem* extension_system_;
  99   FakeEventRouter* event_router_;
 100
 101 #if defined(OS_CHROMEOS)
 102   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 103   chromeos::ScopedTestCrosSettings test_cros_settings_;
 104   chromeos::ScopedTestUserManager test_user_manager_;
 105 #endif
 106 };
 107
 108 TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
 109   OperationManager manager(&test_profile_);
 110
 111   manager.StartWriteFromFile(
 112       kDummyExtensionId,
 113       test_utils_.GetImagePath(),
 114       test_utils_.GetDevicePath().AsUTF8Unsafe(),
 115       base::Bind(&ImageWriterOperationManagerTest::StartCallback,
 116                  base::Unretained(this)));
 117
 118   EXPECT_TRUE(started_);
 119   EXPECT_TRUE(start_success_);
 120   EXPECT_EQ("", start_error_);
 121
 122   manager.CancelWrite(
 123       kDummyExtensionId,
 124       base::Bind(&ImageWriterOperationManagerTest::CancelCallback,
 125                  base::Unretained(this)));
 126
 127   EXPECT_TRUE(cancelled_);
 128   EXPECT_TRUE(cancel_success_);
 129   EXPECT_EQ("", cancel_error_);
 130
 131   base::RunLoop().RunUntilIdle();
 132 }
 133
 134 TEST_F(ImageWriterOperationManagerTest, DestroyPartitions) {
 135   OperationManager manager(&test_profile_);
 136
 137   manager.DestroyPartitions(
 138       kDummyExtensionId,
 139       test_utils_.GetDevicePath().AsUTF8Unsafe(),
 140       base::Bind(&ImageWriterOperationManagerTest::StartCallback,
 141                  base::Unretained(this)));
 142
 143   EXPECT_TRUE(started_);
 144   EXPECT_TRUE(start_success_);
 145   EXPECT_EQ("", start_error_);
 146
 147   manager.CancelWrite(
 148       kDummyExtensionId,
 149       base::Bind(&ImageWriterOperationManagerTest::CancelCallback,
 150                  base::Unretained(this)));
 151
 152   EXPECT_TRUE(cancelled_);
 153   EXPECT_TRUE(cancel_success_);
 154   EXPECT_EQ("", cancel_error_);
 155
 156   base::RunLoop().RunUntilIdle();
 157 }
 158
 159 } // namespace
 160 } // namespace image_writer
 161 } // namespace extensions