Set version field when changes are made to enhanced bookmarks.

components/enhanced_bookmarks/enhanced_bookmark_model_unittest.cc

 // Copyright 2014 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 "components/enhanced_bookmarks/metadata_accessor.h"
+#include "components/enhanced_bookmarks/enhanced_bookmark_model.h"
 
 #include "base/base64.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/browser/bookmark_node.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
 #include "components/enhanced_bookmarks/proto/metadata.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 namespace {
 
-using namespace image::collections;
-
 const std::string BOOKMARK_URL("http://example.com/index.html");
 
-class MetadataAccessorTest : public testing::Test {
+class EnhancedBookmarkModelTest : public testing::Test {
  public:
-  MetadataAccessorTest() {}
-  virtual ~MetadataAccessorTest() {}
+  EnhancedBookmarkModelTest() {}
+  virtual ~EnhancedBookmarkModelTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    test::TestBookmarkClient bookmark_client;
+    bookmark_model_.reset(bookmark_client.CreateModel().release());
+    model_.reset(new enhanced_bookmarks::EnhancedBookmarkModel(
+        bookmark_model_.get(), "v1.0"));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    model_.reset();
+    bookmark_model_.reset();
+  }
 
  protected:
-  DISALLOW_COPY_AND_ASSIGN(MetadataAccessorTest);
+  const BookmarkNode* AddBookmark() {
+    return AddBookmark("Some title", bookmark_model_->other_node());
+  }
 
-  // Adds a bookmark as the subnode at index 0 to other_node.
-  // |name| should be ASCII encoded.
-  // Returns the newly added bookmark.
-  const BookmarkNode* AddBookmark(BookmarkModel* model, std::string name) {
-    return model->AddURL(model->other_node(),
-                         0,  // index.
-                         base::ASCIIToUTF16(name),
-                         GURL(BOOKMARK_URL));
+  const BookmarkNode* AddFolder() {
+    return AddFolder("Some title", bookmark_model_->other_node());
   }
+
+  const BookmarkNode* AddBookmark(const std::string& name,
+                                  const BookmarkNode* parent) {
+    return bookmark_model_->AddURL(parent,
+                                   0,  // index.
+                                   base::ASCIIToUTF16(name),
+                                   GURL(BOOKMARK_URL));
+  }
+
+  const BookmarkNode* AddFolder(const std::string& name,
+                                const BookmarkNode* parent) {
+    return bookmark_model_->AddFolder(parent, 0, base::ASCIIToUTF16(name));
+  }
+
+  std::string GetVersionForNode(const BookmarkNode* node) {
+    std::string version;
+    if (!node->GetMetaInfo("stars.version", &version))
+      return std::string();
+    return version;
+  }
+
+  scoped_ptr<BookmarkModel> bookmark_model_;
+  scoped_ptr<enhanced_bookmarks::EnhancedBookmarkModel> model_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EnhancedBookmarkModelTest);
 };
 
-TEST_F(MetadataAccessorTest, TestEmptySnippet) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestEmptySnippet) {
+  const BookmarkNode* node = AddBookmark();
 
-  std::string snippet(enhanced_bookmarks::SnippetFromBookmark(node.get()));
-  CHECK_EQ(snippet, "");
+  std::string snippet(model_->GetSnippetForNode(node));
+  EXPECT_EQ(snippet, "");
 };
 
-TEST_F(MetadataAccessorTest, TestSnippet) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestSnippet) {
+  const BookmarkNode* node = AddBookmark();
 
   // Binary serialize the protobuf.
-  PageData data;
+  image::collections::PageData data;
   data.set_snippet("I'm happy!");
   ASSERT_TRUE(data.IsInitialized());
   std::string output;
   bool result = data.SerializeToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kPageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", encoded);
 
-  std::string snippet(enhanced_bookmarks::SnippetFromBookmark(node.get()));
-  CHECK_EQ(snippet, "I'm happy!");
-};
+  std::string snippet(model_->GetSnippetForNode(node));
+  EXPECT_EQ(snippet, "I'm happy!");
+}
 
-TEST_F(MetadataAccessorTest, TestBadEncodingSnippet) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestBadEncodingSnippet) {
+  const BookmarkNode* node = AddBookmark();
 
   // Binary serialize the protobuf.
-  PageData data;
+  image::collections::PageData data;
   data.set_snippet("You are happy!");
   ASSERT_TRUE(data.IsInitialized());
   std::string output;
   bool result = data.SerializeToString(&output);
   ASSERT_TRUE(result);
 
   // don't base 64 encode the output.
-  node->SetMetaInfo(enhanced_bookmarks::kPageDataKey, output);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", output);
 
-  std::string snippet(enhanced_bookmarks::SnippetFromBookmark(node.get()));
-  CHECK_EQ(snippet, "");
-};
+  std::string snippet(model_->GetSnippetForNode(node));
+  EXPECT_EQ(snippet, "");
+}
 
-TEST_F(MetadataAccessorTest, TestOriginalImage) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestOriginalImage) {
+  const BookmarkNode* node = AddBookmark();
 
-  ImageData data;
+  image::collections::ImageData data;
   // Intentionally make raw pointer.
-  ImageData_ImageInfo* info = new ImageData_ImageInfo;
+  image::collections::ImageData_ImageInfo* info =
+      new image::collections::ImageData_ImageInfo;
   info->set_url("http://example.com/foobar");
   info->set_width(15);
   info->set_height(55);
   // This method consumes the pointer.
   data.set_allocated_original_info(info);
 
   std::string output;
   bool result = data.SerializePartialToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kImageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::OriginalImageFromBookmark(
-      node.get(), &url, &width, &height);
+  result = model_->GetOriginalImageForNode(node, &url, &width, &height);
   ASSERT_TRUE(result);
-  CHECK_EQ(url, GURL("http://example.com/foobar"));
-  CHECK_EQ(width, 15);
-  CHECK_EQ(height, 55);
-};
+  EXPECT_EQ(url, GURL("http://example.com/foobar"));
+  EXPECT_EQ(width, 15);
+  EXPECT_EQ(height, 55);
+}
 
-TEST_F(MetadataAccessorTest, TestThumbnailImage) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestThumbnailImage) {
+  const BookmarkNode* node = AddBookmark();
 
-  ImageData data;
+  image::collections::ImageData data;
   // Intentionally make raw pointer.
-  ImageData_ImageInfo* info = new ImageData_ImageInfo;
+  image::collections::ImageData_ImageInfo* info =
+      new image::collections::ImageData_ImageInfo;
   info->set_url("http://example.com/foobar");
   info->set_width(15);
   info->set_height(55);
   // This method consumes the pointer.
   data.set_allocated_thumbnail_info(info);
 
   std::string output;
   bool result = data.SerializePartialToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kImageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::ThumbnailImageFromBookmark(
-      node.get(), &url, &width, &height);
+  result = model_->GetThumbnailImageForNode(node, &url, &width, &height);
   ASSERT_TRUE(result);
-  CHECK_EQ(url, GURL("http://example.com/foobar"));
-  CHECK_EQ(width, 15);
-  CHECK_EQ(height, 55);
-};
+  EXPECT_EQ(url, GURL("http://example.com/foobar"));
+  EXPECT_EQ(width, 15);
+  EXPECT_EQ(height, 55);
+}
 
-TEST_F(MetadataAccessorTest, TestOriginalImageMissingDimensions) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestOriginalImageMissingDimensions) {
+  const BookmarkNode* node = AddBookmark();
 
-  ImageData data;
+  image::collections::ImageData data;
   // Intentionally make raw pointer.
-  ImageData_ImageInfo* info = new ImageData_ImageInfo;
+  image::collections::ImageData_ImageInfo* info =
+      new image::collections::ImageData_ImageInfo;
   info->set_url("http://example.com/foobar");
   // This method consumes the pointer.
   data.set_allocated_original_info(info);
 
   std::string output;
   bool result = data.SerializePartialToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kImageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::OriginalImageFromBookmark(
-      node.get(), &url, &width, &height);
+  result = model_->GetOriginalImageForNode(node, &url, &width, &height);
   ASSERT_FALSE(result);
-};
+}
 
-TEST_F(MetadataAccessorTest, TestOriginalImageBadUrl) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestOriginalImageBadUrl) {
+  const BookmarkNode* node = AddBookmark();
 
-  ImageData data;
+  image::collections::ImageData data;
   // Intentionally make raw pointer.
-  ImageData_ImageInfo* info = new ImageData_ImageInfo;
+  image::collections::ImageData_ImageInfo* info =
+      new image::collections::ImageData_ImageInfo;
   info->set_url("asdf. 13r");
   info->set_width(15);
   info->set_height(55);
   // This method consumes the pointer.
   data.set_allocated_original_info(info);
 
   std::string output;
   bool result = data.SerializePartialToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kImageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.imageData", encoded);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::OriginalImageFromBookmark(
-      node.get(), &url, &width, &height);
+  result = model_->GetOriginalImageForNode(node, &url, &width, &height);
   ASSERT_FALSE(result);
-};
+}
 
-TEST_F(MetadataAccessorTest, TestEncodeDecode) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  const BookmarkNode* node =
-      bookmark_model->AddURL(bookmark_model->other_node(),
-                             0,  // index.
-                             base::ASCIIToUTF16("whatever"),
-                             GURL(BOOKMARK_URL));
+TEST_F(EnhancedBookmarkModelTest, TestEncodeDecode) {
+  const BookmarkNode* node = AddBookmark();
 
-  bool result = enhanced_bookmarks::SetOriginalImageForBookmark(
-      bookmark_model.get(), node, GURL("http://example.com/i.jpg"), 22, 33);
+  bool result = model_->SetOriginalImageForNode(
+      node, GURL("http://example.com/i.jpg"), 22, 33, false);
   ASSERT_TRUE(result);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::OriginalImageFromBookmark(
-      node, &url, &width, &height);
+  result = model_->GetOriginalImageForNode(node, &url, &width, &height);
   ASSERT_TRUE(result);
-  CHECK_EQ(url, GURL("http://example.com/i.jpg"));
-  CHECK_EQ(width, 22);
-  CHECK_EQ(height, 33);
-};
+  EXPECT_EQ(url, GURL("http://example.com/i.jpg"));
+  EXPECT_EQ(width, 22);
+  EXPECT_EQ(height, 33);
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
+}
 
-TEST_F(MetadataAccessorTest, TestDoubleEncodeDecode) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  const BookmarkNode* node =
-      bookmark_model->AddURL(bookmark_model->other_node(),
-                             0,  // index.
-                             base::ASCIIToUTF16("whatever"),
-                             GURL(BOOKMARK_URL));
+TEST_F(EnhancedBookmarkModelTest, TestDoubleEncodeDecode) {
+  const BookmarkNode* node = AddBookmark();
 
   // Encode some information.
-  bool result = enhanced_bookmarks::SetOriginalImageForBookmark(
-      bookmark_model.get(), node, GURL("http://example.com/i.jpg"), 22, 33);
+  bool result = model_->SetOriginalImageForNode(
+      node, GURL("http://example.com/i.jpg"), 22, 33, false);
   ASSERT_TRUE(result);
   // Encode some different information.
-  result = enhanced_bookmarks::SetOriginalImageForBookmark(
-      bookmark_model.get(), node, GURL("http://example.com/i.jpg"), 33, 44);
+  result = model_->SetOriginalImageForNode(
+      node, GURL("http://example.com/i.jpg"), 33, 44, false);
   ASSERT_TRUE(result);
 
   GURL url;
   int width;
   int height;
-  result = enhanced_bookmarks::OriginalImageFromBookmark(
-      node, &url, &width, &height);
+  result = model_->GetOriginalImageForNode(node, &url, &width, &height);
   ASSERT_TRUE(result);
-  CHECK_EQ(url, GURL("http://example.com/i.jpg"));
-  CHECK_EQ(width, 33);
-  CHECK_EQ(height, 44);
-};
-
-TEST_F(MetadataAccessorTest, TestThumbnail) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  const BookmarkNode* node =
-      bookmark_model->AddURL(bookmark_model->other_node(),
-                             0,  // index.
-                             base::ASCIIToUTF16("whatever"),
-                             GURL(BOOKMARK_URL));
-
-  // Encode some information.
-  ASSERT_TRUE(enhanced_bookmarks::SetAllImagesForBookmark(
-      bookmark_model.get(),
-      node,
-      GURL(),
-      0,
-      0,
-      GURL("http://google.com/img/thumb.jpg"),
-      33,
-      44));
-  GURL url;
-  int width;
-  int height;
-  bool result = enhanced_bookmarks::ThumbnailImageFromBookmark(
-      node, &url, &width, &height);
-  ASSERT_TRUE(result);
-  CHECK_EQ(url, GURL("http://google.com/img/thumb.jpg"));
-  CHECK_EQ(width, 33);
-  CHECK_EQ(height, 44);
-};
-
-TEST_F(MetadataAccessorTest, TestRemoteId) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  const BookmarkNode* node = AddBookmark(bookmark_model.get(), "Aga Khan");
-
-  // First call creates the UUID, second call should return the same.
-  ASSERT_EQ(
-      enhanced_bookmarks::RemoteIdFromBookmark(bookmark_model.get(), node),
-      enhanced_bookmarks::RemoteIdFromBookmark(bookmark_model.get(), node));
+  EXPECT_EQ(url, GURL("http://example.com/i.jpg"));
+  EXPECT_EQ(width, 33);
+  EXPECT_EQ(height, 44);
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
 }
 
-TEST_F(MetadataAccessorTest, TestEmptyDescription) {
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestRemoteId) {
+  const BookmarkNode* node = AddBookmark();
+  const BookmarkNode* folder_node = AddFolder();
 
-  std::string description(
-      enhanced_bookmarks::DescriptionFromBookmark(node.get()));
-  CHECK_EQ(description, "");
+  std::string remote_id = model_->GetRemoteIdForNode(node);
+  // First call creates the UUID, second call should return the same.
+  EXPECT_EQ(remote_id, model_->GetRemoteIdForNode(node));
+
+  // Verify that the remote id starts with the correct prefix.
+  EXPECT_TRUE(StartsWithASCII(remote_id, "ebc_", true));
+  std::string folder_remote_id = model_->GetRemoteIdForNode(folder_node);
+  EXPECT_TRUE(StartsWithASCII(folder_remote_id, "ebf_", true));
+
+  // Verifiy version field was set.
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
+  EXPECT_EQ("v1.0", GetVersionForNode(folder_node));
 }
 
-TEST_F(MetadataAccessorTest, TestDescription) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestEmptyDescription) {
+  const BookmarkNode* node = AddBookmark();
+
+  std::string description(model_->GetDescriptionForNode(node));
+  EXPECT_EQ(description, "");
+}
+
+TEST_F(EnhancedBookmarkModelTest, TestDescription) {
+  const BookmarkNode* node = AddBookmark();
   const std::string description("This is the most useful description of all.");
 
   // Set the description.
-  enhanced_bookmarks::SetDescriptionForBookmark(
-      bookmark_model.get(), node.get(), description);
+  model_->SetDescriptionForNode(node, description, false);
 
   // Check the description is the one that was set.
-  CHECK_EQ(enhanced_bookmarks::DescriptionFromBookmark(node.get()),
-           description);
+  EXPECT_EQ(model_->GetDescriptionForNode(node), description);
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
 }
 
 // If there is no notes field, the description should fall back on the snippet.
-TEST_F(MetadataAccessorTest, TestDescriptionFallback) {
-  test::TestBookmarkClient bookmark_client;
-  scoped_ptr<BookmarkModel> bookmark_model(bookmark_client.CreateModel());
-  scoped_ptr<BookmarkNode> node(new BookmarkNode(GURL(BOOKMARK_URL)));
+TEST_F(EnhancedBookmarkModelTest, TestDescriptionFallback) {
+  const BookmarkNode* node = AddBookmark();
 
   // Binary serialize the protobuf.
-  PageData data;
+  image::collections::PageData data;
   data.set_snippet("Joe Bar Team");
   ASSERT_TRUE(data.IsInitialized());
   std::string output;
   bool result = data.SerializeToString(&output);
   ASSERT_TRUE(result);
 
   // base64 encode the output.
   std::string encoded;
   base::Base64Encode(output, &encoded);
-  node->SetMetaInfo(enhanced_bookmarks::kPageDataKey, encoded);
+  bookmark_model_->SetNodeMetaInfo(node, "stars.pageData", encoded);
 
   // The snippet is used as the description.
-  std::string snippet(enhanced_bookmarks::SnippetFromBookmark(node.get()));
-  CHECK_EQ("Joe Bar Team",
-           enhanced_bookmarks::DescriptionFromBookmark(node.get()));
+  std::string snippet(model_->GetSnippetForNode(node));
+  EXPECT_EQ("Joe Bar Team", model_->GetDescriptionForNode(node));
 
   // Set the description.
   const std::string description("This is the most useful description of all.");
-  enhanced_bookmarks::SetDescriptionForBookmark(
-      bookmark_model.get(), node.get(), description);
+  model_->SetDescriptionForNode(node, description, false);
 
   // Check the description is the one that was set.
-  CHECK_EQ(enhanced_bookmarks::DescriptionFromBookmark(node.get()),
-           description);
+  EXPECT_EQ(model_->GetDescriptionForNode(node), description);
 }
+
+// Makes sure that the stars.version field is set every time
+// EnhancedBookmarkModel makes a change to a node.
+TEST_F(EnhancedBookmarkModelTest, TestVersionField) {
+  const BookmarkNode* node = AddBookmark();
+  EXPECT_EQ("", GetVersionForNode(node));
+
+  model_->SetDescriptionForNode(node, "foo", false);
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
+
+  // Add a suffix to the version to set.
+  model_->SetVersionSuffix("alpha");
+
+  model_->SetDescriptionForNode(node, "foo", false);
+  // Since the description didn't actually change, the version field should
+  // not either.
+  EXPECT_EQ("v1.0", GetVersionForNode(node));
+
+  model_->SetDescriptionForNode(node, "bar", false);
+  EXPECT_EQ("v1.0/alpha", GetVersionForNode(node));
+}
+
+// Verifies that the stars.userEdit field is set appropriately when editing a
+// node.
+TEST_F(EnhancedBookmarkModelTest, TestUserEdit) {
+  const BookmarkNode* node = AddBookmark();
+
+  model_->SetDescriptionForNode(node, "foo", false);
+  std::string user_edit;
+  ASSERT_TRUE(node->GetMetaInfo("stars.userEdit", &user_edit));
+  EXPECT_EQ("false", user_edit);
+
+  // The user edit field shouldn't update when the description didn't actually
+  // change
+  model_->SetDescriptionForNode(node, "foo", true);
+  ASSERT_TRUE(node->GetMetaInfo("stars.userEdit", &user_edit));
+  EXPECT_EQ("false", user_edit);
+
+  model_->SetDescriptionForNode(node, "bar", true);
+  ASSERT_TRUE(node->GetMetaInfo("stars.userEdit", &user_edit));
+  EXPECT_EQ("true", user_edit);
+}
+
 }  // namespace