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