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.
10 #include "base/bind_helpers.h"
11 #include "base/file_util.h"
12 #include "base/files/scoped_temp_dir.h"
13 #include "base/run_loop.h"
14 #include "base/synchronization/waitable_event.h"
15 #include "base/time/time.h"
16 #include "chrome/browser/media_galleries/fileapi/itunes_data_provider.h"
17 #include "chrome/browser/media_galleries/fileapi/itunes_file_util.h"
18 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
19 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
20 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
21 #include "content/public/browser/browser_thread.h"
22 #include "content/public/test/test_browser_thread.h"
23 #include "content/public/test/test_file_system_options.h"
24 #include "testing/gtest/include/gtest/gtest.h"
25 #include "webkit/browser/fileapi/async_file_util.h"
26 #include "webkit/browser/fileapi/external_mount_points.h"
27 #include "webkit/browser/fileapi/file_system_context.h"
28 #include "webkit/browser/fileapi/file_system_operation_context.h"
29 #include "webkit/browser/fileapi/file_system_operation_runner.h"
30 #include "webkit/browser/quota/mock_special_storage_policy.h"
32 using fileapi::FileSystemOperationContext;
33 using fileapi::FileSystemOperation;
34 using fileapi::FileSystemURL;
40 void ReadDirectoryTestHelperCallback(
41 base::RunLoop* run_loop,
42 FileSystemOperation::FileEntryList* contents,
43 bool* completed, base::File::Error error,
44 const FileSystemOperation::FileEntryList& file_list,
47 *completed = (!has_more && error == base::File::FILE_OK);
48 *contents = file_list;
52 void ReadDirectoryTestHelper(fileapi::FileSystemOperationRunner* runner,
53 const FileSystemURL& url,
54 FileSystemOperation::FileEntryList* contents,
58 base::RunLoop run_loop;
59 runner->ReadDirectory(
60 url, base::Bind(&ReadDirectoryTestHelperCallback, &run_loop, contents,
67 class TestITunesDataProvider : public ITunesDataProvider {
69 explicit TestITunesDataProvider(const base::FilePath& fake_library_path)
70 : ITunesDataProvider(fake_library_path) {
71 EXPECT_TRUE(fake_auto_add_dir_.CreateUniqueTempDir());
74 virtual ~TestITunesDataProvider() {}
76 virtual void RefreshData(const ReadyCallback& ready_callback) OVERRIDE {
77 ready_callback.Run(true /* success */);
80 virtual const base::FilePath& auto_add_path() const OVERRIDE {
81 return fake_auto_add_dir_.path();
84 void SetProvideAutoAddDir(bool provide_auto_add_dir) {
85 if (provide_auto_add_dir) {
86 if (!fake_auto_add_dir_.IsValid())
87 ASSERT_TRUE(fake_auto_add_dir_.CreateUniqueTempDir());
89 ASSERT_TRUE(fake_auto_add_dir_.Delete());
94 base::ScopedTempDir fake_auto_add_dir_;
97 class TestITunesFileUtil : public ITunesFileUtil {
99 explicit TestITunesFileUtil(MediaPathFilter* media_path_filter,
100 ITunesDataProvider* data_provider)
101 : ITunesFileUtil(media_path_filter),
102 data_provider_(data_provider) {
104 virtual ~TestITunesFileUtil() {}
107 virtual ITunesDataProvider* GetDataProvider() OVERRIDE {
108 return data_provider_;
111 ITunesDataProvider* data_provider_;
114 class TestMediaFileSystemBackend : public MediaFileSystemBackend {
116 TestMediaFileSystemBackend(const base::FilePath& profile_path,
117 ITunesFileUtil* itunes_file_util)
118 : MediaFileSystemBackend(
120 MediaFileSystemBackend::MediaTaskRunner().get()),
121 test_file_util_(itunes_file_util) {}
123 virtual fileapi::AsyncFileUtil*
124 GetAsyncFileUtil(fileapi::FileSystemType type) OVERRIDE {
125 if (type != fileapi::kFileSystemTypeItunes)
128 return test_file_util_.get();
132 scoped_ptr<fileapi::AsyncFileUtil> test_file_util_;
135 class ItunesFileUtilTest : public testing::Test {
138 : io_thread_(content::BrowserThread::IO, &message_loop_) {
140 virtual ~ItunesFileUtilTest() {}
142 void SetUpDataProvider() {
143 ASSERT_TRUE(fake_library_dir_.CreateUniqueTempDir());
147 fake_library_dir_.path().AppendASCII(kITunesLibraryXML),
151 itunes_data_provider_.reset(
152 new TestITunesDataProvider(fake_library_dir_.path()));
155 virtual void SetUp() OVERRIDE {
156 ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
157 ImportedMediaGalleryRegistry::GetInstance()->Initialize();
159 scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
160 new quota::MockSpecialStoragePolicy();
162 // Initialize fake ItunesDataProvider on media task runner thread.
163 MediaFileSystemBackend::MediaTaskRunner()->PostTask(
165 base::Bind(&ItunesFileUtilTest::SetUpDataProvider,
166 base::Unretained(this)));
167 base::WaitableEvent event(true, false /* initially_signalled */);
168 MediaFileSystemBackend::MediaTaskRunner()->PostTask(
170 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
173 media_path_filter_.reset(new MediaPathFilter());
174 ScopedVector<fileapi::FileSystemBackend> additional_providers;
175 additional_providers.push_back(new TestMediaFileSystemBackend(
177 new TestITunesFileUtil(media_path_filter_.get(),
178 itunes_data_provider_.get())));
180 file_system_context_ = new fileapi::FileSystemContext(
181 base::MessageLoopProxy::current().get(),
182 base::MessageLoopProxy::current().get(),
183 fileapi::ExternalMountPoints::CreateRefCounted().get(),
184 storage_policy.get(),
186 additional_providers.Pass(),
187 std::vector<fileapi::URLRequestAutoMountHandler>(),
189 content::CreateAllowFileAccessOptions());
193 void TestNonexistentFolder(const std::string& path_append) {
194 FileSystemOperation::FileEntryList contents;
195 FileSystemURL url = CreateURL(path_append);
196 bool completed = false;
197 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
199 ASSERT_FALSE(completed);
202 FileSystemURL CreateURL(const std::string& path) const {
203 base::FilePath virtual_path =
204 ImportedMediaGalleryRegistry::GetInstance()->ImportedRoot();
205 virtual_path = virtual_path.AppendASCII("itunes");
206 virtual_path = virtual_path.AppendASCII(path);
207 return file_system_context_->CreateCrackedFileSystemURL(
208 GURL("http://www.example.com"), fileapi::kFileSystemTypeItunes,
212 fileapi::FileSystemOperationRunner* operation_runner() const {
213 return file_system_context_->operation_runner();
216 scoped_refptr<fileapi::FileSystemContext> file_system_context() const {
217 return file_system_context_;
220 TestITunesDataProvider* data_provider() const {
221 return itunes_data_provider_.get();
225 base::MessageLoop message_loop_;
226 content::TestBrowserThread io_thread_;
228 base::ScopedTempDir profile_dir_;
229 base::ScopedTempDir fake_library_dir_;
231 scoped_refptr<fileapi::FileSystemContext> file_system_context_;
232 scoped_ptr<MediaPathFilter> media_path_filter_;
233 scoped_ptr<TestITunesDataProvider> itunes_data_provider_;
235 DISALLOW_COPY_AND_ASSIGN(ItunesFileUtilTest);
238 TEST_F(ItunesFileUtilTest, RootContents) {
239 FileSystemOperation::FileEntryList contents;
240 FileSystemURL url = CreateURL("");
241 bool completed = false;
242 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
244 ASSERT_TRUE(completed);
245 ASSERT_EQ(2u, contents.size());
247 EXPECT_FALSE(contents.front().is_directory);
248 EXPECT_TRUE(contents.back().is_directory);
250 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesLibraryXML).value(),
251 contents.front().name);
252 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMediaDir).value(),
253 contents.back().name);
256 TEST_F(ItunesFileUtilTest, ItunesMediaDirectoryContentsNoAutoAdd) {
257 data_provider()->SetProvideAutoAddDir(false);
259 FileSystemOperation::FileEntryList contents;
260 FileSystemURL url = CreateURL(kITunesMediaDir);
261 bool completed = false;
262 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
264 ASSERT_TRUE(completed);
265 ASSERT_EQ(1u, contents.size());
267 EXPECT_TRUE(contents.front().is_directory);
268 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMusicDir).value(),
269 contents.back().name);
272 TEST_F(ItunesFileUtilTest, ItunesMediaDirectoryContentsAutoAdd) {
273 data_provider()->SetProvideAutoAddDir(true);
275 FileSystemOperation::FileEntryList contents;
276 FileSystemURL url = CreateURL(kITunesMediaDir);
277 bool completed = false;
278 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
280 ASSERT_TRUE(completed);
281 ASSERT_EQ(2u, contents.size());
283 EXPECT_TRUE(contents.front().is_directory);
284 EXPECT_TRUE(contents.back().is_directory);
286 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesAutoAddDir).value(),
287 contents.front().name);
288 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMusicDir).value(),
289 contents.back().name);
292 TEST_F(ItunesFileUtilTest, ItunesAutoAddDirEnumerate) {
293 data_provider()->SetProvideAutoAddDir(true);
294 ASSERT_EQ(0, base::WriteFile(
295 data_provider()->auto_add_path().AppendASCII("baz.ogg"), NULL, 0));
297 FileSystemOperation::FileEntryList contents;
298 FileSystemURL url = CreateURL(
299 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir);
300 bool completed = false;
302 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
303 ASSERT_TRUE(completed);
304 ASSERT_EQ(1u, contents.size());
305 EXPECT_FALSE(contents.front().is_directory);
306 EXPECT_EQ(base::FilePath().AppendASCII("baz.ogg").value(),
307 contents.front().name);
310 TEST_F(ItunesFileUtilTest, ItunesAutoAddDirEnumerateNested) {
311 data_provider()->SetProvideAutoAddDir(true);
312 base::FilePath nested_dir =
313 data_provider()->auto_add_path().AppendASCII("foo").AppendASCII("bar");
314 ASSERT_TRUE(base::CreateDirectory(nested_dir));
316 base::WriteFile(nested_dir.AppendASCII("baz.ogg"), NULL, 0));
318 FileSystemOperation::FileEntryList contents;
319 FileSystemURL url = CreateURL(
320 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir);
321 bool completed = false;
323 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
324 ASSERT_TRUE(completed);
325 ASSERT_EQ(1u, contents.size());
326 EXPECT_TRUE(contents.front().is_directory);
327 EXPECT_EQ(base::FilePath().AppendASCII("foo").value(), contents.front().name);
331 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir + "/foo");
333 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
334 ASSERT_TRUE(completed);
335 ASSERT_EQ(1u, contents.size());
336 EXPECT_TRUE(contents.front().is_directory);
337 EXPECT_EQ(base::FilePath().AppendASCII("bar").value(), contents.front().name);
341 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir + "/foo/bar");
343 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
344 ASSERT_TRUE(completed);
345 ASSERT_EQ(1u, contents.size());
346 EXPECT_FALSE(contents.front().is_directory);
347 EXPECT_EQ(base::FilePath().AppendASCII("baz.ogg").value(),
348 contents.front().name);
351 } // namespace itunes