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/files/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/mock_special_storage_policy.h"
23 #include "content/public/test/test_browser_thread.h"
24 #include "content/public/test/test_file_system_options.h"
25 #include "storage/browser/fileapi/async_file_util.h"
26 #include "storage/browser/fileapi/external_mount_points.h"
27 #include "storage/browser/fileapi/file_system_context.h"
28 #include "storage/browser/fileapi/file_system_operation_context.h"
29 #include "storage/browser/fileapi/file_system_operation_runner.h"
30 #include "testing/gtest/include/gtest/gtest.h"
32 using storage::FileSystemOperationContext;
33 using storage::FileSystemOperation;
34 using storage::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(storage::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 ~TestITunesDataProvider() override {}
76 void RefreshData(const ReadyCallback& ready_callback) override {
77 ready_callback.Run(true /* success */);
80 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 ~TestITunesFileUtil() override {}
107 ITunesDataProvider* GetDataProvider() override { return data_provider_; }
109 ITunesDataProvider* data_provider_;
112 class TestMediaFileSystemBackend : public MediaFileSystemBackend {
114 TestMediaFileSystemBackend(const base::FilePath& profile_path,
115 ITunesFileUtil* itunes_file_util)
116 : MediaFileSystemBackend(
118 MediaFileSystemBackend::MediaTaskRunner().get()),
119 test_file_util_(itunes_file_util) {}
121 storage::AsyncFileUtil* GetAsyncFileUtil(
122 storage::FileSystemType type) override {
123 if (type != storage::kFileSystemTypeItunes)
126 return test_file_util_.get();
130 scoped_ptr<storage::AsyncFileUtil> test_file_util_;
133 class ItunesFileUtilTest : public testing::Test {
136 : io_thread_(content::BrowserThread::IO, &message_loop_) {
138 virtual ~ItunesFileUtilTest() {}
140 void SetUpDataProvider() {
141 ASSERT_TRUE(fake_library_dir_.CreateUniqueTempDir());
145 fake_library_dir_.path().AppendASCII(kITunesLibraryXML),
149 itunes_data_provider_.reset(
150 new TestITunesDataProvider(fake_library_dir_.path()));
153 virtual void SetUp() override {
154 ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
155 ImportedMediaGalleryRegistry::GetInstance()->Initialize();
157 scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
158 new content::MockSpecialStoragePolicy();
160 // Initialize fake ItunesDataProvider on media task runner thread.
161 MediaFileSystemBackend::MediaTaskRunner()->PostTask(
163 base::Bind(&ItunesFileUtilTest::SetUpDataProvider,
164 base::Unretained(this)));
165 base::WaitableEvent event(true, false /* initially_signalled */);
166 MediaFileSystemBackend::MediaTaskRunner()->PostTask(
168 base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
171 media_path_filter_.reset(new MediaPathFilter());
172 ScopedVector<storage::FileSystemBackend> additional_providers;
173 additional_providers.push_back(new TestMediaFileSystemBackend(
175 new TestITunesFileUtil(media_path_filter_.get(),
176 itunes_data_provider_.get())));
178 file_system_context_ = new storage::FileSystemContext(
179 base::MessageLoopProxy::current().get(),
180 base::MessageLoopProxy::current().get(),
181 storage::ExternalMountPoints::CreateRefCounted().get(),
182 storage_policy.get(),
184 additional_providers.Pass(),
185 std::vector<storage::URLRequestAutoMountHandler>(),
187 content::CreateAllowFileAccessOptions());
191 void TestNonexistentFolder(const std::string& path_append) {
192 FileSystemOperation::FileEntryList contents;
193 FileSystemURL url = CreateURL(path_append);
194 bool completed = false;
195 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
197 ASSERT_FALSE(completed);
200 FileSystemURL CreateURL(const std::string& path) const {
201 base::FilePath virtual_path =
202 ImportedMediaGalleryRegistry::GetInstance()->ImportedRoot();
203 virtual_path = virtual_path.AppendASCII("itunes");
204 virtual_path = virtual_path.AppendASCII(path);
205 return file_system_context_->CreateCrackedFileSystemURL(
206 GURL("http://www.example.com"),
207 storage::kFileSystemTypeItunes,
211 storage::FileSystemOperationRunner* operation_runner() const {
212 return file_system_context_->operation_runner();
215 scoped_refptr<storage::FileSystemContext> file_system_context() const {
216 return file_system_context_;
219 TestITunesDataProvider* data_provider() const {
220 return itunes_data_provider_.get();
224 base::MessageLoop message_loop_;
225 content::TestBrowserThread io_thread_;
227 base::ScopedTempDir profile_dir_;
228 base::ScopedTempDir fake_library_dir_;
230 scoped_refptr<storage::FileSystemContext> file_system_context_;
231 scoped_ptr<MediaPathFilter> media_path_filter_;
232 scoped_ptr<TestITunesDataProvider> itunes_data_provider_;
234 DISALLOW_COPY_AND_ASSIGN(ItunesFileUtilTest);
237 TEST_F(ItunesFileUtilTest, RootContents) {
238 FileSystemOperation::FileEntryList contents;
239 FileSystemURL url = CreateURL("");
240 bool completed = false;
241 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
243 ASSERT_TRUE(completed);
244 ASSERT_EQ(2u, contents.size());
246 EXPECT_FALSE(contents.front().is_directory);
247 EXPECT_TRUE(contents.back().is_directory);
249 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesLibraryXML).value(),
250 contents.front().name);
251 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMediaDir).value(),
252 contents.back().name);
255 TEST_F(ItunesFileUtilTest, ItunesMediaDirectoryContentsNoAutoAdd) {
256 data_provider()->SetProvideAutoAddDir(false);
258 FileSystemOperation::FileEntryList contents;
259 FileSystemURL url = CreateURL(kITunesMediaDir);
260 bool completed = false;
261 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
263 ASSERT_TRUE(completed);
264 ASSERT_EQ(1u, contents.size());
266 EXPECT_TRUE(contents.front().is_directory);
267 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMusicDir).value(),
268 contents.back().name);
271 TEST_F(ItunesFileUtilTest, ItunesMediaDirectoryContentsAutoAdd) {
272 data_provider()->SetProvideAutoAddDir(true);
274 FileSystemOperation::FileEntryList contents;
275 FileSystemURL url = CreateURL(kITunesMediaDir);
276 bool completed = false;
277 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
279 ASSERT_TRUE(completed);
280 ASSERT_EQ(2u, contents.size());
282 EXPECT_TRUE(contents.front().is_directory);
283 EXPECT_TRUE(contents.back().is_directory);
285 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesAutoAddDir).value(),
286 contents.front().name);
287 EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kITunesMusicDir).value(),
288 contents.back().name);
291 TEST_F(ItunesFileUtilTest, ItunesAutoAddDirEnumerate) {
292 data_provider()->SetProvideAutoAddDir(true);
293 ASSERT_EQ(0, base::WriteFile(
294 data_provider()->auto_add_path().AppendASCII("baz.ogg"), NULL, 0));
296 FileSystemOperation::FileEntryList contents;
297 FileSystemURL url = CreateURL(
298 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir);
299 bool completed = false;
301 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
302 ASSERT_TRUE(completed);
303 ASSERT_EQ(1u, contents.size());
304 EXPECT_FALSE(contents.front().is_directory);
305 EXPECT_EQ(base::FilePath().AppendASCII("baz.ogg").value(),
306 contents.front().name);
309 TEST_F(ItunesFileUtilTest, ItunesAutoAddDirEnumerateNested) {
310 data_provider()->SetProvideAutoAddDir(true);
311 base::FilePath nested_dir =
312 data_provider()->auto_add_path().AppendASCII("foo").AppendASCII("bar");
313 ASSERT_TRUE(base::CreateDirectory(nested_dir));
315 base::WriteFile(nested_dir.AppendASCII("baz.ogg"), NULL, 0));
317 FileSystemOperation::FileEntryList contents;
318 FileSystemURL url = CreateURL(
319 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir);
320 bool completed = false;
322 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
323 ASSERT_TRUE(completed);
324 ASSERT_EQ(1u, contents.size());
325 EXPECT_TRUE(contents.front().is_directory);
326 EXPECT_EQ(base::FilePath().AppendASCII("foo").value(), contents.front().name);
330 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir + "/foo");
332 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
333 ASSERT_TRUE(completed);
334 ASSERT_EQ(1u, contents.size());
335 EXPECT_TRUE(contents.front().is_directory);
336 EXPECT_EQ(base::FilePath().AppendASCII("bar").value(), contents.front().name);
340 std::string(kITunesMediaDir) + "/" + kITunesAutoAddDir + "/foo/bar");
342 ReadDirectoryTestHelper(operation_runner(), url, &contents, &completed);
343 ASSERT_TRUE(completed);
344 ASSERT_EQ(1u, contents.size());
345 EXPECT_FALSE(contents.front().is_directory);
346 EXPECT_EQ(base::FilePath().AppendASCII("baz.ogg").value(),
347 contents.front().name);
350 } // namespace itunes