sync/syncable/syncable_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/files/file_path.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/stl_util.h"
  17 #include "base/synchronization/condition_variable.h"
  18 #include "base/test/values_test_util.h"
  19 #include "base/threading/platform_thread.h"
  20 #include "base/values.h"
  21 #include "sync/protocol/bookmark_specifics.pb.h"
  22 #include "sync/syncable/directory_backing_store.h"
  23 #include "sync/syncable/directory_change_delegate.h"
  24 #include "sync/syncable/directory_unittest.h"
  25 #include "sync/syncable/in_memory_directory_backing_store.h"
  26 #include "sync/syncable/metahandle_set.h"
  27 #include "sync/syncable/mutable_entry.h"
  28 #include "sync/syncable/on_disk_directory_backing_store.h"
  29 #include "sync/syncable/syncable_proto_util.h"
  30 #include "sync/syncable/syncable_read_transaction.h"
  31 #include "sync/syncable/syncable_util.h"
  32 #include "sync/syncable/syncable_write_transaction.h"
  33 #include "sync/test/engine/test_id_factory.h"
  34 #include "sync/test/engine/test_syncable_utils.h"
  35 #include "sync/test/fake_encryptor.h"
  36 #include "sync/test/null_directory_change_delegate.h"
  37 #include "sync/test/null_transaction_observer.h"
  38 #include "sync/util/test_unrecoverable_error_handler.h"
  39 #include "testing/gtest/include/gtest/gtest.h"
  40
  41 namespace syncer {
  42 namespace syncable {
  43
  44 using base::ExpectDictBooleanValue;
  45 using base::ExpectDictStringValue;
  46
  47 // An OnDiskDirectoryBackingStore that can be set to always fail SaveChanges.
  48 class TestBackingStore : public OnDiskDirectoryBackingStore {
  49  public:
  50   TestBackingStore(const std::string& dir_name,
  51                    const base::FilePath& backing_filepath);
  52
  53   virtual ~TestBackingStore();
  54
  55   virtual bool SaveChanges(const Directory::SaveChangesSnapshot& snapshot)
  56       OVERRIDE;
  57
  58    void StartFailingSaveChanges() {
  59      fail_save_changes_ = true;
  60    }
  61
  62  private:
  63    bool fail_save_changes_;
  64 };
  65
  66 TestBackingStore::TestBackingStore(const std::string& dir_name,
  67                                    const base::FilePath& backing_filepath)
  68   : OnDiskDirectoryBackingStore(dir_name, backing_filepath),
  69     fail_save_changes_(false) {
  70 }
  71
  72 TestBackingStore::~TestBackingStore() { }
  73
  74 bool TestBackingStore::SaveChanges(
  75     const Directory::SaveChangesSnapshot& snapshot){
  76   if (fail_save_changes_) {
  77     return false;
  78   } else {
  79     return OnDiskDirectoryBackingStore::SaveChanges(snapshot);
  80   }
  81 }
  82
  83 // A directory whose Save() function can be set to always fail.
  84 class TestDirectory : public Directory {
  85  public:
  86   // A factory function used to work around some initialization order issues.
  87   static TestDirectory* Create(
  88       Encryptor *encryptor,
  89       UnrecoverableErrorHandler *handler,
  90       const std::string& dir_name,
  91       const base::FilePath& backing_filepath);
  92
  93   virtual ~TestDirectory();
  94
  95   void StartFailingSaveChanges() {
  96     backing_store_->StartFailingSaveChanges();
  97   }
  98
  99  private:
 100   TestDirectory(Encryptor* encryptor,
 101                 UnrecoverableErrorHandler* handler,
 102                 TestBackingStore* backing_store);
 103
 104   TestBackingStore* backing_store_;
 105 };
 106
 107 TestDirectory* TestDirectory::Create(
 108     Encryptor *encryptor,
 109     UnrecoverableErrorHandler *handler,
 110     const std::string& dir_name,
 111     const base::FilePath& backing_filepath) {
 112   TestBackingStore* backing_store =
 113       new TestBackingStore(dir_name, backing_filepath);
 114   return new TestDirectory(encryptor, handler, backing_store);
 115 }
 116
 117 TestDirectory::TestDirectory(Encryptor* encryptor,
 118                              UnrecoverableErrorHandler* handler,
 119                              TestBackingStore* backing_store)
 120     : Directory(backing_store, handler, NULL, NULL, NULL),
 121       backing_store_(backing_store) {
 122 }
 123
 124 TestDirectory::~TestDirectory() { }
 125
 126 TEST(OnDiskSyncableDirectory, FailInitialWrite) {
 127   base::MessageLoop message_loop;
 128   FakeEncryptor encryptor;
 129   TestUnrecoverableErrorHandler handler;
 130   base::ScopedTempDir temp_dir;
 131   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 132   base::FilePath file_path = temp_dir.path().Append(
 133       FILE_PATH_LITERAL("Test.sqlite3"));
 134   std::string name = "user@x.com";
 135   NullDirectoryChangeDelegate delegate;
 136
 137   scoped_ptr<TestDirectory> test_dir(
 138       TestDirectory::Create(&encryptor, &handler, name, file_path));
 139
 140   test_dir->StartFailingSaveChanges();
 141   ASSERT_EQ(FAILED_INITIAL_WRITE, test_dir->Open(name, &delegate,
 142                                                  NullTransactionObserver()));
 143 }
 144
 145 // A variant of SyncableDirectoryTest that uses a real sqlite database.
 146 class OnDiskSyncableDirectoryTest : public SyncableDirectoryTest {
 147  protected:
 148   // SetUp() is called before each test case is run.
 149   // The sqlite3 DB is deleted before each test is run.
 150   virtual void SetUp() {
 151     SyncableDirectoryTest::SetUp();
 152     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 153     file_path_ = temp_dir_.path().Append(
 154         FILE_PATH_LITERAL("Test.sqlite3"));
 155     base::DeleteFile(file_path_, true);
 156     CreateDirectory();
 157   }
 158
 159   virtual void TearDown() {
 160     // This also closes file handles.
 161     dir()->SaveChanges();
 162     dir().reset();
 163     base::DeleteFile(file_path_, true);
 164     SyncableDirectoryTest::TearDown();
 165   }
 166
 167   // Creates a new directory.  Deletes the old directory, if it exists.
 168   void CreateDirectory() {
 169     test_directory_ = TestDirectory::Create(
 170         encryptor(), unrecoverable_error_handler(), kDirectoryName, file_path_);
 171     dir().reset(test_directory_);
 172     ASSERT_TRUE(dir().get());
 173     ASSERT_EQ(OPENED,
 174               dir()->Open(kDirectoryName,
 175                           directory_change_delegate(),
 176                           NullTransactionObserver()));
 177     ASSERT_TRUE(dir()->good());
 178   }
 179
 180   void SaveAndReloadDir() {
 181     dir()->SaveChanges();
 182     CreateDirectory();
 183   }
 184
 185   void StartFailingSaveChanges() {
 186     test_directory_->StartFailingSaveChanges();
 187   }
 188
 189   TestDirectory *test_directory_;  // mirrors scoped_ptr<Directory> dir_
 190   base::ScopedTempDir temp_dir_;
 191   base::FilePath file_path_;
 192 };
 193
 194 sync_pb::DataTypeContext BuildContext(ModelType type) {
 195   sync_pb::DataTypeContext context;
 196   context.set_context("context");
 197   context.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
 198   return context;
 199 }
 200
 201 TEST_F(OnDiskSyncableDirectoryTest, TestPurgeEntriesWithTypeIn) {
 202   sync_pb::EntitySpecifics bookmark_specs;
 203   sync_pb::EntitySpecifics autofill_specs;
 204   sync_pb::EntitySpecifics preference_specs;
 205   AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
 206   AddDefaultFieldValue(PREFERENCES, &preference_specs);
 207   AddDefaultFieldValue(AUTOFILL, &autofill_specs);
 208
 209   ModelTypeSet types_to_purge(PREFERENCES, AUTOFILL);
 210
 211   dir()->SetDownloadProgress(BOOKMARKS, BuildProgress(BOOKMARKS));
 212   dir()->SetDownloadProgress(PREFERENCES, BuildProgress(PREFERENCES));
 213   dir()->SetDownloadProgress(AUTOFILL, BuildProgress(AUTOFILL));
 214
 215   TestIdFactory id_factory;
 216   // Create some items for each type.
 217   {
 218     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 219
 220     dir()->SetDataTypeContext(&trans, BOOKMARKS, BuildContext(BOOKMARKS));
 221     dir()->SetDataTypeContext(&trans, PREFERENCES, BuildContext(PREFERENCES));
 222     dir()->SetDataTypeContext(&trans, AUTOFILL, BuildContext(AUTOFILL));
 223
 224     // Make it look like these types have completed initial sync.
 225     CreateTypeRoot(&trans, dir().get(), BOOKMARKS);
 226     CreateTypeRoot(&trans, dir().get(), PREFERENCES);
 227     CreateTypeRoot(&trans, dir().get(), AUTOFILL);
 228
 229     // Add more nodes for this type.  Technically, they should be placed under
 230     // the proper type root nodes but the assertions in this test won't notice
 231     // if their parent isn't quite right.
 232     MutableEntry item1(&trans, CREATE, BOOKMARKS, trans.root_id(), "Item");
 233     ASSERT_TRUE(item1.good());
 234     item1.PutServerSpecifics(bookmark_specs);
 235     item1.PutIsUnsynced(true);
 236
 237     MutableEntry item2(&trans, CREATE_NEW_UPDATE_ITEM,
 238                        id_factory.NewServerId());
 239     ASSERT_TRUE(item2.good());
 240     item2.PutServerSpecifics(bookmark_specs);
 241     item2.PutIsUnappliedUpdate(true);
 242
 243     MutableEntry item3(&trans, CREATE, PREFERENCES,
 244                        trans.root_id(), "Item");
 245     ASSERT_TRUE(item3.good());
 246     item3.PutSpecifics(preference_specs);
 247     item3.PutServerSpecifics(preference_specs);
 248     item3.PutIsUnsynced(true);
 249
 250     MutableEntry item4(&trans, CREATE_NEW_UPDATE_ITEM,
 251                        id_factory.NewServerId());
 252     ASSERT_TRUE(item4.good());
 253     item4.PutServerSpecifics(preference_specs);
 254     item4.PutIsUnappliedUpdate(true);
 255
 256     MutableEntry item5(&trans, CREATE, AUTOFILL,
 257                        trans.root_id(), "Item");
 258     ASSERT_TRUE(item5.good());
 259     item5.PutSpecifics(autofill_specs);
 260     item5.PutServerSpecifics(autofill_specs);
 261     item5.PutIsUnsynced(true);
 262
 263     MutableEntry item6(&trans, CREATE_NEW_UPDATE_ITEM,
 264       id_factory.NewServerId());
 265     ASSERT_TRUE(item6.good());
 266     item6.PutServerSpecifics(autofill_specs);
 267     item6.PutIsUnappliedUpdate(true);
 268   }
 269
 270   dir()->SaveChanges();
 271   {
 272     ReadTransaction trans(FROM_HERE, dir().get());
 273     MetahandleSet all_set;
 274     GetAllMetaHandles(&trans, &all_set);
 275     ASSERT_EQ(10U, all_set.size());
 276   }
 277
 278   dir()->PurgeEntriesWithTypeIn(types_to_purge, ModelTypeSet(), ModelTypeSet());
 279
 280   // We first query the in-memory data, and then reload the directory (without
 281   // saving) to verify that disk does not still have the data.
 282   CheckPurgeEntriesWithTypeInSucceeded(types_to_purge, true);
 283   SaveAndReloadDir();
 284   CheckPurgeEntriesWithTypeInSucceeded(types_to_purge, false);
 285 }
 286
 287 TEST_F(OnDiskSyncableDirectoryTest, TestShareInfo) {
 288   dir()->set_store_birthday("Jan 31st");
 289   const char* const bag_of_chips_array = "\0bag of chips";
 290   const std::string bag_of_chips_string =
 291       std::string(bag_of_chips_array, sizeof(bag_of_chips_array));
 292   dir()->set_bag_of_chips(bag_of_chips_string);
 293   {
 294     ReadTransaction trans(FROM_HERE, dir().get());
 295     EXPECT_EQ("Jan 31st", dir()->store_birthday());
 296     EXPECT_EQ(bag_of_chips_string, dir()->bag_of_chips());
 297   }
 298   dir()->set_store_birthday("April 10th");
 299   const char* const bag_of_chips2_array = "\0bag of chips2";
 300   const std::string bag_of_chips2_string =
 301       std::string(bag_of_chips2_array, sizeof(bag_of_chips2_array));
 302   dir()->set_bag_of_chips(bag_of_chips2_string);
 303   dir()->SaveChanges();
 304   {
 305     ReadTransaction trans(FROM_HERE, dir().get());
 306     EXPECT_EQ("April 10th", dir()->store_birthday());
 307     EXPECT_EQ(bag_of_chips2_string, dir()->bag_of_chips());
 308   }
 309   const char* const bag_of_chips3_array = "\0bag of chips3";
 310   const std::string bag_of_chips3_string =
 311       std::string(bag_of_chips3_array, sizeof(bag_of_chips3_array));
 312   dir()->set_bag_of_chips(bag_of_chips3_string);
 313   // Restore the directory from disk.  Make sure that nothing's changed.
 314   SaveAndReloadDir();
 315   {
 316     ReadTransaction trans(FROM_HERE, dir().get());
 317     EXPECT_EQ("April 10th", dir()->store_birthday());
 318     EXPECT_EQ(bag_of_chips3_string, dir()->bag_of_chips());
 319   }
 320 }
 321
 322 TEST_F(OnDiskSyncableDirectoryTest,
 323        TestSimpleFieldsPreservedDuringSaveChanges) {
 324   Id update_id = TestIdFactory::FromNumber(1);
 325   Id create_id;
 326   EntryKernel create_pre_save, update_pre_save;
 327   EntryKernel create_post_save, update_post_save;
 328   std::string create_name =  "Create";
 329
 330   {
 331     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 332     MutableEntry create(
 333         &trans, CREATE, BOOKMARKS, trans.root_id(), create_name);
 334     MutableEntry update(&trans, CREATE_NEW_UPDATE_ITEM, update_id);
 335     create.PutIsUnsynced(true);
 336     update.PutIsUnappliedUpdate(true);
 337     sync_pb::EntitySpecifics specifics;
 338     specifics.mutable_bookmark()->set_favicon("PNG");
 339     specifics.mutable_bookmark()->set_url("http://nowhere");
 340     create.PutSpecifics(specifics);
 341     update.PutServerSpecifics(specifics);
 342     create_pre_save = create.GetKernelCopy();
 343     update_pre_save = update.GetKernelCopy();
 344     create_id = create.GetId();
 345   }
 346
 347   dir()->SaveChanges();
 348   dir().reset(
 349       new Directory(new OnDiskDirectoryBackingStore(kDirectoryName, file_path_),
 350                     unrecoverable_error_handler(),
 351                     NULL,
 352                     NULL,
 353                     NULL));
 354
 355   ASSERT_TRUE(dir().get());
 356   ASSERT_EQ(OPENED,
 357             dir()->Open(kDirectoryName,
 358                         directory_change_delegate(),
 359                         NullTransactionObserver()));
 360   ASSERT_TRUE(dir()->good());
 361
 362   {
 363     ReadTransaction trans(FROM_HERE, dir().get());
 364     Entry create(&trans, GET_BY_ID, create_id);
 365     EXPECT_EQ(1, CountEntriesWithName(&trans, trans.root_id(), create_name));
 366     Entry update(&trans, GET_BY_ID, update_id);
 367     create_post_save = create.GetKernelCopy();
 368     update_post_save = update.GetKernelCopy();
 369   }
 370   int i = BEGIN_FIELDS;
 371   for ( ; i < INT64_FIELDS_END ; ++i) {
 372     EXPECT_EQ(create_pre_save.ref((Int64Field)i) +
 373                   (i == TRANSACTION_VERSION ? 1 : 0),
 374               create_post_save.ref((Int64Field)i))
 375               << "int64 field #" << i << " changed during save/load";
 376     EXPECT_EQ(update_pre_save.ref((Int64Field)i),
 377               update_post_save.ref((Int64Field)i))
 378         << "int64 field #" << i << " changed during save/load";
 379   }
 380   for ( ; i < TIME_FIELDS_END ; ++i) {
 381     EXPECT_EQ(create_pre_save.ref((TimeField)i),
 382               create_post_save.ref((TimeField)i))
 383               << "time field #" << i << " changed during save/load";
 384     EXPECT_EQ(update_pre_save.ref((TimeField)i),
 385               update_post_save.ref((TimeField)i))
 386               << "time field #" << i << " changed during save/load";
 387   }
 388   for ( ; i < ID_FIELDS_END ; ++i) {
 389     EXPECT_EQ(create_pre_save.ref((IdField)i),
 390               create_post_save.ref((IdField)i))
 391               << "id field #" << i << " changed during save/load";
 392     EXPECT_EQ(update_pre_save.ref((IdField)i),
 393               update_pre_save.ref((IdField)i))
 394               << "id field #" << i << " changed during save/load";
 395   }
 396   for ( ; i < BIT_FIELDS_END ; ++i) {
 397     EXPECT_EQ(create_pre_save.ref((BitField)i),
 398               create_post_save.ref((BitField)i))
 399               << "Bit field #" << i << " changed during save/load";
 400     EXPECT_EQ(update_pre_save.ref((BitField)i),
 401               update_post_save.ref((BitField)i))
 402               << "Bit field #" << i << " changed during save/load";
 403   }
 404   for ( ; i < STRING_FIELDS_END ; ++i) {
 405     EXPECT_EQ(create_pre_save.ref((StringField)i),
 406               create_post_save.ref((StringField)i))
 407               << "String field #" << i << " changed during save/load";
 408     EXPECT_EQ(update_pre_save.ref((StringField)i),
 409               update_post_save.ref((StringField)i))
 410               << "String field #" << i << " changed during save/load";
 411   }
 412   for ( ; i < PROTO_FIELDS_END; ++i) {
 413     EXPECT_EQ(create_pre_save.ref((ProtoField)i).SerializeAsString(),
 414               create_post_save.ref((ProtoField)i).SerializeAsString())
 415               << "Blob field #" << i << " changed during save/load";
 416     EXPECT_EQ(update_pre_save.ref((ProtoField)i).SerializeAsString(),
 417               update_post_save.ref((ProtoField)i).SerializeAsString())
 418               << "Blob field #" << i << " changed during save/load";
 419   }
 420   for ( ; i < UNIQUE_POSITION_FIELDS_END; ++i) {
 421     EXPECT_TRUE(create_pre_save.ref((UniquePositionField)i).Equals(
 422         create_post_save.ref((UniquePositionField)i)))
 423         << "Position field #" << i << " changed during save/load";
 424     EXPECT_TRUE(update_pre_save.ref((UniquePositionField)i).Equals(
 425         update_post_save.ref((UniquePositionField)i)))
 426         << "Position field #" << i << " changed during save/load";
 427   }
 428 }
 429
 430 TEST_F(OnDiskSyncableDirectoryTest, TestSaveChangesFailure) {
 431   int64 handle1 = 0;
 432   // Set up an item using a regular, saveable directory.
 433   {
 434     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 435
 436     MutableEntry e1(&trans, CREATE, BOOKMARKS, trans.root_id(), "aguilera");
 437     ASSERT_TRUE(e1.good());
 438     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
 439     handle1 = e1.GetMetahandle();
 440     e1.PutBaseVersion(1);
 441     e1.PutIsDir(true);
 442     e1.PutId(TestIdFactory::FromNumber(101));
 443     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
 444     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 445   }
 446   ASSERT_TRUE(dir()->SaveChanges());
 447
 448   // Make sure the item is no longer dirty after saving,
 449   // and make a modification.
 450   {
 451     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 452
 453     MutableEntry aguilera(&trans, GET_BY_HANDLE, handle1);
 454     ASSERT_TRUE(aguilera.good());
 455     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
 456     EXPECT_EQ(aguilera.GetNonUniqueName(), "aguilera");
 457     aguilera.PutNonUniqueName("overwritten");
 458     EXPECT_TRUE(aguilera.GetKernelCopy().is_dirty());
 459     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 460   }
 461   ASSERT_TRUE(dir()->SaveChanges());
 462
 463   // Now do some operations when SaveChanges() will fail.
 464   StartFailingSaveChanges();
 465   ASSERT_TRUE(dir()->good());
 466
 467   int64 handle2 = 0;
 468   {
 469     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 470
 471     MutableEntry aguilera(&trans, GET_BY_HANDLE, handle1);
 472     ASSERT_TRUE(aguilera.good());
 473     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
 474     EXPECT_EQ(aguilera.GetNonUniqueName(), "overwritten");
 475     EXPECT_FALSE(aguilera.GetKernelCopy().is_dirty());
 476     EXPECT_FALSE(IsInDirtyMetahandles(handle1));
 477     aguilera.PutNonUniqueName("christina");
 478     EXPECT_TRUE(aguilera.GetKernelCopy().is_dirty());
 479     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 480
 481     // New item.
 482     MutableEntry kids_on_block(
 483         &trans, CREATE, BOOKMARKS, trans.root_id(), "kids");
 484     ASSERT_TRUE(kids_on_block.good());
 485     handle2 = kids_on_block.GetMetahandle();
 486     kids_on_block.PutBaseVersion(1);
 487     kids_on_block.PutIsDir(true);
 488     kids_on_block.PutId(TestIdFactory::FromNumber(102));
 489     EXPECT_TRUE(kids_on_block.GetKernelCopy().is_dirty());
 490     EXPECT_TRUE(IsInDirtyMetahandles(handle2));
 491   }
 492
 493   // We are using an unsaveable directory, so this can't succeed.  However,
 494   // the HandleSaveChangesFailure code path should have been triggered.
 495   ASSERT_FALSE(dir()->SaveChanges());
 496
 497   // Make sure things were rolled back and the world is as it was before call.
 498   {
 499     ReadTransaction trans(FROM_HERE, dir().get());
 500     Entry e1(&trans, GET_BY_HANDLE, handle1);
 501     ASSERT_TRUE(e1.good());
 502     EntryKernel aguilera = e1.GetKernelCopy();
 503     Entry kids(&trans, GET_BY_HANDLE, handle2);
 504     ASSERT_TRUE(kids.good());
 505     EXPECT_TRUE(kids.GetKernelCopy().is_dirty());
 506     EXPECT_TRUE(IsInDirtyMetahandles(handle2));
 507     EXPECT_TRUE(aguilera.is_dirty());
 508     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 509   }
 510 }
 511
 512 TEST_F(OnDiskSyncableDirectoryTest, TestSaveChangesFailureWithPurge) {
 513   int64 handle1 = 0;
 514   // Set up an item and progress marker using a regular, saveable directory.
 515   dir()->SetDownloadProgress(BOOKMARKS, BuildProgress(BOOKMARKS));
 516   {
 517     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 518
 519     MutableEntry e1(&trans, CREATE, BOOKMARKS, trans.root_id(), "aguilera");
 520     ASSERT_TRUE(e1.good());
 521     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
 522     handle1 = e1.GetMetahandle();
 523     e1.PutBaseVersion(1);
 524     e1.PutIsDir(true);
 525     e1.PutId(TestIdFactory::FromNumber(101));
 526     sync_pb::EntitySpecifics bookmark_specs;
 527     AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
 528     e1.PutSpecifics(bookmark_specs);
 529     e1.PutServerSpecifics(bookmark_specs);
 530     e1.PutId(TestIdFactory::FromNumber(101));
 531     EXPECT_TRUE(e1.GetKernelCopy().is_dirty());
 532     EXPECT_TRUE(IsInDirtyMetahandles(handle1));
 533   }
 534   ASSERT_TRUE(dir()->SaveChanges());
 535
 536   // Now do some operations while SaveChanges() is set to fail.
 537   StartFailingSaveChanges();
 538   ASSERT_TRUE(dir()->good());
 539
 540   ModelTypeSet set(BOOKMARKS);
 541   dir()->PurgeEntriesWithTypeIn(set, ModelTypeSet(), ModelTypeSet());
 542   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
 543   ASSERT_FALSE(dir()->SaveChanges());
 544   EXPECT_TRUE(IsInMetahandlesToPurge(handle1));
 545 }
 546
 547 class SyncableDirectoryManagement : public testing::Test {
 548  public:
 549   virtual void SetUp() {
 550     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 551   }
 552
 553   virtual void TearDown() {
 554   }
 555  protected:
 556   base::MessageLoop message_loop_;
 557   base::ScopedTempDir temp_dir_;
 558   FakeEncryptor encryptor_;
 559   TestUnrecoverableErrorHandler handler_;
 560   NullDirectoryChangeDelegate delegate_;
 561 };
 562
 563 TEST_F(SyncableDirectoryManagement, TestFileRelease) {
 564   base::FilePath path =
 565       temp_dir_.path().Append(Directory::kSyncDatabaseFilename);
 566
 567   Directory dir(new OnDiskDirectoryBackingStore("ScopeTest", path),
 568                 &handler_,
 569                 NULL,
 570                 NULL,
 571                 NULL);
 572   DirOpenResult result =
 573       dir.Open("ScopeTest", &delegate_, NullTransactionObserver());
 574   ASSERT_EQ(result, OPENED);
 575   dir.Close();
 576
 577   // Closing the directory should have released the backing database file.
 578   ASSERT_TRUE(base::DeleteFile(path, true));
 579 }
 580
 581 class SyncableClientTagTest : public SyncableDirectoryTest {
 582  public:
 583   static const int kBaseVersion = 1;
 584   const char* test_name_;
 585   const char* test_tag_;
 586
 587   SyncableClientTagTest() : test_name_("test_name"), test_tag_("dietcoke") {}
 588
 589   bool CreateWithDefaultTag(Id id, bool deleted) {
 590     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir().get());
 591     MutableEntry me(&wtrans, CREATE, PREFERENCES,
 592                     wtrans.root_id(), test_name_);
 593     CHECK(me.good());
 594     me.PutId(id);
 595     if (id.ServerKnows()) {
 596       me.PutBaseVersion(kBaseVersion);
 597     }
 598     me.PutIsUnsynced(true);
 599     me.PutIsDel(deleted);
 600     me.PutIsDir(false);
 601     return me.PutUniqueClientTag(test_tag_);
 602   }
 603
 604   // Verify an entry exists with the default tag.
 605   void VerifyTag(Id id, bool deleted) {
 606     // Should still be present and valid in the client tag index.
 607     ReadTransaction trans(FROM_HERE, dir().get());
 608     Entry me(&trans, GET_BY_CLIENT_TAG, test_tag_);
 609     CHECK(me.good());
 610     EXPECT_EQ(me.GetId(), id);
 611     EXPECT_EQ(me.GetUniqueClientTag(), test_tag_);
 612     EXPECT_EQ(me.GetIsDel(), deleted);
 613
 614     // We only sync deleted items that the server knew about.
 615     if (me.GetId().ServerKnows() || !me.GetIsDel()) {
 616       EXPECT_EQ(me.GetIsUnsynced(), true);
 617     }
 618   }
 619
 620  protected:
 621   TestIdFactory factory_;
 622 };
 623
 624 TEST_F(SyncableClientTagTest, TestClientTagClear) {
 625   Id server_id = factory_.NewServerId();
 626   EXPECT_TRUE(CreateWithDefaultTag(server_id, false));
 627   {
 628     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 629     MutableEntry me(&trans, GET_BY_CLIENT_TAG, test_tag_);
 630     EXPECT_TRUE(me.good());
 631     me.PutUniqueClientTag(std::string());
 632   }
 633   {
 634     ReadTransaction trans(FROM_HERE, dir().get());
 635     Entry by_tag(&trans, GET_BY_CLIENT_TAG, test_tag_);
 636     EXPECT_FALSE(by_tag.good());
 637
 638     Entry by_id(&trans, GET_BY_ID, server_id);
 639     EXPECT_TRUE(by_id.good());
 640     EXPECT_TRUE(by_id.GetUniqueClientTag().empty());
 641   }
 642 }
 643
 644 TEST_F(SyncableClientTagTest, TestClientTagIndexServerId) {
 645   Id server_id = factory_.NewServerId();
 646   EXPECT_TRUE(CreateWithDefaultTag(server_id, false));
 647   VerifyTag(server_id, false);
 648 }
 649
 650 TEST_F(SyncableClientTagTest, TestClientTagIndexClientId) {
 651   Id client_id = factory_.NewLocalId();
 652   EXPECT_TRUE(CreateWithDefaultTag(client_id, false));
 653   VerifyTag(client_id, false);
 654 }
 655
 656 TEST_F(SyncableClientTagTest, TestDeletedClientTagIndexClientId) {
 657   Id client_id = factory_.NewLocalId();
 658   EXPECT_TRUE(CreateWithDefaultTag(client_id, true));
 659   VerifyTag(client_id, true);
 660 }
 661
 662 TEST_F(SyncableClientTagTest, TestDeletedClientTagIndexServerId) {
 663   Id server_id = factory_.NewServerId();
 664   EXPECT_TRUE(CreateWithDefaultTag(server_id, true));
 665   VerifyTag(server_id, true);
 666 }
 667
 668 TEST_F(SyncableClientTagTest, TestClientTagIndexDuplicateServer) {
 669   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
 670   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
 671   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
 672   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
 673   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 674 }
 675
 676 }  // namespace syncable
 677 }  // namespace syncer