xref: /external/chromium_org/chrome/browser/media_galleries/fileapi/iphoto_data_provider_browsertest.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <string>
#include <vector>

#include "base/bind.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/format_macros.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
#include "chrome/browser/media_galleries/fileapi/iphoto_data_provider.h"
#include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
#include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "content/public/browser/browser_thread.h"
#include "url/gurl.h"

using base::FilePath;

namespace iphoto {

class TestIPhotoDataProvider : public IPhotoDataProvider {
 public:
  TestIPhotoDataProvider(const base::FilePath& xml_library_path,
                         const base::Closure& callback)
      : IPhotoDataProvider(xml_library_path),
        callback_(callback) {
  }
  virtual ~TestIPhotoDataProvider() {}

 private:
  virtual void OnLibraryChanged(const base::FilePath& path,
                                bool error) OVERRIDE {
    IPhotoDataProvider::OnLibraryChanged(path, error);
    callback_.Run();
  }

  base::Closure callback_;

  DISALLOW_COPY_AND_ASSIGN(TestIPhotoDataProvider);
};

class IPhotoDataProviderTest : public InProcessBrowserTest {
 public:
  IPhotoDataProviderTest() {}
  virtual ~IPhotoDataProviderTest() {}

 protected:
  virtual void SetUp() OVERRIDE {
    ASSERT_TRUE(library_dir_.CreateUniqueTempDir());
    WriteLibraryInternal();
    // The ImportedMediaGalleryRegistry is created on which ever thread calls
    // GetInstance() first.  It shouldn't matter what thread creates, however
    // in practice it is always created on the UI thread, so this calls
    // GetInstance here to mirror those real conditions.
    ImportedMediaGalleryRegistry::GetInstance();
    InProcessBrowserTest::SetUp();
  }

  void RunTest() {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
    base::RunLoop loop;
    quit_closure_ = loop.QuitClosure();
    MediaFileSystemBackend::MediaTaskRunner()->PostTask(
        FROM_HERE,
        base::Bind(&IPhotoDataProviderTest::StartTestOnMediaTaskRunner,
                   base::Unretained(this)));
    loop.Run();
  }

  void WriteLibrary(const base::Closure& callback) {
    SetLibraryChangeCallback(callback);
    WriteLibraryInternal();
  }

  void SetLibraryChangeCallback(const base::Closure& callback) {
    EXPECT_TRUE(library_changed_callback_.is_null());
    library_changed_callback_ = callback;
  }

  IPhotoDataProvider* data_provider() const {
    return ImportedMediaGalleryRegistry::IPhotoDataProvider();
  }

  const base::FilePath& library_dir() const {
    return library_dir_.path();
  }

  base::FilePath XmlFile() const {
    return library_dir_.path().AppendASCII("library.xml");
  }

  // Start the test. The data provider is refreshed before calling StartTest
  // and the result of the refresh is passed in.
  virtual void StartTest(bool parse_success) = 0;

  void TestDone() {
    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
    ImportedMediaGalleryRegistry* imported_registry =
        ImportedMediaGalleryRegistry::GetInstance();
    imported_registry->iphoto_data_provider_.reset();
    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                     quit_closure_);
  }

  // Override to provide a full library string.
  virtual std::string GetLibraryString() {
    return "<plist><dict>\n</dict></plist>\n";
  }

 private:
  void StartTestOnMediaTaskRunner() {
    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
    ImportedMediaGalleryRegistry* imported_registry =
        ImportedMediaGalleryRegistry::GetInstance();
    imported_registry->iphoto_data_provider_.reset(
        new TestIPhotoDataProvider(
            XmlFile(),
            base::Bind(&IPhotoDataProviderTest::OnLibraryChanged,
                       base::Unretained(this))));
    data_provider()->RefreshData(base::Bind(&IPhotoDataProviderTest::StartTest,
                                            base::Unretained(this)));
  };

  void OnLibraryChanged() {
    DCHECK(MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread());
    if (!library_changed_callback_.is_null()) {
      library_changed_callback_.Run();
      library_changed_callback_.Reset();
    }
  }

  void WriteLibraryInternal() {
    std::string xml = GetLibraryString();
    ASSERT_EQ(static_cast<int>(xml.size()),
              base::WriteFile(XmlFile(), xml.c_str(), xml.size()));
  }

  base::ScopedTempDir library_dir_;

  base::Closure library_changed_callback_;

  base::Closure quit_closure_;

  DISALLOW_COPY_AND_ASSIGN(IPhotoDataProviderTest);
};

class IPhotoDataProviderBasicTest : public IPhotoDataProviderTest {
 public:
  IPhotoDataProviderBasicTest() {}
  virtual ~IPhotoDataProviderBasicTest() {}

  virtual std::string GetLibraryString() OVERRIDE {
    return "<plist><dict>\n"
      "<key>List of Albums</key>\n"
      "<array>"
      "    <dict>\n"
      "      <key>AlbumId</key>"
      "      <integer>14</integer>"
      "      <key>AlbumName</key>"
      "      <string>Album1</string>"
      "      <key>KeyList</key>"
      "      <array>"
      "      <string>1</string>"
      "      <string>3</string>"  // [3] and [4] are name dupes
      "      <string>4</string>"
      "      </array>"
      "    </dict>\n"
      "    <dict>\n"
      "      <key>AlbumId</key>"
      "      <integer>15</integer>"
      "      <key>AlbumName</key>"
      "      <string>Album2</string>"
      "      <key>KeyList</key>"
      "      <array>"
      "      <string>2</string>"
      "      </array>"
      "    </dict>\n"
      "    <dict>\n"
      "      <key>AlbumId</key>"
      "      <integer>16</integer>"
      "      <key>AlbumName</key>"
      "      <string>Album5</string>"
      "      <key>KeyList</key>"
      "      <array>"
      "      <string>5</string>"  // A name dupe of [2], but in another album.
      "      </array>"
      "    </dict>\n"
      "</array>\n"
      "<key>Master Image List</key>\n"
      "<dict>\n"
      "  <key>1</key>\n"
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption</key>"
      "    <string>caption</string>"
      "    <key>GUID</key>\n"
      "    <string>guid1</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/path1.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/thumb1.jpg</string>"
      "  </dict>\n"
      "  <key>2</key>\n"
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption</key>"
      "    <string>caption2</string>"
      "    <key>GUID</key>\n"
      "    <string>guid2</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/path2.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/thumb2.jpg</string>"
      "  </dict>\n"
      "  <key>3</key>\n"
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption</key>"
      "    <string>caption3</string>"
      "    <key>GUID</key>\n"
      "    <string>guid3</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/path3.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/thumb3.jpg</string>"
      "  </dict>\n"
      "  <key>4</key>\n"  // A name duplicate of [3] in another path.
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption</key>"
      "    <string>caption</string>"
      "    <key>GUID</key>\n"
      "    <string>guid3</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/dupe/path3.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/dupe/thumb3.jpg</string>"
      "  </dict>\n"
      "  <key>5</key>\n"  // A name duplicate of [2] in another path.
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption</key>"
      "    <string>caption5</string>"
      "    <key>GUID</key>\n"
      "    <string>guid2</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/dupe/path2.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/dupe/thumb2.jpg</string>"
      "    <key>OriginalPath</key>"             \
      "    <string>/original/vol/another2.jpg</string>"  \
      "  </dict>\n"
      "</dict>\n"
      "</dict></plist>\n";
  }

  virtual void StartTest(bool parse_success) OVERRIDE {
    EXPECT_TRUE(parse_success);

    std::vector<std::string> names = data_provider()->GetAlbumNames();
    EXPECT_EQ(3U, names.size());
    EXPECT_EQ("Album1", names[0]);

    EXPECT_EQ(FilePath("/vol/path1.jpg").value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album1", "path1.jpg").value());
    EXPECT_EQ(FilePath("/vol/path3.jpg").value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album1", "path3.jpg").value());
    EXPECT_EQ(FilePath("/vol/dupe/path3.jpg").value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album1", "path3(4).jpg").value());
    EXPECT_EQ(FilePath().value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album1", "path5.jpg").value());

    // path2.jpg is name-duped, but in different albums, and so should not
    // be mangled.
    EXPECT_EQ(FilePath("/vol/dupe/path2.jpg").value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album5", "path2.jpg").value());
    EXPECT_EQ(FilePath("/vol/path2.jpg").value(),
              data_provider()->GetPhotoLocationInAlbum(
                  "Album2", "path2.jpg").value());

    std::map<std::string, base::FilePath> photos =
        data_provider()->GetAlbumContents("nonexistent");
    EXPECT_EQ(0U, photos.size());
    photos = data_provider()->GetAlbumContents("Album1");
    EXPECT_EQ(3U, photos.size());
    EXPECT_TRUE(ContainsKey(photos, "path1.jpg"));
    EXPECT_FALSE(ContainsKey(photos, "path2.jpg"));
    EXPECT_TRUE(ContainsKey(photos, "path3.jpg"));
    EXPECT_TRUE(ContainsKey(photos, "path3(4).jpg"));
    EXPECT_EQ(FilePath("/vol/path1.jpg").value(), photos["path1.jpg"].value());
    EXPECT_EQ(FilePath("/vol/path3.jpg").value(),
        photos["path3.jpg"].value());
    EXPECT_EQ(FilePath("/vol/dupe/path3.jpg").value(),
        photos["path3(4).jpg"].value());

    photos = data_provider()->GetAlbumContents("Album2");
    EXPECT_EQ(1U, photos.size());
    EXPECT_TRUE(ContainsKey(photos, "path2.jpg"));

    EXPECT_FALSE(data_provider()->HasOriginals("Album1"));
    EXPECT_TRUE(data_provider()->HasOriginals("Album5"));
    std::map<std::string, base::FilePath> originals =
        data_provider()->GetOriginals("Album1");
    EXPECT_EQ(0U, originals.size());
    originals = data_provider()->GetOriginals("Album5");
    EXPECT_EQ(1U, originals.size());
    EXPECT_TRUE(ContainsKey(originals, "path2.jpg"));
    EXPECT_FALSE(ContainsKey(originals, "path1.jpg"));
    EXPECT_EQ(FilePath("/original/vol/another2.jpg").value(),
              originals["path2.jpg"].value());
    base::FilePath original_path =
        data_provider()->GetOriginalPhotoLocation("Album5", "path2.jpg");
    EXPECT_EQ(FilePath("/original/vol/another2.jpg").value(),
              original_path.value());

    TestDone();
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(IPhotoDataProviderBasicTest);
};

class IPhotoDataProviderRefreshTest : public IPhotoDataProviderTest {
 public:
  IPhotoDataProviderRefreshTest() {}
  virtual ~IPhotoDataProviderRefreshTest() {}

  std::string another_album;

  virtual std::string GetLibraryString() OVERRIDE {
    return "<plist><dict>\n"
      "<key>List of Albums</key>\n"
      "<array>"
      "    <dict>"
      "      <key>AlbumId</key>"
      "      <integer>14</integer>"
      "      <key>AlbumName</key>"
      "      <string>Album1</string>"
      "      <key>KeyList</key>"
      "      <array>"
      "      <string>1</string>"
      "      </array>"
      "    </dict>\n" +
      another_album +
      "</array>\n"
      "<key>Master Image List</key>\n"
      "<dict>\n"
      "  <key>1</key>\n"
      "  <dict>\n"
      "    <key>MediaType</key>"
      "    <string>Image</string>"
      "    <key>Caption1</key>"
      "    <string>caption</string>"
      "    <key>GUID</key>\n"
      "    <string>guid1</string>"
      "    <key>ImagePath</key>"
      "    <string>/vol/path1.jpg</string>"
      "    <key>ThumbPath</key>"
      "    <string>/vol/thumb1.jpg</string>"
      "  </dict>\n"
      "</dict>\n"
      "</dict></plist>\n";
  }

  virtual void StartTest(bool parse_success) OVERRIDE {
    EXPECT_TRUE(parse_success);

    EXPECT_EQ(FilePath("/vol/path1.jpg"),
              data_provider()->GetPhotoLocationInAlbum("Album1", "path1.jpg"));
    std::vector<std::string> names = data_provider()->GetAlbumNames();
    EXPECT_EQ(1U, names.size());
    EXPECT_EQ("Album1", names[0]);

    another_album =
      "    <dict>"
      "      <key>AlbumId</key>"
      "      <integer>14</integer>"
      "      <key>AlbumName</key>"
      "      <string>Another Album</string>"
      "      <key>KeyList</key>"
      "      <array>"
      "      <string>1</string>"
      "      </array>"
      "    </dict>\n";

    WriteLibrary(base::Bind(&IPhotoDataProviderRefreshTest::CheckAfterWrite,
                            base::Unretained(this)));
  }

  void CheckAfterWrite() {
    // No change -- data has not been parsed.
    EXPECT_EQ(FilePath("/vol/path1.jpg"),
              data_provider()->GetPhotoLocationInAlbum("Album1", "path1.jpg"));
    std::vector<std::string> names = data_provider()->GetAlbumNames();
    EXPECT_EQ(1U, names.size());
    EXPECT_EQ("Album1", names[0]);

    data_provider()->RefreshData(
        base::Bind(&IPhotoDataProviderRefreshTest::CheckRefresh,
                   base::Unretained(this)));
  }

  void CheckRefresh(bool is_valid) {
    EXPECT_TRUE(is_valid);

    EXPECT_EQ(FilePath("/vol/path1.jpg"),
              data_provider()->GetPhotoLocationInAlbum("Album1", "path1.jpg"));
    std::vector<std::string> names = data_provider()->GetAlbumNames();
    EXPECT_EQ(2U, names.size());
    if (names.size() == 2U) {
      EXPECT_EQ("Album1", names[0]);
      EXPECT_EQ("Another Album", names[1]);
    }

    TestDone();
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(IPhotoDataProviderRefreshTest);
};

class IPhotoDataProviderInvalidTest : public IPhotoDataProviderTest {
 public:
  IPhotoDataProviderInvalidTest() {}
  virtual ~IPhotoDataProviderInvalidTest() {}

  virtual void StartTest(bool parse_success) OVERRIDE {
    EXPECT_TRUE(parse_success);

    SetLibraryChangeCallback(
        base::Bind(&IPhotoDataProvider::RefreshData,
                   base::Unretained(data_provider()),
                   base::Bind(&IPhotoDataProviderInvalidTest::CheckInvalid,
                              base::Unretained(this))));
    EXPECT_EQ(1L, base::WriteFile(XmlFile(), " ", 1));
  }

  void CheckInvalid(bool is_valid) {
    EXPECT_FALSE(is_valid);
    TestDone();
  }

 private:
  DISALLOW_COPY_AND_ASSIGN(IPhotoDataProviderInvalidTest);
};

IN_PROC_BROWSER_TEST_F(IPhotoDataProviderBasicTest, BasicTest) {
  RunTest();
}

IN_PROC_BROWSER_TEST_F(IPhotoDataProviderRefreshTest, RefreshTest) {
  RunTest();
}

IN_PROC_BROWSER_TEST_F(IPhotoDataProviderInvalidTest, InvalidTest) {
  RunTest();
}

}  // namespace iphoto