1 // Copyright (c) 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 "chrome/browser/chromeos/contacts/contact_database.h" 6 7 #include <string> 8 9 #include "base/bind.h" 10 #include "base/file_util.h" 11 #include "base/files/file_enumerator.h" 12 #include "base/files/file_path.h" 13 #include "base/files/scoped_temp_dir.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/memory/scoped_vector.h" 16 #include "base/message_loop/message_loop.h" 17 #include "chrome/browser/chromeos/contacts/contact.pb.h" 18 #include "chrome/browser/chromeos/contacts/contact_test_util.h" 19 #include "content/public/browser/browser_thread.h" 20 #include "content/public/test/test_browser_thread.h" 21 #include "testing/gtest/include/gtest/gtest.h" 22 #include "ui/gfx/size.h" 23 24 using content::BrowserThread; 25 26 namespace contacts { 27 namespace test { 28 29 // Name of the directory created within a temporary directory to store the 30 // contacts database. 31 const base::FilePath::CharType kDatabaseDirectoryName[] = 32 FILE_PATH_LITERAL("contacts"); 33 34 class ContactDatabaseTest : public testing::Test { 35 public: 36 ContactDatabaseTest() 37 : ui_thread_(BrowserThread::UI, &message_loop_), 38 db_(NULL) { 39 } 40 41 virtual ~ContactDatabaseTest() { 42 } 43 44 protected: 45 // testing::Test implementation. 46 virtual void SetUp() OVERRIDE { 47 CHECK(temp_dir_.CreateUniqueTempDir()); 48 CreateDatabase(); 49 } 50 51 virtual void TearDown() OVERRIDE { 52 DestroyDatabase(); 53 } 54 55 protected: 56 base::FilePath database_path() const { 57 return temp_dir_.path().Append(kDatabaseDirectoryName); 58 } 59 60 void CreateDatabase() { 61 DestroyDatabase(); 62 db_ = new ContactDatabase; 63 db_->Init(database_path(), 64 base::Bind(&ContactDatabaseTest::OnDatabaseInitialized, 65 base::Unretained(this))); 66 67 // The database will be initialized on the file thread; run the message loop 68 // until that happens. 69 message_loop_.Run(); 70 } 71 72 void DestroyDatabase() { 73 if (db_) { 74 db_->DestroyOnUIThread(); 75 db_ = NULL; 76 } 77 } 78 79 // Calls ContactDatabase::SaveContacts() and blocks until the operation is 80 // complete. 81 void SaveContacts(scoped_ptr<ContactPointers> contacts_to_save, 82 scoped_ptr<ContactDatabaseInterface::ContactIds> 83 contact_ids_to_delete, 84 scoped_ptr<UpdateMetadata> metadata, 85 bool is_full_update) { 86 CHECK(db_); 87 db_->SaveContacts(contacts_to_save.Pass(), 88 contact_ids_to_delete.Pass(), 89 metadata.Pass(), 90 is_full_update, 91 base::Bind(&ContactDatabaseTest::OnContactsSaved, 92 base::Unretained(this))); 93 message_loop_.Run(); 94 } 95 96 // Calls ContactDatabase::LoadContacts() and blocks until the operation is 97 // complete. 98 void LoadContacts(scoped_ptr<ScopedVector<Contact> >* contacts_out, 99 scoped_ptr<UpdateMetadata>* metadata_out) { 100 CHECK(db_); 101 db_->LoadContacts(base::Bind(&ContactDatabaseTest::OnContactsLoaded, 102 base::Unretained(this))); 103 message_loop_.Run(); 104 contacts_out->swap(loaded_contacts_); 105 metadata_out->swap(loaded_metadata_); 106 } 107 108 private: 109 void OnDatabaseInitialized(bool success) { 110 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 111 CHECK(success); 112 // TODO(derat): Move google_apis::test::RunBlockingPoolTask() to a shared 113 // location and use it for these tests. 114 message_loop_.Quit(); 115 } 116 117 void OnContactsSaved(bool success) { 118 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 119 CHECK(success); 120 message_loop_.Quit(); 121 } 122 123 void OnContactsLoaded(bool success, 124 scoped_ptr<ScopedVector<Contact> > contacts, 125 scoped_ptr<UpdateMetadata> metadata) { 126 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 127 CHECK(success); 128 loaded_contacts_.swap(contacts); 129 loaded_metadata_.swap(metadata); 130 message_loop_.Quit(); 131 } 132 133 base::MessageLoopForUI message_loop_; 134 content::TestBrowserThread ui_thread_; 135 136 // Temporary directory where the database is saved. 137 base::ScopedTempDir temp_dir_; 138 139 // This class retains ownership of this object. 140 ContactDatabase* db_; 141 142 // Contacts and metadata returned by the most-recent 143 // ContactDatabase::LoadContacts() call. Used to pass returned values from 144 // OnContactsLoaded() to LoadContacts(). 145 scoped_ptr<ScopedVector<Contact> > loaded_contacts_; 146 scoped_ptr<UpdateMetadata> loaded_metadata_; 147 148 DISALLOW_COPY_AND_ASSIGN(ContactDatabaseTest); 149 }; 150 151 TEST_F(ContactDatabaseTest, SaveAndReload) { 152 // Save a contact to the database and check that we get the same data back 153 // when loading it. 154 const std::string kContactId = "contact_id_1"; 155 scoped_ptr<Contact> contact(new Contact); 156 InitContact(kContactId, "1", false, contact.get()); 157 AddEmailAddress("email_1", Contact_AddressType_Relation_HOME, 158 "email_label_1", true, contact.get()); 159 AddEmailAddress("email_2", Contact_AddressType_Relation_WORK, 160 "", false, contact.get()); 161 AddPhoneNumber("123-456-7890", Contact_AddressType_Relation_HOME, 162 "phone_label", true, contact.get()); 163 AddPostalAddress("postal_1", Contact_AddressType_Relation_HOME, 164 "postal_label_1", true, contact.get()); 165 AddPostalAddress("postal_2", Contact_AddressType_Relation_OTHER, 166 "postal_label_2", false, contact.get()); 167 AddInstantMessagingAddress("im_1", 168 Contact_InstantMessagingAddress_Protocol_AIM, 169 Contact_AddressType_Relation_HOME, 170 "im_label_1", true, contact.get()); 171 SetPhoto(gfx::Size(20, 20), contact.get()); 172 scoped_ptr<ContactPointers> contacts_to_save(new ContactPointers); 173 contacts_to_save->push_back(contact.get()); 174 scoped_ptr<ContactDatabaseInterface::ContactIds> contact_ids_to_delete( 175 new ContactDatabaseInterface::ContactIds); 176 177 const int64 kLastUpdateTime = 1234; 178 scoped_ptr<UpdateMetadata> metadata_to_save(new UpdateMetadata); 179 metadata_to_save->set_last_update_start_time(kLastUpdateTime); 180 181 SaveContacts(contacts_to_save.Pass(), 182 contact_ids_to_delete.Pass(), 183 metadata_to_save.Pass(), 184 true); 185 scoped_ptr<ScopedVector<Contact> > loaded_contacts; 186 scoped_ptr<UpdateMetadata> loaded_metadata; 187 LoadContacts(&loaded_contacts, &loaded_metadata); 188 EXPECT_EQ(VarContactsToString(1, contact.get()), 189 ContactsToString(*loaded_contacts)); 190 EXPECT_EQ(kLastUpdateTime, loaded_metadata->last_update_start_time()); 191 192 // Modify the contact, save it, and check that the loaded contact is also 193 // updated. 194 InitContact(kContactId, "2", false, contact.get()); 195 AddEmailAddress("email_3", Contact_AddressType_Relation_OTHER, 196 "email_label_2", true, contact.get()); 197 AddPhoneNumber("phone_2", Contact_AddressType_Relation_OTHER, 198 "phone_label_2", false, contact.get()); 199 AddPostalAddress("postal_3", Contact_AddressType_Relation_HOME, 200 "postal_label_3", true, contact.get()); 201 SetPhoto(gfx::Size(64, 64), contact.get()); 202 contacts_to_save.reset(new ContactPointers); 203 contacts_to_save->push_back(contact.get()); 204 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 205 metadata_to_save.reset(new UpdateMetadata); 206 const int64 kNewLastUpdateTime = 5678; 207 metadata_to_save->set_last_update_start_time(kNewLastUpdateTime); 208 SaveContacts(contacts_to_save.Pass(), 209 contact_ids_to_delete.Pass(), 210 metadata_to_save.Pass(), 211 true); 212 213 LoadContacts(&loaded_contacts, &loaded_metadata); 214 EXPECT_EQ(VarContactsToString(1, contact.get()), 215 ContactsToString(*loaded_contacts)); 216 EXPECT_EQ(kNewLastUpdateTime, loaded_metadata->last_update_start_time()); 217 } 218 219 TEST_F(ContactDatabaseTest, FullAndIncrementalUpdates) { 220 // Do a full update that inserts two contacts into the database. 221 const std::string kContactId1 = "contact_id_1"; 222 const std::string kSharedEmail = "foo (at) example.org"; 223 scoped_ptr<Contact> contact1(new Contact); 224 InitContact(kContactId1, "1", false, contact1.get()); 225 AddEmailAddress(kSharedEmail, Contact_AddressType_Relation_HOME, 226 "", true, contact1.get()); 227 228 const std::string kContactId2 = "contact_id_2"; 229 scoped_ptr<Contact> contact2(new Contact); 230 InitContact(kContactId2, "2", false, contact2.get()); 231 AddEmailAddress(kSharedEmail, Contact_AddressType_Relation_WORK, 232 "", true, contact2.get()); 233 234 scoped_ptr<ContactPointers> contacts_to_save(new ContactPointers); 235 contacts_to_save->push_back(contact1.get()); 236 contacts_to_save->push_back(contact2.get()); 237 scoped_ptr<ContactDatabaseInterface::ContactIds> contact_ids_to_delete( 238 new ContactDatabaseInterface::ContactIds); 239 scoped_ptr<UpdateMetadata> metadata_to_save(new UpdateMetadata); 240 SaveContacts(contacts_to_save.Pass(), 241 contact_ids_to_delete.Pass(), 242 metadata_to_save.Pass(), 243 true); 244 245 scoped_ptr<ScopedVector<Contact> > loaded_contacts; 246 scoped_ptr<UpdateMetadata> loaded_metadata; 247 LoadContacts(&loaded_contacts, &loaded_metadata); 248 EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()), 249 ContactsToString(*loaded_contacts)); 250 251 // Do an incremental update including just the second contact. 252 InitContact(kContactId2, "2b", false, contact2.get()); 253 AddPostalAddress("postal_1", Contact_AddressType_Relation_HOME, 254 "", true, contact2.get()); 255 contacts_to_save.reset(new ContactPointers); 256 contacts_to_save->push_back(contact2.get()); 257 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 258 metadata_to_save.reset(new UpdateMetadata); 259 SaveContacts(contacts_to_save.Pass(), 260 contact_ids_to_delete.Pass(), 261 metadata_to_save.Pass(), 262 false); 263 LoadContacts(&loaded_contacts, &loaded_metadata); 264 EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()), 265 ContactsToString(*loaded_contacts)); 266 267 // Do an empty incremental update and check that the metadata is still 268 // updated. 269 contacts_to_save.reset(new ContactPointers); 270 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 271 metadata_to_save.reset(new UpdateMetadata); 272 const int64 kLastUpdateTime = 1234; 273 metadata_to_save->set_last_update_start_time(kLastUpdateTime); 274 SaveContacts(contacts_to_save.Pass(), 275 contact_ids_to_delete.Pass(), 276 metadata_to_save.Pass(), 277 false); 278 LoadContacts(&loaded_contacts, &loaded_metadata); 279 EXPECT_EQ(VarContactsToString(2, contact1.get(), contact2.get()), 280 ContactsToString(*loaded_contacts)); 281 EXPECT_EQ(kLastUpdateTime, loaded_metadata->last_update_start_time()); 282 283 // Do a full update including just the first contact. The second contact 284 // should be removed from the database. 285 InitContact(kContactId1, "1b", false, contact1.get()); 286 AddPostalAddress("postal_2", Contact_AddressType_Relation_WORK, 287 "", true, contact1.get()); 288 AddPhoneNumber("phone", Contact_AddressType_Relation_HOME, 289 "", true, contact1.get()); 290 contacts_to_save.reset(new ContactPointers); 291 contacts_to_save->push_back(contact1.get()); 292 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 293 metadata_to_save.reset(new UpdateMetadata); 294 SaveContacts(contacts_to_save.Pass(), 295 contact_ids_to_delete.Pass(), 296 metadata_to_save.Pass(), 297 true); 298 LoadContacts(&loaded_contacts, &loaded_metadata); 299 EXPECT_EQ(VarContactsToString(1, contact1.get()), 300 ContactsToString(*loaded_contacts)); 301 302 // Do a full update including no contacts. The database should be cleared. 303 contacts_to_save.reset(new ContactPointers); 304 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 305 metadata_to_save.reset(new UpdateMetadata); 306 SaveContacts(contacts_to_save.Pass(), 307 contact_ids_to_delete.Pass(), 308 metadata_to_save.Pass(), 309 true); 310 LoadContacts(&loaded_contacts, &loaded_metadata); 311 EXPECT_TRUE(loaded_contacts->empty()); 312 } 313 314 // Test that we create a new database when we encounter a corrupted one. 315 TEST_F(ContactDatabaseTest, DeleteWhenCorrupt) { 316 DestroyDatabase(); 317 // Overwrite all of the files in the database with a space character. 318 base::FileEnumerator enumerator( 319 database_path(), false, base::FileEnumerator::FILES); 320 for (base::FilePath path = enumerator.Next(); !path.empty(); 321 path = enumerator.Next()) { 322 file_util::WriteFile(path, " ", 1); 323 } 324 CreateDatabase(); 325 326 // Make sure that the resulting database is usable. 327 scoped_ptr<Contact> contact(new Contact); 328 InitContact("1", "1", false, contact.get()); 329 scoped_ptr<ContactPointers> contacts_to_save(new ContactPointers); 330 contacts_to_save->push_back(contact.get()); 331 scoped_ptr<ContactDatabaseInterface::ContactIds> contact_ids_to_delete( 332 new ContactDatabaseInterface::ContactIds); 333 scoped_ptr<UpdateMetadata> metadata_to_save(new UpdateMetadata); 334 SaveContacts(contacts_to_save.Pass(), 335 contact_ids_to_delete.Pass(), 336 metadata_to_save.Pass(), 337 true); 338 339 scoped_ptr<ScopedVector<Contact> > loaded_contacts; 340 scoped_ptr<UpdateMetadata> loaded_metadata; 341 LoadContacts(&loaded_contacts, &loaded_metadata); 342 EXPECT_EQ(VarContactsToString(1, contact.get()), 343 ContactsToString(*loaded_contacts)); 344 } 345 346 TEST_F(ContactDatabaseTest, DeleteRequestedContacts) { 347 // Insert two contacts into the database with a full update. 348 const std::string kContactId1 = "contact_id_1"; 349 scoped_ptr<Contact> contact1(new Contact); 350 InitContact(kContactId1, "1", false, contact1.get()); 351 const std::string kContactId2 = "contact_id_2"; 352 scoped_ptr<Contact> contact2(new Contact); 353 InitContact(kContactId2, "2", false, contact2.get()); 354 355 scoped_ptr<ContactPointers> contacts_to_save(new ContactPointers); 356 contacts_to_save->push_back(contact1.get()); 357 contacts_to_save->push_back(contact2.get()); 358 scoped_ptr<ContactDatabaseInterface::ContactIds> contact_ids_to_delete( 359 new ContactDatabaseInterface::ContactIds); 360 scoped_ptr<UpdateMetadata> metadata_to_save(new UpdateMetadata); 361 SaveContacts(contacts_to_save.Pass(), 362 contact_ids_to_delete.Pass(), 363 metadata_to_save.Pass(), 364 true); 365 366 // Do an incremental update that inserts a third contact and deletes the first 367 // contact. 368 const std::string kContactId3 = "contact_id_3"; 369 scoped_ptr<Contact> contact3(new Contact); 370 InitContact(kContactId3, "3", false, contact3.get()); 371 372 contacts_to_save.reset(new ContactPointers); 373 contacts_to_save->push_back(contact3.get()); 374 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 375 contact_ids_to_delete->push_back(kContactId1); 376 metadata_to_save.reset(new UpdateMetadata); 377 SaveContacts(contacts_to_save.Pass(), 378 contact_ids_to_delete.Pass(), 379 metadata_to_save.Pass(), 380 false); 381 382 // LoadContacts() should return only the second and third contacts. 383 scoped_ptr<ScopedVector<Contact> > loaded_contacts; 384 scoped_ptr<UpdateMetadata> loaded_metadata; 385 LoadContacts(&loaded_contacts, &loaded_metadata); 386 EXPECT_EQ(VarContactsToString(2, contact2.get(), contact3.get()), 387 ContactsToString(*loaded_contacts)); 388 389 // Do another incremental update that deletes the second contact. 390 contacts_to_save.reset(new ContactPointers); 391 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 392 contact_ids_to_delete->push_back(kContactId2); 393 metadata_to_save.reset(new UpdateMetadata); 394 SaveContacts(contacts_to_save.Pass(), 395 contact_ids_to_delete.Pass(), 396 metadata_to_save.Pass(), 397 false); 398 LoadContacts(&loaded_contacts, &loaded_metadata); 399 EXPECT_EQ(VarContactsToString(1, contact3.get()), 400 ContactsToString(*loaded_contacts)); 401 402 // Deleting a contact that isn't present should be a no-op. 403 contacts_to_save.reset(new ContactPointers); 404 contact_ids_to_delete.reset(new ContactDatabaseInterface::ContactIds); 405 contact_ids_to_delete->push_back("bogus_id"); 406 metadata_to_save.reset(new UpdateMetadata); 407 SaveContacts(contacts_to_save.Pass(), 408 contact_ids_to_delete.Pass(), 409 metadata_to_save.Pass(), 410 false); 411 LoadContacts(&loaded_contacts, &loaded_metadata); 412 EXPECT_EQ(VarContactsToString(1, contact3.get()), 413 ContactsToString(*loaded_contacts)); 414 } 415 416 } // namespace test 417 } // namespace contacts 418
