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 21namespace extensions { 22namespace image_writer { 23 24// A fake for the EventRouter. If tests require monitoring of interaction with 25// the event router put the logic here. 26class 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(). 38class 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. 54KeyedService* BuildFakeExtensionSystem(content::BrowserContext* profile) { 55 return new FakeExtensionSystem(static_cast<Profile*>(profile)); 56} 57 58namespace { 59 60class 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 108TEST_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 134TEST_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 162