OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 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 <string> |
| 6 |
| 7 #include "base/memory/scoped_ptr.h" |
| 8 #include "base/memory/scoped_vector.h" |
| 9 #include "chrome/browser/chromeos/file_system_provider/observer.h" |
| 10 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h" |
| 11 #include "chrome/browser/chromeos/file_system_provider/service.h" |
| 12 #include "chrome/browser/chromeos/login/fake_user_manager.h" |
| 13 #include "chrome/test/base/testing_profile.h" |
| 14 #include "content/public/test/test_browser_thread_bundle.h" |
| 15 #include "testing/gtest/include/gtest/gtest.h" |
| 16 #include "webkit/browser/fileapi/external_mount_points.h" |
| 17 |
| 18 namespace chromeos { |
| 19 namespace file_system_provider { |
| 20 namespace { |
| 21 |
| 22 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; |
| 23 const char kFileSystemName[] = "Camera Pictures"; |
| 24 |
| 25 // Utility observer, logging events from file_system_provider::Service. |
| 26 class LoggingObserver : public Observer { |
| 27 public: |
| 28 LoggingObserver() {} |
| 29 virtual ~LoggingObserver() {} |
| 30 |
| 31 // file_system_provider::Observer overrides. |
| 32 virtual void OnProvidedFileSystemRegistered( |
| 33 const ProvidedFileSystem& file_system) OVERRIDE { |
| 34 registered.push_back(new const ProvidedFileSystem(file_system)); |
| 35 } |
| 36 |
| 37 virtual void OnProvidedFileSystemUnregistered( |
| 38 const ProvidedFileSystem& file_system) OVERRIDE { |
| 39 unregistered.push_back(new const ProvidedFileSystem(file_system)); |
| 40 } |
| 41 |
| 42 ScopedVector<const ProvidedFileSystem> registered; |
| 43 ScopedVector<const ProvidedFileSystem> unregistered; |
| 44 }; |
| 45 |
| 46 } // namespace |
| 47 |
| 48 class FileSystemProviderServiceTest : public testing::Test { |
| 49 protected: |
| 50 FileSystemProviderServiceTest() {} |
| 51 virtual ~FileSystemProviderServiceTest() {} |
| 52 |
| 53 virtual void SetUp() OVERRIDE { |
| 54 user_manager_ = new FakeUserManager(); |
| 55 user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_)); |
| 56 profile_.reset(new TestingProfile); |
| 57 user_manager_->AddUser(profile_->GetProfileName()); |
| 58 file_system_provider_service_.reset(new Service(profile_.get())); |
| 59 } |
| 60 |
| 61 virtual void TearDown() { |
| 62 fileapi::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems(); |
| 63 } |
| 64 |
| 65 content::TestBrowserThreadBundle thread_bundle_; |
| 66 scoped_ptr<TestingProfile> profile_; |
| 67 scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_; |
| 68 FakeUserManager* user_manager_; |
| 69 scoped_ptr<Service> file_system_provider_service_; |
| 70 }; |
| 71 |
| 72 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem) { |
| 73 LoggingObserver observer; |
| 74 file_system_provider_service_->AddObserver(&observer); |
| 75 |
| 76 const std::string file_system_id = |
| 77 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 78 kFileSystemName); |
| 79 |
| 80 EXPECT_NE("", file_system_id); |
| 81 ASSERT_EQ(1u, observer.registered.size()); |
| 82 EXPECT_EQ(kExtensionId, observer.registered[0]->extension_id()); |
| 83 EXPECT_EQ("mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
| 84 observer.registered[0]->file_system_id()); |
| 85 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
| 86 observer.registered[0]->mount_path().AsUTF8Unsafe()); |
| 87 EXPECT_EQ(kFileSystemName, observer.registered[0]->file_system_name()); |
| 88 ASSERT_EQ(0u, observer.unregistered.size()); |
| 89 |
| 90 std::vector<ProvidedFileSystem> provided_file_systems = |
| 91 file_system_provider_service_->GetRegisteredFileSystems(); |
| 92 ASSERT_EQ(1u, provided_file_systems.size()); |
| 93 |
| 94 file_system_provider_service_->RemoveObserver(&observer); |
| 95 } |
| 96 |
| 97 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_UniqueIds) { |
| 98 LoggingObserver observer; |
| 99 file_system_provider_service_->AddObserver(&observer); |
| 100 |
| 101 std::string file_system_first_id = |
| 102 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 103 kFileSystemName); |
| 104 ASSERT_NE("", file_system_first_id); |
| 105 |
| 106 std::string file_system_second_id = |
| 107 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 108 kFileSystemName); |
| 109 ASSERT_NE("", file_system_second_id); |
| 110 |
| 111 ASSERT_NE(file_system_first_id, file_system_second_id); |
| 112 ASSERT_EQ(2u, observer.registered.size()); |
| 113 |
| 114 std::vector<ProvidedFileSystem> provided_file_systems = |
| 115 file_system_provider_service_->GetRegisteredFileSystems(); |
| 116 ASSERT_EQ(2u, provided_file_systems.size()); |
| 117 |
| 118 file_system_provider_service_->RemoveObserver(&observer); |
| 119 } |
| 120 |
| 121 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_StressTest) { |
| 122 LoggingObserver observer; |
| 123 file_system_provider_service_->AddObserver(&observer); |
| 124 |
| 125 const size_t kMaxFileSystems = 16; |
| 126 for (size_t i = 0; i < kMaxFileSystems; ++i) { |
| 127 std::string file_system_id = |
| 128 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 129 kFileSystemName); |
| 130 ASSERT_NE("", file_system_id); |
| 131 } |
| 132 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); |
| 133 |
| 134 // The next file system is out of limit, and registering it should fail. |
| 135 std::string file_system_id = |
| 136 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 137 kFileSystemName); |
| 138 ASSERT_EQ("", file_system_id); |
| 139 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); |
| 140 |
| 141 std::vector<ProvidedFileSystem> provided_file_systems = |
| 142 file_system_provider_service_->GetRegisteredFileSystems(); |
| 143 ASSERT_EQ(kMaxFileSystems, provided_file_systems.size()); |
| 144 |
| 145 file_system_provider_service_->RemoveObserver(&observer); |
| 146 } |
| 147 |
| 148 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem) { |
| 149 LoggingObserver observer; |
| 150 file_system_provider_service_->AddObserver(&observer); |
| 151 |
| 152 const std::string file_system_id = |
| 153 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 154 kFileSystemName); |
| 155 ASSERT_NE("", file_system_id); |
| 156 ASSERT_EQ(1u, observer.registered.size()); |
| 157 |
| 158 const bool result = file_system_provider_service_->UnregisterFileSystem( |
| 159 kExtensionId, file_system_id); |
| 160 ASSERT_TRUE(result); |
| 161 ASSERT_EQ(1u, observer.unregistered.size()); |
| 162 |
| 163 EXPECT_EQ(kExtensionId, observer.unregistered[0]->extension_id()); |
| 164 EXPECT_EQ("mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
| 165 observer.unregistered[0]->file_system_id()); |
| 166 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
| 167 observer.unregistered[0]->mount_path().AsUTF8Unsafe()); |
| 168 EXPECT_EQ(kFileSystemName, observer.unregistered[0]->file_system_name()); |
| 169 |
| 170 std::vector<ProvidedFileSystem> provided_file_systems = |
| 171 file_system_provider_service_->GetRegisteredFileSystems(); |
| 172 ASSERT_EQ(0u, provided_file_systems.size()); |
| 173 |
| 174 file_system_provider_service_->RemoveObserver(&observer); |
| 175 } |
| 176 |
| 177 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem_WrongExtensionId) { |
| 178 LoggingObserver observer; |
| 179 file_system_provider_service_->AddObserver(&observer); |
| 180 |
| 181 const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe"; |
| 182 |
| 183 const std::string file_system_id = |
| 184 file_system_provider_service_->RegisterFileSystem(kExtensionId, |
| 185 kFileSystemName); |
| 186 ASSERT_NE("", file_system_id); |
| 187 ASSERT_EQ(1u, observer.registered.size()); |
| 188 |
| 189 const bool result = file_system_provider_service_->UnregisterFileSystem( |
| 190 kWrongExtensionId, file_system_id); |
| 191 ASSERT_FALSE(result); |
| 192 ASSERT_EQ(0u, observer.unregistered.size()); |
| 193 |
| 194 std::vector<ProvidedFileSystem> provided_file_systems = |
| 195 file_system_provider_service_->GetRegisteredFileSystems(); |
| 196 ASSERT_EQ(1u, provided_file_systems.size()); |
| 197 |
| 198 file_system_provider_service_->RemoveObserver(&observer); |
| 199 } |
| 200 |
| 201 } // namespace file_system_provider |
| 202 } // namespace chromeos |
OLD | NEW |