blob: ee722542a7e5e09c5c9416ad2829311def3e870e [file] [log] [blame]
// Copyright 2012 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.
// Unit tests for the SyncApi. Note that a lot of the underlying
// functionality is provided by the Syncable layer, which has its own
// unit tests. We'll test SyncApi specific things in this harness.
#include "sync/internal_api/sync_manager_impl.h"
#include <stdint.h>
#include <cstddef>
#include <map>
#include <utility>
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/files/scoped_temp_dir.h"
#include "base/format_macros.h"
#include "base/location.h"
#include "base/memory/scoped_ptr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/values_test_util.h"
#include "base/values.h"
#include "google_apis/gaia/gaia_constants.h"
#include "sync/engine/sync_scheduler.h"
#include "sync/internal_api/public/base/attachment_id_proto.h"
#include "sync/internal_api/public/base/cancelation_signal.h"
#include "sync/internal_api/public/base/model_type_test_util.h"
#include "sync/internal_api/public/change_record.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/internal_api/public/engine/polling_constants.h"
#include "sync/internal_api/public/events/protocol_event.h"
#include "sync/internal_api/public/http_post_provider_factory.h"
#include "sync/internal_api/public/http_post_provider_interface.h"
#include "sync/internal_api/public/read_node.h"
#include "sync/internal_api/public/read_transaction.h"
#include "sync/internal_api/public/test/test_entry_factory.h"
#include "sync/internal_api/public/test/test_internal_components_factory.h"
#include "sync/internal_api/public/test/test_user_share.h"
#include "sync/internal_api/public/write_node.h"
#include "sync/internal_api/public/write_transaction.h"
#include "sync/internal_api/sync_encryption_handler_impl.h"
#include "sync/internal_api/syncapi_internal.h"
#include "sync/js/js_backend.h"
#include "sync/js/js_event_handler.h"
#include "sync/js/js_test_util.h"
#include "sync/protocol/bookmark_specifics.pb.h"
#include "sync/protocol/encryption.pb.h"
#include "sync/protocol/extension_specifics.pb.h"
#include "sync/protocol/password_specifics.pb.h"
#include "sync/protocol/preference_specifics.pb.h"
#include "sync/protocol/proto_value_conversions.h"
#include "sync/protocol/sync.pb.h"
#include "sync/sessions/sync_session.h"
#include "sync/syncable/directory.h"
#include "sync/syncable/entry.h"
#include "sync/syncable/mutable_entry.h"
#include "sync/syncable/nigori_util.h"
#include "sync/syncable/syncable_id.h"
#include "sync/syncable/syncable_read_transaction.h"
#include "sync/syncable/syncable_util.h"
#include "sync/syncable/syncable_write_transaction.h"
#include "sync/test/callback_counter.h"
#include "sync/test/engine/fake_model_worker.h"
#include "sync/test/engine/fake_sync_scheduler.h"
#include "sync/test/engine/test_id_factory.h"
#include "sync/test/fake_encryptor.h"
#include "sync/util/cryptographer.h"
#include "sync/util/extensions_activity.h"
#include "sync/util/mock_unrecoverable_error_handler.h"
#include "sync/util/time.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
using base::ExpectDictStringValue;
using testing::_;
using testing::DoAll;
using testing::InSequence;
using testing::Return;
using testing::SaveArg;
using testing::StrictMock;
namespace syncer {
using sessions::SyncSessionSnapshot;
using syncable::GET_BY_HANDLE;
using syncable::IS_DEL;
using syncable::IS_UNSYNCED;
using syncable::NON_UNIQUE_NAME;
using syncable::SPECIFICS;
using syncable::kEncryptedString;
namespace {
// Makes a child node under the type root folder. Returns the id of the
// newly-created node.
int64_t MakeNode(UserShare* share,
ModelType model_type,
const std::string& client_tag) {
WriteTransaction trans(FROM_HERE, share);
WriteNode node(&trans);
WriteNode::InitUniqueByCreationResult result =
node.InitUniqueByCreation(model_type, client_tag);
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
node.SetIsFolder(false);
return node.GetId();
}
// Makes a non-folder child of the root node. Returns the id of the
// newly-created node.
int64_t MakeNodeWithRoot(UserShare* share,
ModelType model_type,
const std::string& client_tag) {
WriteTransaction trans(FROM_HERE, share);
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode node(&trans);
WriteNode::InitUniqueByCreationResult result =
node.InitUniqueByCreation(model_type, root_node, client_tag);
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
node.SetIsFolder(false);
return node.GetId();
}
// Makes a folder child of a non-root node. Returns the id of the
// newly-created node.
int64_t MakeFolderWithParent(UserShare* share,
ModelType model_type,
int64_t parent_id,
BaseNode* predecessor) {
WriteTransaction trans(FROM_HERE, share);
ReadNode parent_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
WriteNode node(&trans);
EXPECT_TRUE(node.InitBookmarkByCreation(parent_node, predecessor));
node.SetIsFolder(true);
return node.GetId();
}
int64_t MakeBookmarkWithParent(UserShare* share,
int64_t parent_id,
BaseNode* predecessor) {
WriteTransaction trans(FROM_HERE, share);
ReadNode parent_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, parent_node.InitByIdLookup(parent_id));
WriteNode node(&trans);
EXPECT_TRUE(node.InitBookmarkByCreation(parent_node, predecessor));
return node.GetId();
}
// Creates the "synced" root node for a particular datatype. We use the syncable
// methods here so that the syncer treats these nodes as if they were already
// received from the server.
int64_t MakeTypeRoot(UserShare* share, ModelType model_type) {
sync_pb::EntitySpecifics specifics;
AddDefaultFieldValue(model_type, &specifics);
syncable::WriteTransaction trans(
FROM_HERE, syncable::UNITTEST, share->directory.get());
// Attempt to lookup by nigori tag.
std::string type_tag = ModelTypeToRootTag(model_type);
syncable::Id node_id = syncable::Id::CreateFromServerId(type_tag);
syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
node_id);
EXPECT_TRUE(entry.good());
entry.PutBaseVersion(1);
entry.PutServerVersion(1);
entry.PutIsUnappliedUpdate(false);
entry.PutParentId(syncable::Id::GetRoot());
entry.PutServerParentId(syncable::Id::GetRoot());
entry.PutServerIsDir(true);
entry.PutIsDir(true);
entry.PutServerSpecifics(specifics);
entry.PutSpecifics(specifics);
entry.PutUniqueServerTag(type_tag);
entry.PutNonUniqueName(type_tag);
entry.PutIsDel(false);
return entry.GetMetahandle();
}
// Simulates creating a "synced" node as a child of the root datatype node.
int64_t MakeServerNode(UserShare* share,
ModelType model_type,
const std::string& client_tag,
const std::string& hashed_tag,
const sync_pb::EntitySpecifics& specifics) {
syncable::WriteTransaction trans(
FROM_HERE, syncable::UNITTEST, share->directory.get());
syncable::Entry root_entry(&trans, syncable::GET_TYPE_ROOT, model_type);
EXPECT_TRUE(root_entry.good());
syncable::Id root_id = root_entry.GetId();
syncable::Id node_id = syncable::Id::CreateFromServerId(client_tag);
syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
node_id);
EXPECT_TRUE(entry.good());
entry.PutBaseVersion(1);
entry.PutServerVersion(1);
entry.PutIsUnappliedUpdate(false);
entry.PutServerParentId(root_id);
entry.PutParentId(root_id);
entry.PutServerIsDir(false);
entry.PutIsDir(false);
entry.PutServerSpecifics(specifics);
entry.PutSpecifics(specifics);
entry.PutNonUniqueName(client_tag);
entry.PutUniqueClientTag(hashed_tag);
entry.PutIsDel(false);
return entry.GetMetahandle();
}
int GetTotalNodeCount(UserShare* share, int64_t root) {
ReadTransaction trans(FROM_HERE, share);
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(root));
return node.GetTotalNodeCount();
}
} // namespace
class SyncApiTest : public testing::Test {
public:
void SetUp() override { test_user_share_.SetUp(); }
void TearDown() override { test_user_share_.TearDown(); }
protected:
// Create an entry with the given |model_type|, |client_tag| and
// |attachment_metadata|.
void CreateEntryWithAttachmentMetadata(
const ModelType& model_type,
const std::string& client_tag,
const sync_pb::AttachmentMetadata& attachment_metadata);
// Attempts to load the entry specified by |model_type| and |client_tag| and
// returns the lookup result code.
BaseNode::InitByLookupResult LookupEntryByClientTag(
const ModelType& model_type,
const std::string& client_tag);
// Replace the entry specified by |model_type| and |client_tag| with a
// tombstone.
void ReplaceWithTombstone(const ModelType& model_type,
const std::string& client_tag);
// Save changes to the Directory, destroy it then reload it.
bool ReloadDir();
UserShare* user_share();
syncable::Directory* dir();
SyncEncryptionHandler* encryption_handler();
private:
base::MessageLoop message_loop_;
TestUserShare test_user_share_;
};
UserShare* SyncApiTest::user_share() {
return test_user_share_.user_share();
}
syncable::Directory* SyncApiTest::dir() {
return test_user_share_.user_share()->directory.get();
}
SyncEncryptionHandler* SyncApiTest::encryption_handler() {
return test_user_share_.encryption_handler();
}
bool SyncApiTest::ReloadDir() {
return test_user_share_.Reload();
}
void SyncApiTest::CreateEntryWithAttachmentMetadata(
const ModelType& model_type,
const std::string& client_tag,
const sync_pb::AttachmentMetadata& attachment_metadata) {
syncer::WriteTransaction trans(FROM_HERE, user_share());
syncer::ReadNode root_node(&trans);
root_node.InitByRootLookup();
syncer::WriteNode node(&trans);
ASSERT_EQ(node.InitUniqueByCreation(model_type, root_node, client_tag),
syncer::WriteNode::INIT_SUCCESS);
node.SetAttachmentMetadata(attachment_metadata);
}
BaseNode::InitByLookupResult SyncApiTest::LookupEntryByClientTag(
const ModelType& model_type,
const std::string& client_tag) {
syncer::ReadTransaction trans(FROM_HERE, user_share());
syncer::ReadNode node(&trans);
return node.InitByClientTagLookup(model_type, client_tag);
}
void SyncApiTest::ReplaceWithTombstone(const ModelType& model_type,
const std::string& client_tag) {
syncer::WriteTransaction trans(FROM_HERE, user_share());
syncer::WriteNode node(&trans);
ASSERT_EQ(node.InitByClientTagLookup(model_type, client_tag),
syncer::WriteNode::INIT_OK);
node.Tombstone();
}
TEST_F(SyncApiTest, SanityCheckTest) {
{
ReadTransaction trans(FROM_HERE, user_share());
EXPECT_TRUE(trans.GetWrappedTrans());
}
{
WriteTransaction trans(FROM_HERE, user_share());
EXPECT_TRUE(trans.GetWrappedTrans());
}
{
// No entries but root should exist
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
// Metahandle 1 can be root, sanity check 2
EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD, node.InitByIdLookup(2));
}
}
TEST_F(SyncApiTest, BasicTagWrite) {
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
EXPECT_EQ(kInvalidId, root_node.GetFirstChildId());
}
ignore_result(MakeNodeWithRoot(user_share(), BOOKMARKS, "testtag"));
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, "testtag"));
EXPECT_NE(0, node.GetId());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
EXPECT_EQ(node.GetId(), root_node.GetFirstChildId());
}
}
TEST_F(SyncApiTest, BasicTagWriteWithImplicitParent) {
int64_t type_root = MakeTypeRoot(user_share(), PREFERENCES);
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode type_root_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, type_root_node.InitByIdLookup(type_root));
EXPECT_EQ(kInvalidId, type_root_node.GetFirstChildId());
}
ignore_result(MakeNode(user_share(), PREFERENCES, "testtag"));
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, "testtag"));
EXPECT_EQ(kInvalidId, node.GetParentId());
ReadNode type_root_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, type_root_node.InitByIdLookup(type_root));
EXPECT_EQ(node.GetId(), type_root_node.GetFirstChildId());
}
}
TEST_F(SyncApiTest, ModelTypesSiloed) {
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
EXPECT_EQ(root_node.GetFirstChildId(), 0);
}
ignore_result(MakeNodeWithRoot(user_share(), BOOKMARKS, "collideme"));
ignore_result(MakeNodeWithRoot(user_share(), PREFERENCES, "collideme"));
ignore_result(MakeNodeWithRoot(user_share(), AUTOFILL, "collideme"));
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode bookmarknode(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
bookmarknode.InitByClientTagLookup(BOOKMARKS,
"collideme"));
ReadNode prefnode(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
prefnode.InitByClientTagLookup(PREFERENCES,
"collideme"));
ReadNode autofillnode(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
autofillnode.InitByClientTagLookup(AUTOFILL,
"collideme"));
EXPECT_NE(bookmarknode.GetId(), prefnode.GetId());
EXPECT_NE(autofillnode.GetId(), prefnode.GetId());
EXPECT_NE(bookmarknode.GetId(), autofillnode.GetId());
}
}
TEST_F(SyncApiTest, ReadMissingTagsFails) {
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
node.InitByClientTagLookup(BOOKMARKS,
"testtag"));
}
{
WriteTransaction trans(FROM_HERE, user_share());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_NOT_GOOD,
node.InitByClientTagLookup(BOOKMARKS,
"testtag"));
}
}
// TODO(chron): Hook this all up to the server and write full integration tests
// for update->undelete behavior.
TEST_F(SyncApiTest, TestDeleteBehavior) {
int64_t node_id;
int64_t folder_id;
std::string test_title("test1");
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
// we'll use this spare folder later
WriteNode folder_node(&trans);
EXPECT_TRUE(folder_node.InitBookmarkByCreation(root_node, NULL));
folder_id = folder_node.GetId();
WriteNode wnode(&trans);
WriteNode::InitUniqueByCreationResult result =
wnode.InitUniqueByCreation(BOOKMARKS, root_node, "testtag");
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
wnode.SetIsFolder(false);
wnode.SetTitle(test_title);
node_id = wnode.GetId();
}
// Ensure we can delete something with a tag.
{
WriteTransaction trans(FROM_HERE, user_share());
WriteNode wnode(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
wnode.InitByClientTagLookup(BOOKMARKS,
"testtag"));
EXPECT_FALSE(wnode.GetIsFolder());
EXPECT_EQ(wnode.GetTitle(), test_title);
wnode.Tombstone();
}
// Lookup of a node which was deleted should return failure,
// but have found some data about the node.
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_FAILED_ENTRY_IS_DEL,
node.InitByClientTagLookup(BOOKMARKS,
"testtag"));
// Note that for proper function of this API this doesn't need to be
// filled, we're checking just to make sure the DB worked in this test.
EXPECT_EQ(node.GetTitle(), test_title);
}
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode folder_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, folder_node.InitByIdLookup(folder_id));
WriteNode wnode(&trans);
// This will undelete the tag.
WriteNode::InitUniqueByCreationResult result =
wnode.InitUniqueByCreation(BOOKMARKS, folder_node, "testtag");
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
EXPECT_EQ(wnode.GetIsFolder(), false);
EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
EXPECT_EQ(wnode.GetId(), node_id);
EXPECT_NE(wnode.GetTitle(), test_title); // Title should be cleared
wnode.SetTitle(test_title);
}
// Now look up should work.
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS,
"testtag"));
EXPECT_EQ(node.GetTitle(), test_title);
EXPECT_EQ(node.GetModelType(), BOOKMARKS);
}
}
TEST_F(SyncApiTest, WriteAndReadPassword) {
KeyParams params = {"localhost", "username", "passphrase"};
{
ReadTransaction trans(FROM_HERE, user_share());
trans.GetCryptographer()->AddKey(params);
}
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode password_node(&trans);
WriteNode::InitUniqueByCreationResult result =
password_node.InitUniqueByCreation(PASSWORDS,
root_node, "foo");
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
password_node.SetPasswordSpecifics(data);
}
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode password_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
password_node.InitByClientTagLookup(PASSWORDS, "foo"));
const sync_pb::PasswordSpecificsData& data =
password_node.GetPasswordSpecifics();
EXPECT_EQ("secret", data.password_value());
}
}
TEST_F(SyncApiTest, WriteEncryptedTitle) {
KeyParams params = {"localhost", "username", "passphrase"};
{
ReadTransaction trans(FROM_HERE, user_share());
trans.GetCryptographer()->AddKey(params);
}
encryption_handler()->EnableEncryptEverything();
int bookmark_id;
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode bookmark_node(&trans);
ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, NULL));
bookmark_id = bookmark_node.GetId();
bookmark_node.SetTitle("foo");
WriteNode pref_node(&trans);
WriteNode::InitUniqueByCreationResult result =
pref_node.InitUniqueByCreation(PREFERENCES, root_node, "bar");
ASSERT_EQ(WriteNode::INIT_SUCCESS, result);
pref_node.SetTitle("bar");
}
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode bookmark_node(&trans);
ASSERT_EQ(BaseNode::INIT_OK, bookmark_node.InitByIdLookup(bookmark_id));
EXPECT_EQ("foo", bookmark_node.GetTitle());
EXPECT_EQ(kEncryptedString,
bookmark_node.GetEntry()->GetNonUniqueName());
ReadNode pref_node(&trans);
ASSERT_EQ(BaseNode::INIT_OK,
pref_node.InitByClientTagLookup(PREFERENCES,
"bar"));
EXPECT_EQ(kEncryptedString, pref_node.GetTitle());
}
}
// Non-unique name should not be empty. For bookmarks non-unique name is copied
// from bookmark title. This test verifies that setting bookmark title to ""
// results in single space title and non-unique name in internal representation.
// GetTitle should still return empty string.
TEST_F(SyncApiTest, WriteEmptyBookmarkTitle) {
int bookmark_id;
{
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode bookmark_node(&trans);
ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, NULL));
bookmark_id = bookmark_node.GetId();
bookmark_node.SetTitle("");
}
{
ReadTransaction trans(FROM_HERE, user_share());
ReadNode bookmark_node(&trans);
ASSERT_EQ(BaseNode::INIT_OK, bookmark_node.InitByIdLookup(bookmark_id));
EXPECT_EQ("", bookmark_node.GetTitle());
EXPECT_EQ(" ", bookmark_node.GetEntitySpecifics().bookmark().title());
EXPECT_EQ(" ", bookmark_node.GetEntry()->GetNonUniqueName());
}
}
TEST_F(SyncApiTest, BaseNodeSetSpecifics) {
int64_t child_id = MakeNodeWithRoot(user_share(), BOOKMARKS, "testtag");
WriteTransaction trans(FROM_HERE, user_share());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
EXPECT_NE(entity_specifics.SerializeAsString(),
node.GetEntitySpecifics().SerializeAsString());
node.SetEntitySpecifics(entity_specifics);
EXPECT_EQ(entity_specifics.SerializeAsString(),
node.GetEntitySpecifics().SerializeAsString());
}
TEST_F(SyncApiTest, BaseNodeSetSpecificsPreservesUnknownFields) {
int64_t child_id = MakeNodeWithRoot(user_share(), BOOKMARKS, "testtag");
WriteTransaction trans(FROM_HERE, user_share());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
EXPECT_TRUE(node.GetEntitySpecifics().unknown_fields().empty());
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("http://www.google.com");
entity_specifics.mutable_unknown_fields()->AddFixed32(5, 100);
node.SetEntitySpecifics(entity_specifics);
EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
entity_specifics.mutable_unknown_fields()->Clear();
node.SetEntitySpecifics(entity_specifics);
EXPECT_FALSE(node.GetEntitySpecifics().unknown_fields().empty());
}
TEST_F(SyncApiTest, EmptyTags) {
WriteTransaction trans(FROM_HERE, user_share());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode node(&trans);
std::string empty_tag;
WriteNode::InitUniqueByCreationResult result =
node.InitUniqueByCreation(TYPED_URLS, root_node, empty_tag);
EXPECT_NE(WriteNode::INIT_SUCCESS, result);
EXPECT_EQ(BaseNode::INIT_FAILED_PRECONDITION,
node.InitByClientTagLookup(TYPED_URLS, empty_tag));
}
// Test counting nodes when the type's root node has no children.
TEST_F(SyncApiTest, GetTotalNodeCountEmpty) {
int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
EXPECT_EQ(1, GetTotalNodeCount(user_share(), type_root));
}
// Test counting nodes when there is one child beneath the type's root.
TEST_F(SyncApiTest, GetTotalNodeCountOneChild) {
int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
int64_t parent =
MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL);
EXPECT_EQ(2, GetTotalNodeCount(user_share(), type_root));
EXPECT_EQ(1, GetTotalNodeCount(user_share(), parent));
}
// Test counting nodes when there are multiple children beneath the type root,
// and one of those children has children of its own.
TEST_F(SyncApiTest, GetTotalNodeCountMultipleChildren) {
int64_t type_root = MakeTypeRoot(user_share(), BOOKMARKS);
int64_t parent =
MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL);
ignore_result(MakeFolderWithParent(user_share(), BOOKMARKS, type_root, NULL));
int64_t child1 = MakeFolderWithParent(user_share(), BOOKMARKS, parent, NULL);
ignore_result(MakeBookmarkWithParent(user_share(), parent, NULL));
ignore_result(MakeBookmarkWithParent(user_share(), child1, NULL));
EXPECT_EQ(6, GetTotalNodeCount(user_share(), type_root));
EXPECT_EQ(4, GetTotalNodeCount(user_share(), parent));
}
// Verify that Directory keeps track of which attachments are referenced by
// which entries.
TEST_F(SyncApiTest, AttachmentLinking) {
// Add an entry with an attachment.
std::string tag1("some tag");
syncer::AttachmentId attachment_id(syncer::AttachmentId::Create(0, 0));
sync_pb::AttachmentMetadata attachment_metadata;
sync_pb::AttachmentMetadataRecord* record = attachment_metadata.add_record();
*record->mutable_id() = attachment_id.GetProto();
ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
CreateEntryWithAttachmentMetadata(PREFERENCES, tag1, attachment_metadata);
// See that the directory knows it's linked.
ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
// Add a second entry referencing the same attachment.
std::string tag2("some other tag");
CreateEntryWithAttachmentMetadata(PREFERENCES, tag2, attachment_metadata);
// See that the directory knows it's still linked.
ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
// Tombstone the first entry.
ReplaceWithTombstone(syncer::PREFERENCES, tag1);
// See that the attachment is still considered linked because the entry hasn't
// been purged from the Directory.
ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
// Save changes and see that the entry is truly gone.
ASSERT_TRUE(dir()->SaveChanges());
ASSERT_EQ(LookupEntryByClientTag(PREFERENCES, tag1),
syncer::WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
// However, the attachment is still linked.
ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
// Save, destroy, and recreate the directory. See that it's still linked.
ASSERT_TRUE(ReloadDir());
ASSERT_TRUE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
// Tombstone the second entry, save changes, see that it's truly gone.
ReplaceWithTombstone(syncer::PREFERENCES, tag2);
ASSERT_TRUE(dir()->SaveChanges());
ASSERT_EQ(LookupEntryByClientTag(PREFERENCES, tag2),
syncer::WriteNode::INIT_FAILED_ENTRY_NOT_GOOD);
// Finally, the attachment is no longer linked.
ASSERT_FALSE(dir()->IsAttachmentLinked(attachment_id.GetProto()));
}
// This tests directory integrity in the case of creating a new unique node
// with client tag matching that of an existing unapplied node with server only
// data. See crbug.com/505761.
TEST_F(SyncApiTest, WriteNode_UniqueByCreation_UndeleteCase) {
int64_t preferences_root = MakeTypeRoot(user_share(), PREFERENCES);
// Create a node with server only data.
int64_t item1 = 0;
{
syncable::WriteTransaction trans(FROM_HERE, syncable::UNITTEST,
user_share()->directory.get());
syncable::MutableEntry entry(&trans, syncable::CREATE_NEW_UPDATE_ITEM,
syncable::Id::CreateFromServerId("foo1"));
DCHECK(entry.good());
entry.PutServerVersion(10);
entry.PutIsUnappliedUpdate(true);
sync_pb::EntitySpecifics specifics;
AddDefaultFieldValue(PREFERENCES, &specifics);
entry.PutServerSpecifics(specifics);
const std::string hash = syncable::GenerateSyncableHash(PREFERENCES, "foo");
entry.PutUniqueClientTag(hash);
item1 = entry.GetMetahandle();
}
// Verify that the server-only item is invisible as a child of
// of |preferences_root| because at this point it should have the
// "deleted" flag set.
EXPECT_EQ(1, GetTotalNodeCount(user_share(), preferences_root));
// Create a client node with the same tag as the node above.
int64_t item2 = MakeNode(user_share(), PREFERENCES, "foo");
// Expect this to be the same directory entry as |item1|.
EXPECT_EQ(item1, item2);
// Expect it to be visible as a child of |preferences_root|.
EXPECT_EQ(2, GetTotalNodeCount(user_share(), preferences_root));
// Tombstone the new item
{
WriteTransaction trans(FROM_HERE, user_share());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(item1));
node.Tombstone();
}
// Verify that it is gone from the index.
EXPECT_EQ(1, GetTotalNodeCount(user_share(), preferences_root));
}
namespace {
class TestHttpPostProviderInterface : public HttpPostProviderInterface {
public:
~TestHttpPostProviderInterface() override {}
void SetExtraRequestHeaders(const char* headers) override {}
void SetURL(const char* url, int port) override {}
void SetPostPayload(const char* content_type,
int content_length,
const char* content) override {}
bool MakeSynchronousPost(int* error_code, int* response_code) override {
return false;
}
int GetResponseContentLength() const override { return 0; }
const char* GetResponseContent() const override { return ""; }
const std::string GetResponseHeaderValue(
const std::string& name) const override {
return std::string();
}
void Abort() override {}
};
class TestHttpPostProviderFactory : public HttpPostProviderFactory {
public:
~TestHttpPostProviderFactory() override {}
void Init(const std::string& user_agent,
const BindToTrackerCallback& bind_to_tracker_callback) override {}
HttpPostProviderInterface* Create() override {
return new TestHttpPostProviderInterface();
}
void Destroy(HttpPostProviderInterface* http) override {
delete static_cast<TestHttpPostProviderInterface*>(http);
}
};
class SyncManagerObserverMock : public SyncManager::Observer {
public:
MOCK_METHOD1(OnSyncCycleCompleted,
void(const SyncSessionSnapshot&)); // NOLINT
MOCK_METHOD4(OnInitializationComplete,
void(const WeakHandle<JsBackend>&,
const WeakHandle<DataTypeDebugInfoListener>&,
bool,
syncer::ModelTypeSet)); // NOLINT
MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus)); // NOLINT
MOCK_METHOD1(OnUpdatedToken, void(const std::string&)); // NOLINT
MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&)); // NOLINT
MOCK_METHOD1(OnMigrationRequested, void(syncer::ModelTypeSet)); // NOLINT
MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&)); // NOLINT
};
class SyncEncryptionHandlerObserverMock
: public SyncEncryptionHandler::Observer {
public:
MOCK_METHOD2(OnPassphraseRequired,
void(PassphraseRequiredReason,
const sync_pb::EncryptedData&)); // NOLINT
MOCK_METHOD0(OnPassphraseAccepted, void()); // NOLINT
MOCK_METHOD2(OnBootstrapTokenUpdated,
void(const std::string&, BootstrapTokenType type)); // NOLINT
MOCK_METHOD2(OnEncryptedTypesChanged,
void(ModelTypeSet, bool)); // NOLINT
MOCK_METHOD0(OnEncryptionComplete, void()); // NOLINT
MOCK_METHOD1(OnCryptographerStateChanged, void(Cryptographer*)); // NOLINT
MOCK_METHOD2(OnPassphraseTypeChanged, void(PassphraseType,
base::Time)); // NOLINT
MOCK_METHOD1(OnLocalSetPassphraseEncryption,
void(const SyncEncryptionHandler::NigoriState&)); // NOLINT
};
} // namespace
class SyncManagerTest : public testing::Test,
public SyncManager::ChangeDelegate {
protected:
enum NigoriStatus {
DONT_WRITE_NIGORI,
WRITE_TO_NIGORI
};
enum EncryptionStatus {
UNINITIALIZED,
DEFAULT_ENCRYPTION,
FULL_ENCRYPTION
};
SyncManagerTest()
: sync_manager_("Test sync manager") {
switches_.encryption_method =
InternalComponentsFactory::ENCRYPTION_KEYSTORE;
}
virtual ~SyncManagerTest() {
}
// Test implementation.
void SetUp() {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
extensions_activity_ = new ExtensionsActivity();
SyncCredentials credentials;
credentials.account_id = "foo@bar.com";
credentials.email = "foo@bar.com";
credentials.sync_token = "sometoken";
OAuth2TokenService::ScopeSet scope_set;
scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
credentials.scope_set = scope_set;
sync_manager_.AddObserver(&manager_observer_);
EXPECT_CALL(manager_observer_, OnInitializationComplete(_, _, _, _)).
WillOnce(DoAll(SaveArg<0>(&js_backend_),
SaveArg<2>(&initialization_succeeded_)));
EXPECT_FALSE(js_backend_.IsInitialized());
std::vector<scoped_refptr<ModelSafeWorker> > workers;
ModelSafeRoutingInfo routing_info;
GetModelSafeRoutingInfo(&routing_info);
// This works only because all routing info types are GROUP_PASSIVE.
// If we had types in other groups, we would need additional workers
// to support them.
scoped_refptr<ModelSafeWorker> worker = new FakeModelWorker(GROUP_PASSIVE);
workers.push_back(worker);
SyncManager::InitArgs args;
args.database_location = temp_dir_.path();
args.service_url = GURL("https://example.com/");
args.post_factory =
scoped_ptr<HttpPostProviderFactory>(new TestHttpPostProviderFactory());
args.workers = workers;
args.extensions_activity = extensions_activity_.get(),
args.change_delegate = this;
args.credentials = credentials;
args.invalidator_client_id = "fake_invalidator_client_id";
args.internal_components_factory.reset(GetFactory());
args.encryptor = &encryptor_;
args.unrecoverable_error_handler =
MakeWeakHandle(mock_unrecoverable_error_handler_.GetWeakPtr());
args.cancelation_signal = &cancelation_signal_;
sync_manager_.Init(&args);
sync_manager_.GetEncryptionHandler()->AddObserver(&encryption_observer_);
EXPECT_TRUE(js_backend_.IsInitialized());
EXPECT_EQ(InternalComponentsFactory::STORAGE_ON_DISK,
storage_used_);
if (initialization_succeeded_) {
for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
i != routing_info.end(); ++i) {
type_roots_[i->first] =
MakeTypeRoot(sync_manager_.GetUserShare(), i->first);
}
}
PumpLoop();
}
void TearDown() {
sync_manager_.RemoveObserver(&manager_observer_);
sync_manager_.ShutdownOnSyncThread(STOP_SYNC);
PumpLoop();
}
void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
(*out)[NIGORI] = GROUP_PASSIVE;
(*out)[DEVICE_INFO] = GROUP_PASSIVE;
(*out)[EXPERIMENTS] = GROUP_PASSIVE;
(*out)[BOOKMARKS] = GROUP_PASSIVE;
(*out)[THEMES] = GROUP_PASSIVE;
(*out)[SESSIONS] = GROUP_PASSIVE;
(*out)[PASSWORDS] = GROUP_PASSIVE;
(*out)[PREFERENCES] = GROUP_PASSIVE;
(*out)[PRIORITY_PREFERENCES] = GROUP_PASSIVE;
(*out)[ARTICLES] = GROUP_PASSIVE;
}
ModelTypeSet GetEnabledTypes() {
ModelSafeRoutingInfo routing_info;
GetModelSafeRoutingInfo(&routing_info);
return GetRoutingInfoTypes(routing_info);
}
void OnChangesApplied(ModelType model_type,
int64_t model_version,
const BaseTransaction* trans,
const ImmutableChangeRecordList& changes) override {}
void OnChangesComplete(ModelType model_type) override {}
// Helper methods.
bool SetUpEncryption(NigoriStatus nigori_status,
EncryptionStatus encryption_status) {
UserShare* share = sync_manager_.GetUserShare();
// We need to create the nigori node as if it were an applied server update.
int64_t nigori_id = GetIdForDataType(NIGORI);
if (nigori_id == kInvalidId)
return false;
// Set the nigori cryptographer information.
if (encryption_status == FULL_ENCRYPTION)
sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
WriteTransaction trans(FROM_HERE, share);
Cryptographer* cryptographer = trans.GetCryptographer();
if (!cryptographer)
return false;
if (encryption_status != UNINITIALIZED) {
KeyParams params = {"localhost", "dummy", "foobar"};
cryptographer->AddKey(params);
} else {
DCHECK_NE(nigori_status, WRITE_TO_NIGORI);
}
if (nigori_status == WRITE_TO_NIGORI) {
sync_pb::NigoriSpecifics nigori;
cryptographer->GetKeys(nigori.mutable_encryption_keybag());
share->directory->GetNigoriHandler()->UpdateNigoriFromEncryptedTypes(
&nigori,
trans.GetWrappedTrans());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(nigori_id));
node.SetNigoriSpecifics(nigori);
}
return cryptographer->is_ready();
}
int64_t GetIdForDataType(ModelType type) {
if (type_roots_.count(type) == 0)
return 0;
return type_roots_[type];
}
void PumpLoop() {
base::RunLoop().RunUntilIdle();
}
void SetJsEventHandler(const WeakHandle<JsEventHandler>& event_handler) {
js_backend_.Call(FROM_HERE, &JsBackend::SetJsEventHandler,
event_handler);
PumpLoop();
}
// Looks up an entry by client tag and resets IS_UNSYNCED value to false.
// Returns true if entry was previously unsynced, false if IS_UNSYNCED was
// already false.
bool ResetUnsyncedEntry(ModelType type,
const std::string& client_tag) {
UserShare* share = sync_manager_.GetUserShare();
syncable::WriteTransaction trans(
FROM_HERE, syncable::UNITTEST, share->directory.get());
const std::string hash = syncable::GenerateSyncableHash(type, client_tag);
syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG,
hash);
EXPECT_TRUE(entry.good());
if (!entry.GetIsUnsynced())
return false;
entry.PutIsUnsynced(false);
return true;
}
virtual InternalComponentsFactory* GetFactory() {
return new TestInternalComponentsFactory(
GetSwitches(), InternalComponentsFactory::STORAGE_IN_MEMORY,
&storage_used_);
}
// Returns true if we are currently encrypting all sync data. May
// be called on any thread.
bool IsEncryptEverythingEnabledForTest() {
return sync_manager_.GetEncryptionHandler()->IsEncryptEverythingEnabled();
}
// Gets the set of encrypted types from the cryptographer
// Note: opens a transaction. May be called from any thread.
ModelTypeSet GetEncryptedTypes() {
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
return GetEncryptedTypesWithTrans(&trans);
}
ModelTypeSet GetEncryptedTypesWithTrans(BaseTransaction* trans) {
return trans->GetDirectory()->GetNigoriHandler()->
GetEncryptedTypes(trans->GetWrappedTrans());
}
void SimulateInvalidatorEnabledForTest(bool is_enabled) {
DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
sync_manager_.SetInvalidatorEnabled(is_enabled);
}
void SetProgressMarkerForType(ModelType type, bool set) {
if (set) {
sync_pb::DataTypeProgressMarker marker;
marker.set_token("token");
marker.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
sync_manager_.directory()->SetDownloadProgress(type, marker);
} else {
sync_pb::DataTypeProgressMarker marker;
sync_manager_.directory()->SetDownloadProgress(type, marker);
}
}
InternalComponentsFactory::Switches GetSwitches() const {
return switches_;
}
void ExpectPassphraseAcceptance() {
EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
}
void SetImplicitPassphraseAndCheck(const std::string& passphrase) {
sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(
passphrase,
false);
EXPECT_EQ(IMPLICIT_PASSPHRASE,
sync_manager_.GetEncryptionHandler()->GetPassphraseType());
}
void SetCustomPassphraseAndCheck(const std::string& passphrase) {
EXPECT_CALL(encryption_observer_,
OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(
passphrase,
true);
EXPECT_EQ(CUSTOM_PASSPHRASE,
sync_manager_.GetEncryptionHandler()->GetPassphraseType());
}
bool HasUnrecoverableError() {
return mock_unrecoverable_error_handler_.invocation_count() > 0;
}
private:
// Needed by |sync_manager_|.
base::MessageLoop message_loop_;
// Needed by |sync_manager_|.
base::ScopedTempDir temp_dir_;
// Sync Id's for the roots of the enabled datatypes.
std::map<ModelType, int64_t> type_roots_;
scoped_refptr<ExtensionsActivity> extensions_activity_;
protected:
FakeEncryptor encryptor_;
SyncManagerImpl sync_manager_;
CancelationSignal cancelation_signal_;
WeakHandle<JsBackend> js_backend_;
bool initialization_succeeded_;
StrictMock<SyncManagerObserverMock> manager_observer_;
StrictMock<SyncEncryptionHandlerObserverMock> encryption_observer_;
InternalComponentsFactory::Switches switches_;
InternalComponentsFactory::StorageOption storage_used_;
MockUnrecoverableErrorHandler mock_unrecoverable_error_handler_;
};
TEST_F(SyncManagerTest, GetAllNodesForTypeTest) {
ModelSafeRoutingInfo routing_info;
GetModelSafeRoutingInfo(&routing_info);
sync_manager_.StartSyncingNormally(routing_info, base::Time());
scoped_ptr<base::ListValue> node_list(
sync_manager_.GetAllNodesForType(syncer::PREFERENCES));
// Should have one node: the type root node.
ASSERT_EQ(1U, node_list->GetSize());
const base::DictionaryValue* first_result;
ASSERT_TRUE(node_list->GetDictionary(0, &first_result));
EXPECT_TRUE(first_result->HasKey("ID"));
EXPECT_TRUE(first_result->HasKey("NON_UNIQUE_NAME"));
}
TEST_F(SyncManagerTest, RefreshEncryptionReady) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
const ModelTypeSet encrypted_types = GetEncryptedTypes();
EXPECT_TRUE(encrypted_types.Has(PASSWORDS));
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByIdLookup(GetIdForDataType(NIGORI)));
sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
EXPECT_TRUE(nigori.has_encryption_keybag());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
}
}
// Attempt to refresh encryption when nigori not downloaded.
TEST_F(SyncManagerTest, RefreshEncryptionNotReady) {
// Don't set up encryption (no nigori node created).
// Should fail. Triggers an OnPassphraseRequired because the cryptographer
// is not ready.
EXPECT_CALL(encryption_observer_, OnPassphraseRequired(_, _)).Times(1);
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
const ModelTypeSet encrypted_types = GetEncryptedTypes();
EXPECT_TRUE(encrypted_types.Has(PASSWORDS)); // Hardcoded.
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
}
// Attempt to refresh encryption when nigori is empty.
TEST_F(SyncManagerTest, RefreshEncryptionEmptyNigori) {
EXPECT_TRUE(SetUpEncryption(DONT_WRITE_NIGORI, DEFAULT_ENCRYPTION));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete()).Times(1);
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
// Should write to nigori.
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
const ModelTypeSet encrypted_types = GetEncryptedTypes();
EXPECT_TRUE(encrypted_types.Has(PASSWORDS)); // Hardcoded.
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByIdLookup(GetIdForDataType(NIGORI)));
sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
EXPECT_TRUE(nigori.has_encryption_keybag());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
}
}
TEST_F(SyncManagerTest, EncryptDataTypesWithNoData) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
}
TEST_F(SyncManagerTest, EncryptDataTypesWithData) {
size_t batch_size = 5;
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
// Create some unencrypted unsynced data.
int64_t folder = MakeFolderWithParent(sync_manager_.GetUserShare(), BOOKMARKS,
GetIdForDataType(BOOKMARKS), NULL);
// First batch_size nodes are children of folder.
size_t i;
for (i = 0; i < batch_size; ++i) {
MakeBookmarkWithParent(sync_manager_.GetUserShare(), folder, NULL);
}
// Next batch_size nodes are a different type and on their own.
for (; i < 2*batch_size; ++i) {
MakeNodeWithRoot(sync_manager_.GetUserShare(), SESSIONS,
base::StringPrintf("%" PRIuS "", i));
}
// Last batch_size nodes are a third type that will not need encryption.
for (; i < 3*batch_size; ++i) {
MakeNodeWithRoot(sync_manager_.GetUserShare(), THEMES,
base::StringPrintf("%" PRIuS "", i));
}
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
EXPECT_TRUE(GetEncryptedTypesWithTrans(&trans).Equals(
SyncEncryptionHandler::SensitiveTypes()));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
BOOKMARKS,
false /* not encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
SESSIONS,
false /* not encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
THEMES,
false /* not encrypted */));
}
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
EXPECT_TRUE(GetEncryptedTypesWithTrans(&trans).Equals(
EncryptableUserTypes()));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
BOOKMARKS,
true /* is encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
SESSIONS,
true /* is encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
THEMES,
true /* is encrypted */));
}
// Trigger's a ReEncryptEverything with new passphrase.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetCustomPassphraseAndCheck("new_passphrase");
EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
EXPECT_TRUE(GetEncryptedTypesWithTrans(&trans).Equals(
EncryptableUserTypes()));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
BOOKMARKS,
true /* is encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
SESSIONS,
true /* is encrypted */));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
THEMES,
true /* is encrypted */));
}
// Calling EncryptDataTypes with an empty encrypted types should not trigger
// a reencryption and should just notify immediately.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN)).Times(0);
EXPECT_CALL(encryption_observer_, OnPassphraseAccepted()).Times(0);
EXPECT_CALL(encryption_observer_, OnEncryptionComplete()).Times(0);
sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
}
// Test that when there are no pending keys and the cryptographer is not
// initialized, we add a key based on the current GAIA password.
// (case 1 in SyncManager::SyncInternal::SetEncryptionPassphrase)
TEST_F(SyncManagerTest, SetInitialGaiaPass) {
EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetImplicitPassphraseAndCheck("new_passphrase");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
sync_pb::NigoriSpecifics nigori = node.GetNigoriSpecifics();
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
EXPECT_TRUE(cryptographer->CanDecrypt(nigori.encryption_keybag()));
}
}
// Test that when there are no pending keys and we have on the old GAIA
// password, we update and re-encrypt everything with the new GAIA password.
// (case 1 in SyncManager::SyncInternal::SetEncryptionPassphrase)
TEST_F(SyncManagerTest, UpdateGaiaPass) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
Cryptographer verifier(&encryptor_);
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
std::string bootstrap_token;
cryptographer->GetBootstrapToken(&bootstrap_token);
verifier.Bootstrap(bootstrap_token);
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetImplicitPassphraseAndCheck("new_passphrase");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
// Verify the default key has changed.
sync_pb::EncryptedData encrypted;
cryptographer->GetKeys(&encrypted);
EXPECT_FALSE(verifier.CanDecrypt(encrypted));
}
}
// Sets a new explicit passphrase. This should update the bootstrap token
// and re-encrypt everything.
// (case 2 in SyncManager::SyncInternal::SetEncryptionPassphrase)
TEST_F(SyncManagerTest, SetPassphraseWithPassword) {
Cryptographer verifier(&encryptor_);
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
// Store the default (soon to be old) key.
Cryptographer* cryptographer = trans.GetCryptographer();
std::string bootstrap_token;
cryptographer->GetBootstrapToken(&bootstrap_token);
verifier.Bootstrap(bootstrap_token);
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode password_node(&trans);
WriteNode::InitUniqueByCreationResult result =
password_node.InitUniqueByCreation(PASSWORDS,
root_node, "foo");
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
password_node.SetPasswordSpecifics(data);
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetCustomPassphraseAndCheck("new_passphrase");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
// Verify the default key has changed.
sync_pb::EncryptedData encrypted;
cryptographer->GetKeys(&encrypted);
EXPECT_FALSE(verifier.CanDecrypt(encrypted));
ReadNode password_node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
password_node.InitByClientTagLookup(PASSWORDS,
"foo"));
const sync_pb::PasswordSpecificsData& data =
password_node.GetPasswordSpecifics();
EXPECT_EQ("secret", data.password_value());
}
}
// Manually set the pending keys in the cryptographer/nigori to reflect the data
// being encrypted with a new (unprovided) GAIA password, then supply the
// password.
// (case 7 in SyncManager::SyncInternal::SetDecryptionPassphrase)
TEST_F(SyncManagerTest, SupplyPendingGAIAPass) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
Cryptographer other_cryptographer(&encryptor_);
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
std::string bootstrap_token;
cryptographer->GetBootstrapToken(&bootstrap_token);
other_cryptographer.Bootstrap(bootstrap_token);
// Now update the nigori to reflect the new keys, and update the
// cryptographer to have pending keys.
KeyParams params = {"localhost", "dummy", "passphrase2"};
other_cryptographer.AddKey(params);
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
sync_pb::NigoriSpecifics nigori;
other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
cryptographer->SetPendingKeys(nigori.encryption_keybag());
EXPECT_TRUE(cryptographer->has_pending_keys());
node.SetNigoriSpecifics(nigori);
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
sync_manager_.GetEncryptionHandler()->SetDecryptionPassphrase("passphrase2");
EXPECT_EQ(IMPLICIT_PASSPHRASE,
sync_manager_.GetEncryptionHandler()->GetPassphraseType());
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
// Verify we're encrypting with the new key.
sync_pb::EncryptedData encrypted;
cryptographer->GetKeys(&encrypted);
EXPECT_TRUE(other_cryptographer.CanDecrypt(encrypted));
}
}
// Manually set the pending keys in the cryptographer/nigori to reflect the data
// being encrypted with an old (unprovided) GAIA password. Attempt to supply
// the current GAIA password and verify the bootstrap token is updated. Then
// supply the old GAIA password, and verify we re-encrypt all data with the
// new GAIA password.
// (cases 4 and 5 in SyncManager::SyncInternal::SetEncryptionPassphrase)
TEST_F(SyncManagerTest, SupplyPendingOldGAIAPass) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
Cryptographer other_cryptographer(&encryptor_);
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
std::string bootstrap_token;
cryptographer->GetBootstrapToken(&bootstrap_token);
other_cryptographer.Bootstrap(bootstrap_token);
// Now update the nigori to reflect the new keys, and update the
// cryptographer to have pending keys.
KeyParams params = {"localhost", "dummy", "old_gaia"};
other_cryptographer.AddKey(params);
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
sync_pb::NigoriSpecifics nigori;
other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
node.SetNigoriSpecifics(nigori);
cryptographer->SetPendingKeys(nigori.encryption_keybag());
// other_cryptographer now contains all encryption keys, and is encrypting
// with the newest gaia.
KeyParams new_params = {"localhost", "dummy", "new_gaia"};
other_cryptographer.AddKey(new_params);
}
// The bootstrap token should have been updated. Save it to ensure it's based
// on the new GAIA password.
std::string bootstrap_token;
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN))
.WillOnce(SaveArg<0>(&bootstrap_token));
EXPECT_CALL(encryption_observer_, OnPassphraseRequired(_, _));
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
SetImplicitPassphraseAndCheck("new_gaia");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_initialized());
EXPECT_FALSE(cryptographer->is_ready());
// Verify we're encrypting with the new key, even though we have pending
// keys.
sync_pb::EncryptedData encrypted;
other_cryptographer.GetKeys(&encrypted);
EXPECT_TRUE(cryptographer->CanDecrypt(encrypted));
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetImplicitPassphraseAndCheck("old_gaia");
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
// Verify we're encrypting with the new key.
sync_pb::EncryptedData encrypted;
other_cryptographer.GetKeys(&encrypted);
EXPECT_TRUE(cryptographer->CanDecrypt(encrypted));
// Verify the saved bootstrap token is based on the new gaia password.
Cryptographer temp_cryptographer(&encryptor_);
temp_cryptographer.Bootstrap(bootstrap_token);
EXPECT_TRUE(temp_cryptographer.CanDecrypt(encrypted));
}
}
// Manually set the pending keys in the cryptographer/nigori to reflect the data
// being encrypted with an explicit (unprovided) passphrase, then supply the
// passphrase.
// (case 9 in SyncManager::SyncInternal::SetDecryptionPassphrase)
TEST_F(SyncManagerTest, SupplyPendingExplicitPass) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
Cryptographer other_cryptographer(&encryptor_);
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
std::string bootstrap_token;
cryptographer->GetBootstrapToken(&bootstrap_token);
other_cryptographer.Bootstrap(bootstrap_token);
// Now update the nigori to reflect the new keys, and update the
// cryptographer to have pending keys.
KeyParams params = {"localhost", "dummy", "explicit"};
other_cryptographer.AddKey(params);
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
sync_pb::NigoriSpecifics nigori;
other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
cryptographer->SetPendingKeys(nigori.encryption_keybag());
EXPECT_TRUE(cryptographer->has_pending_keys());
nigori.set_keybag_is_frozen(true);
node.SetNigoriSpecifics(nigori);
}
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_,
OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
EXPECT_CALL(encryption_observer_, OnPassphraseRequired(_, _));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
sync_manager_.GetEncryptionHandler()->Init();
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
sync_manager_.GetEncryptionHandler()->SetDecryptionPassphrase("explicit");
EXPECT_EQ(CUSTOM_PASSPHRASE,
sync_manager_.GetEncryptionHandler()->GetPassphraseType());
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
// Verify we're encrypting with the new key.
sync_pb::EncryptedData encrypted;
cryptographer->GetKeys(&encrypted);
EXPECT_TRUE(other_cryptographer.CanDecrypt(encrypted));
}
}
// Manually set the pending keys in the cryptographer/nigori to reflect the data
// being encrypted with a new (unprovided) GAIA password, then supply the
// password as a user-provided password.
// This is the android case 7/8.
TEST_F(SyncManagerTest, SupplyPendingGAIAPassUserProvided) {
EXPECT_FALSE(SetUpEncryption(DONT_WRITE_NIGORI, UNINITIALIZED));
Cryptographer other_cryptographer(&encryptor_);
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
// Now update the nigori to reflect the new keys, and update the
// cryptographer to have pending keys.
KeyParams params = {"localhost", "dummy", "passphrase"};
other_cryptographer.AddKey(params);
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitTypeRoot(NIGORI));
sync_pb::NigoriSpecifics nigori;
other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
node.SetNigoriSpecifics(nigori);
cryptographer->SetPendingKeys(nigori.encryption_keybag());
EXPECT_FALSE(cryptographer->is_ready());
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetImplicitPassphraseAndCheck("passphrase");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
}
}
TEST_F(SyncManagerTest, SetPassphraseWithEmptyPasswordNode) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
int64_t node_id = 0;
std::string tag = "foo";
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode root_node(&trans);
root_node.InitByRootLookup();
WriteNode password_node(&trans);
WriteNode::InitUniqueByCreationResult result =
password_node.InitUniqueByCreation(PASSWORDS, root_node, tag);
EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
node_id = password_node.GetId();
}
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetCustomPassphraseAndCheck("new_passphrase");
EXPECT_FALSE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode password_node(&trans);
EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
password_node.InitByClientTagLookup(PASSWORDS,
tag));
}
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode password_node(&trans);
EXPECT_EQ(BaseNode::INIT_FAILED_DECRYPT_IF_NECESSARY,
password_node.InitByIdLookup(node_id));
}
}
// Friended by WriteNode, so can't be in an anonymouse namespace.
TEST_F(SyncManagerTest, EncryptBookmarksWithLegacyData) {
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
std::string title;
SyncAPINameToServerName("Google", &title);
std::string url = "http://www.google.com";
std::string raw_title2 = ".."; // An invalid cosmo title.
std::string title2;
SyncAPINameToServerName(raw_title2, &title2);
std::string url2 = "http://www.bla.com";
// Create a bookmark using the legacy format.
int64_t node_id1 =
MakeNodeWithRoot(sync_manager_.GetUserShare(), BOOKMARKS, "testtag");
int64_t node_id2 =
MakeNodeWithRoot(sync_manager_.GetUserShare(), BOOKMARKS, "testtag2");
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url(url);
node.SetEntitySpecifics(entity_specifics);
// Set the old style title.
syncable::MutableEntry* node_entry = node.entry_;
node_entry->PutNonUniqueName(title);
WriteNode node2(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
sync_pb::EntitySpecifics entity_specifics2;
entity_specifics2.mutable_bookmark()->set_url(url2);
node2.SetEntitySpecifics(entity_specifics2);
// Set the old style title.
syncable::MutableEntry* node_entry2 = node2.entry_;
node_entry2->PutNonUniqueName(title2);
}
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
EXPECT_EQ(BOOKMARKS, node.GetModelType());
EXPECT_EQ(title, node.GetTitle());
EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
ReadNode node2(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
EXPECT_EQ(BOOKMARKS, node2.GetModelType());
// We should de-canonicalize the title in GetTitle(), but the title in the
// specifics should be stored in the server legal form.
EXPECT_EQ(raw_title2, node2.GetTitle());
EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
}
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
BOOKMARKS,
false /* not encrypted */));
}
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
sync_manager_.GetEncryptionHandler()->EnableEncryptEverything();
EXPECT_TRUE(IsEncryptEverythingEnabledForTest());
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
EXPECT_TRUE(GetEncryptedTypesWithTrans(&trans).Equals(
EncryptableUserTypes()));
EXPECT_TRUE(syncable::VerifyDataTypeEncryptionForTest(
trans.GetWrappedTrans(),
BOOKMARKS,
true /* is encrypted */));
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(node_id1));
EXPECT_EQ(BOOKMARKS, node.GetModelType());
EXPECT_EQ(title, node.GetTitle());
EXPECT_EQ(title, node.GetBookmarkSpecifics().title());
EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
ReadNode node2(&trans);
EXPECT_EQ(BaseNode::INIT_OK, node2.InitByIdLookup(node_id2));
EXPECT_EQ(BOOKMARKS, node2.GetModelType());
// We should de-canonicalize the title in GetTitle(), but the title in the
// specifics should be stored in the server legal form.
EXPECT_EQ(raw_title2, node2.GetTitle());
EXPECT_EQ(title2, node2.GetBookmarkSpecifics().title());
EXPECT_EQ(url2, node2.GetBookmarkSpecifics().url());
}
}
// Create a bookmark and set the title/url, then verify the data was properly
// set. This replicates the unique way bookmarks have of creating sync nodes.
// See BookmarkChangeProcessor::PlaceSyncNode(..).
TEST_F(SyncManagerTest, CreateLocalBookmark) {
std::string title = "title";
std::string url = "url";
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode bookmark_root(&trans);
ASSERT_EQ(BaseNode::INIT_OK, bookmark_root.InitTypeRoot(BOOKMARKS));
WriteNode node(&trans);
ASSERT_TRUE(node.InitBookmarkByCreation(bookmark_root, NULL));
node.SetIsFolder(false);
node.SetTitle(title);
sync_pb::BookmarkSpecifics bookmark_specifics(node.GetBookmarkSpecifics());
bookmark_specifics.set_url(url);
node.SetBookmarkSpecifics(bookmark_specifics);
}
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode bookmark_root(&trans);
ASSERT_EQ(BaseNode::INIT_OK, bookmark_root.InitTypeRoot(BOOKMARKS));
int64_t child_id = bookmark_root.GetFirstChildId();
ReadNode node(&trans);
ASSERT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(child_id));
EXPECT_FALSE(node.GetIsFolder());
EXPECT_EQ(title, node.GetTitle());
EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
}
}
// Verifies WriteNode::UpdateEntryWithEncryption does not make unnecessary
// changes.
TEST_F(SyncManagerTest, UpdateEntryWithEncryption) {
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("url");
entity_specifics.mutable_bookmark()->set_title("title");
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
syncable::GenerateSyncableHash(BOOKMARKS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to the same data. Should not set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetEntitySpecifics(entity_specifics);
}
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Encrypt the datatatype, should set is_unsynced.
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
specifics.encrypted()));
}
EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Set a new passphrase. Should set is_unsynced.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetCustomPassphraseAndCheck("new_passphrase");
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->is_ready());
EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
specifics.encrypted()));
}
EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Force a re-encrypt everything. Should not set is_unsynced.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
specifics.encrypted()));
}
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to the same data. Should not set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetEntitySpecifics(entity_specifics);
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_FALSE(node_entry->GetIsUnsynced());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
specifics.encrypted()));
}
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to different data. Should set is_unsynced.
{
entity_specifics.mutable_bookmark()->set_url("url2");
entity_specifics.mutable_bookmark()->set_title("title2");
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetEntitySpecifics(entity_specifics);
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_TRUE(node_entry->GetIsUnsynced());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
Cryptographer* cryptographer = trans.GetCryptographer();
EXPECT_TRUE(cryptographer->CanDecryptUsingDefaultKey(
specifics.encrypted()));
}
}
// Passwords have their own handling for encryption. Verify it does not result
// in unnecessary writes via SetEntitySpecifics.
TEST_F(SyncManagerTest, UpdatePasswordSetEntitySpecificsNoChange) {
std::string client_tag = "title";
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
cryptographer->Encrypt(
data,
entity_specifics.mutable_password()->
mutable_encrypted());
}
MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
syncable::GenerateSyncableHash(PASSWORDS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
// Manually change to the same data via SetEntitySpecifics. Should not set
// is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PASSWORDS, client_tag));
node.SetEntitySpecifics(entity_specifics);
}
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
}
// Passwords have their own handling for encryption. Verify it does not result
// in unnecessary writes via SetPasswordSpecifics.
TEST_F(SyncManagerTest, UpdatePasswordSetPasswordSpecifics) {
std::string client_tag = "title";
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
cryptographer->Encrypt(
data,
entity_specifics.mutable_password()->
mutable_encrypted());
}
MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
syncable::GenerateSyncableHash(PASSWORDS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
// Manually change to the same data via SetPasswordSpecifics. Should not set
// is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PASSWORDS, client_tag));
node.SetPasswordSpecifics(node.GetPasswordSpecifics());
}
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
// Manually change to different data. Should set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PASSWORDS, client_tag));
Cryptographer* cryptographer = trans.GetCryptographer();
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret2");
cryptographer->Encrypt(
data,
entity_specifics.mutable_password()->mutable_encrypted());
node.SetPasswordSpecifics(data);
const syncable::Entry* node_entry = node.GetEntry();
EXPECT_TRUE(node_entry->GetIsUnsynced());
}
}
// Passwords have their own handling for encryption. Verify setting a new
// passphrase updates the data.
TEST_F(SyncManagerTest, UpdatePasswordNewPassphrase) {
std::string client_tag = "title";
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
cryptographer->Encrypt(
data,
entity_specifics.mutable_password()->mutable_encrypted());
}
MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
syncable::GenerateSyncableHash(PASSWORDS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
// Set a new passphrase. Should set is_unsynced.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_,
OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
ExpectPassphraseAcceptance();
SetCustomPassphraseAndCheck("new_passphrase");
EXPECT_TRUE(ResetUnsyncedEntry(PASSWORDS, client_tag));
}
// Passwords have their own handling for encryption. Verify it does not result
// in unnecessary writes via ReencryptEverything.
TEST_F(SyncManagerTest, UpdatePasswordReencryptEverything) {
std::string client_tag = "title";
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* cryptographer = trans.GetCryptographer();
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
cryptographer->Encrypt(
data,
entity_specifics.mutable_password()->mutable_encrypted());
}
MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, client_tag,
syncable::GenerateSyncableHash(PASSWORDS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
// Force a re-encrypt everything. Should not set is_unsynced.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, client_tag));
}
// Test that attempting to start up with corrupted password data triggers
// an unrecoverable error (rather than crashing).
TEST_F(SyncManagerTest, ReencryptEverythingWithUnrecoverableErrorPasswords) {
const char kClientTag[] = "client_tag";
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
// Create a synced bookmark with undecryptable data.
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer other_cryptographer(&encryptor_);
KeyParams fake_params = {"localhost", "dummy", "fake_key"};
other_cryptographer.AddKey(fake_params);
sync_pb::PasswordSpecificsData data;
data.set_password_value("secret");
other_cryptographer.Encrypt(
data,
entity_specifics.mutable_password()->mutable_encrypted());
// Set up the real cryptographer with a different key.
KeyParams real_params = {"localhost", "username", "real_key"};
trans.GetCryptographer()->AddKey(real_params);
}
MakeServerNode(sync_manager_.GetUserShare(), PASSWORDS, kClientTag,
syncable::GenerateSyncableHash(PASSWORDS,
kClientTag),
entity_specifics);
EXPECT_FALSE(ResetUnsyncedEntry(PASSWORDS, kClientTag));
// Force a re-encrypt everything. Should trigger an unrecoverable error due
// to being unable to decrypt the data that was previously applied.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
EXPECT_FALSE(HasUnrecoverableError());
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
EXPECT_TRUE(HasUnrecoverableError());
}
// Test that attempting to start up with corrupted bookmark data triggers
// an unrecoverable error (rather than crashing).
TEST_F(SyncManagerTest, ReencryptEverythingWithUnrecoverableErrorBookmarks) {
const char kClientTag[] = "client_tag";
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
sync_pb::EntitySpecifics entity_specifics;
{
// Create a synced bookmark with undecryptable data.
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer other_cryptographer(&encryptor_);
KeyParams fake_params = {"localhost", "dummy", "fake_key"};
other_cryptographer.AddKey(fake_params);
sync_pb::EntitySpecifics bm_specifics;
bm_specifics.mutable_bookmark()->set_title("title");
bm_specifics.mutable_bookmark()->set_url("url");
sync_pb::EncryptedData encrypted;
other_cryptographer.Encrypt(bm_specifics, &encrypted);
entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
// Set up the real cryptographer with a different key.
KeyParams real_params = {"localhost", "username", "real_key"};
trans.GetCryptographer()->AddKey(real_params);
}
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, kClientTag,
syncable::GenerateSyncableHash(BOOKMARKS,
kClientTag),
entity_specifics);
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, kClientTag));
// Force a re-encrypt everything. Should trigger an unrecoverable error due
// to being unable to decrypt the data that was previously applied.
testing::Mock::VerifyAndClearExpectations(&encryption_observer_);
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
EXPECT_FALSE(HasUnrecoverableError());
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
EXPECT_TRUE(HasUnrecoverableError());
}
// Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for bookmarks
// when we write the same data, but does set it when we write new data.
TEST_F(SyncManagerTest, SetBookmarkTitle) {
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("url");
entity_specifics.mutable_bookmark()->set_title("title");
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
syncable::GenerateSyncableHash(BOOKMARKS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to the same title. Should not set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetTitle(client_tag);
}
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to new title. Should set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetTitle("title2");
}
EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
}
// Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
// bookmarks when we write the same data, but does set it when we write new
// data.
TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("url");
entity_specifics.mutable_bookmark()->set_title("title");
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
syncable::GenerateSyncableHash(BOOKMARKS,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Encrypt the datatatype, should set is_unsynced.
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to the same title. Should not set is_unsynced.
// NON_UNIQUE_NAME should be kEncryptedString.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetTitle(client_tag);
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
}
EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
// Manually change to new title. Should set is_unsynced. NON_UNIQUE_NAME
// should still be kEncryptedString.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
node.SetTitle("title2");
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
}
EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
}
// Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
// when we write the same data, but does set it when we write new data.
TEST_F(SyncManagerTest, SetNonBookmarkTitle) {
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_preference()->set_name("name");
entity_specifics.mutable_preference()->set_value("value");
MakeServerNode(sync_manager_.GetUserShare(),
PREFERENCES,
client_tag,
syncable::GenerateSyncableHash(PREFERENCES,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
// Manually change to the same title. Should not set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, client_tag));
node.SetTitle(client_tag);
}
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
// Manually change to new title. Should set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, client_tag));
node.SetTitle("title2");
}
EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
}
// Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
// non-bookmarks when we write the same data or when we write new data
// data (should remained kEncryptedString).
TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_preference()->set_name("name");
entity_specifics.mutable_preference()->set_value("value");
MakeServerNode(sync_manager_.GetUserShare(),
PREFERENCES,
client_tag,
syncable::GenerateSyncableHash(PREFERENCES,
client_tag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
// Encrypt the datatatype, should set is_unsynced.
EXPECT_CALL(encryption_observer_,
OnEncryptedTypesChanged(
HasModelTypes(EncryptableUserTypes()), true));
EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, FULL_ENCRYPTION));
EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, true));
sync_manager_.GetEncryptionHandler()->Init();
PumpLoop();
EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
// Manually change to the same title. Should not set is_unsynced.
// NON_UNIQUE_NAME should be kEncryptedString.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, client_tag));
node.SetTitle(client_tag);
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
}
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
// Manually change to new title. Should not set is_unsynced because the
// NON_UNIQUE_NAME should still be kEncryptedString.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, client_tag));
node.SetTitle("title2");
const syncable::Entry* node_entry = node.GetEntry();
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
EXPECT_FALSE(node_entry->GetIsUnsynced());
}
}
// Ensure that titles are truncated to 255 bytes, and attempting to reset
// them to their longer version does not set IS_UNSYNCED.
TEST_F(SyncManagerTest, SetLongTitle) {
const int kNumChars = 512;
const std::string kClientTag = "tag";
std::string title(kNumChars, '0');
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_preference()->set_name("name");
entity_specifics.mutable_preference()->set_value("value");
MakeServerNode(sync_manager_.GetUserShare(),
PREFERENCES,
"short_title",
syncable::GenerateSyncableHash(PREFERENCES,
kClientTag),
entity_specifics);
// New node shouldn't start off unsynced.
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
// Manually change to the long title. Should set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, kClientTag));
node.SetTitle(title);
EXPECT_EQ(node.GetTitle(), title.substr(0, 255));
}
EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
// Manually change to the same title. Should not set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, kClientTag));
node.SetTitle(title);
EXPECT_EQ(node.GetTitle(), title.substr(0, 255));
}
EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
// Manually change to new title. Should set is_unsynced.
{
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(PREFERENCES, kClientTag));
node.SetTitle("title2");
}
EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
}
// Create an encrypted entry when the cryptographer doesn't think the type is
// marked for encryption. Ensure reads/writes don't break and don't unencrypt
// the data.
TEST_F(SyncManagerTest, SetPreviouslyEncryptedSpecifics) {
std::string client_tag = "tag";
std::string url = "url";
std::string url2 = "new_url";
std::string title = "title";
sync_pb::EntitySpecifics entity_specifics;
EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
{
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
Cryptographer* crypto = trans.GetCryptographer();
sync_pb::EntitySpecifics bm_specifics;
bm_specifics.mutable_bookmark()->set_title("title");
bm_specifics.mutable_bookmark()->set_url("url");
sync_pb::EncryptedData encrypted;
crypto->Encrypt(bm_specifics, &encrypted);
entity_specifics.mutable_encrypted()->CopyFrom(encrypted);
AddDefaultFieldValue(BOOKMARKS, &entity_specifics);
}
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
syncable::GenerateSyncableHash(BOOKMARKS,
client_tag),
entity_specifics);
{
// Verify the data.
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
EXPECT_EQ(title, node.GetTitle());
EXPECT_EQ(url, node.GetBookmarkSpecifics().url());
}
{
// Overwrite the url (which overwrites the specifics).
WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
WriteNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
sync_pb::BookmarkSpecifics bookmark_specifics(node.GetBookmarkSpecifics());
bookmark_specifics.set_url(url2);
node.SetBookmarkSpecifics(bookmark_specifics);
}
{
// Verify it's still encrypted and it has the most recent url.
ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
ReadNode node(&trans);
EXPECT_EQ(BaseNode::INIT_OK,
node.InitByClientTagLookup(BOOKMARKS, client_tag));
EXPECT_EQ(title, node.GetTitle());
EXPECT_EQ(url2, node.GetBookmarkSpecifics().url());
const syncable::Entry* node_entry = node.GetEntry();
EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
EXPECT_TRUE(specifics.has_encrypted());
}
}
// Verify transaction version of a model type is incremented when node of
// that type is updated.
TEST_F(SyncManagerTest, IncrementTransactionVersion) {
ModelSafeRoutingInfo routing_info;
GetModelSafeRoutingInfo(&routing_info);
{
ReadTransaction read_trans(FROM_HERE, sync_manager_.GetUserShare());
for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
i != routing_info.end(); ++i) {
// Transaction version is incremented when SyncManagerTest::SetUp()
// creates a node of each type.
EXPECT_EQ(1,
sync_manager_.GetUserShare()->directory->
GetTransactionVersion(i->first));
}
}
// Create bookmark node to increment transaction version of bookmark model.
std::string client_tag = "title";
sync_pb::EntitySpecifics entity_specifics;
entity_specifics.mutable_bookmark()->set_url("url");
entity_specifics.mutable_bookmark()->set_title("title");
MakeServerNode(sync_manager_.GetUserShare(), BOOKMARKS, client_tag,
syncable::GenerateSyncableHash(BOOKMARKS,
client_tag),
entity_specifics);
{
ReadTransaction read_trans(FROM_HERE, sync_manager_.GetUserShare());
for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
i != routing_info.end(); ++i) {
EXPECT_EQ(i->first == BOOKMARKS ? 2 : 1,
sync_manager_.GetUserShare()->directory->
GetTransactionVersion(i->first));
}
}
}
class MockSyncScheduler : public FakeSyncScheduler {
public:
MockSyncScheduler() : FakeSyncScheduler() {}
virtual ~MockSyncScheduler() {}
MOCK_METHOD2(Start, void(SyncScheduler::Mode, base::Time));
MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
};
class ComponentsFactory : public TestInternalComponentsFactory {
public:
ComponentsFactory(const Switches& switches,
SyncScheduler* scheduler_to_use,
sessions::SyncSessionContext** session_context,
InternalComponentsFactory::StorageOption* storage_used)
: TestInternalComponentsFactory(
switches, InternalComponentsFactory::STORAGE_IN_MEMORY, storage_used),
scheduler_to_use_(scheduler_to_use),
session_context_(session_context) {}
~ComponentsFactory() override {}
scoped_ptr<SyncScheduler> BuildScheduler(
const std::string& name,
sessions::SyncSessionContext* context,
CancelationSignal* stop_handle) override {
*session_context_ = context;
return std::move(scheduler_to_use_);
}
private:
scoped_ptr<SyncScheduler> scheduler_to_use_;
sessions::SyncSessionContext** session_context_;
};
class SyncManagerTestWithMockScheduler : public SyncManagerTest {
public:
SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
InternalComponentsFactory* GetFactory() override {
scheduler_ = new MockSyncScheduler();
return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_,
&storage_used_);
}
MockSyncScheduler* scheduler() { return scheduler_; }
sessions::SyncSessionContext* session_context() {
return session_context_;
}
private:
MockSyncScheduler* scheduler_;
sessions::SyncSessionContext* session_context_;
};
// Test that the configuration params are properly created and sent to
// ScheduleConfigure. No callback should be invoked. Any disabled datatypes
// should be purged.
TEST_F(SyncManagerTestWithMockScheduler, BasicConfiguration) {
ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
ModelSafeRoutingInfo new_routing_info;
GetModelSafeRoutingInfo(&new_routing_info);
ModelTypeSet enabled_types = GetRoutingInfoTypes(new_routing_info);
ModelTypeSet disabled_types = Difference(ModelTypeSet::All(), enabled_types);
ConfigurationParams params;
EXPECT_CALL(*scheduler(), Start(SyncScheduler::CONFIGURATION_MODE, _));
EXPECT_CALL(*scheduler(), ScheduleConfiguration(_)).
WillOnce(SaveArg<0>(&params));
// Set data for all types.
ModelTypeSet protocol_types = ProtocolTypes();
for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
iter.Inc()) {
SetProgressMarkerForType(iter.Get(), true);
}
CallbackCounter ready_task_counter, retry_task_counter;
sync_manager_.ConfigureSyncer(
reason,
types_to_download,
disabled_types,
ModelTypeSet(),
ModelTypeSet(),
new_routing_info,
base::Bind(&CallbackCounter::Callback,
base::Unretained(&ready_task_counter)),
base::Bind(&CallbackCounter::Callback,
base::Unretained(&retry_task_counter)));
EXPECT_EQ(0, ready_task_counter.times_called());
EXPECT_EQ(0, retry_task_counter.times_called());
EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
params.source);
EXPECT_TRUE(types_to_download.Equals(params.types_to_download));
EXPECT_EQ(new_routing_info, params.routing_info);
// Verify all the disabled types were purged.
EXPECT_TRUE(sync_manager_.InitialSyncEndedTypes().Equals(
enabled_types));
EXPECT_TRUE(sync_manager_.GetTypesWithEmptyProgressMarkerToken(
ModelTypeSet::All()).Equals(disabled_types));
}
// Test that on a reconfiguration (configuration where the session context