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