New authorization framework for sync. ...

chrome/browser/sync/profile_sync_service_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stack>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/model_associator.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/sync_backend_host_mock.h"
 #include "chrome/browser/sync/notification_method.h"
 #include "chrome/browser/sync/profile_sync_factory.h"
 #include "chrome/browser/sync/profile_sync_factory_mock.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_profile.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using std::vector;
 using browser_sync::AssociatorInterface;
 using browser_sync::BookmarkChangeProcessor;
 using browser_sync::BookmarkModelAssociator;
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
@@ skipping 194 matching lines @@
 
   BookmarkChangeProcessor* change_processor() {
     return change_processor_;
   }
 
   void StartSyncService() {
     StartSyncServiceAndSetInitialSyncEnded(true);
   }
   void StartSyncServiceAndSetInitialSyncEnded(bool set_initial_sync_ended) {
     if (!service_.get()) {
+      // Set bootstrap to true and it will provide a logged in user for test
       service_.reset(new TestProfileSyncService(&factory_,
                                                 profile_.get(),
-                                                false, false, NULL));
+                                                "test", false, NULL));
       if (!set_initial_sync_ended)
         service_->dont_set_initial_sync_ended_on_init();
 
       // Register the bookmark data type.
       model_associator_ = new TestBookmarkModelAssociator(service_.get(),
                                                           service_.get());
       change_processor_ = new BookmarkChangeProcessor(model_associator_,
                                                       service_.get());
       EXPECT_CALL(factory_, CreateBookmarkSyncComponents(_, _)).
           WillOnce(Return(ProfileSyncFactory::SyncComponents(
               model_associator_, change_processor_)));
       EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
           WillOnce(ReturnNewDataTypeManager());
 
       service_->RegisterDataTypeController(
           new browser_sync::BookmarkDataTypeController(&factory_,
                                                        profile_.get(),
                                                        service_.get()));
+
+      profile_->GetTokenService()->IssueAuthTokenForTest(
+          GaiaConstants::kSyncService, "token");
       service_->Initialize();
       MessageLoop::current()->Run();
     }
   }
 
   void StopSyncService(SaveOption save) {
     if (save == DONT_SAVE_TO_STORAGE)
       service_->DisableForUser();
     service_.reset();
   }
@@ skipping 180 matching lines @@
         ProfileSyncService::kDevServerUrl);
 
   EXPECT_TRUE(other_bookmarks_id());
   EXPECT_TRUE(bookmark_bar_id());
 
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) {
   service_.reset(new TestProfileSyncService(&factory_, profile_.get(),
-                                            false, true, NULL));
+                                            "test", true, NULL));
   service_->set_num_expected_resumes(0);
-  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
-      WillOnce(ReturnNewDataTypeManager());
+  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
   EXPECT_CALL(factory_, CreateBookmarkSyncComponents(_, _)).Times(0);
   service_->RegisterDataTypeController(
       new browser_sync::BookmarkDataTypeController(&factory_,
                                                    profile_.get(),
                                                    service_.get()));
+
   service_->Initialize();
   service_.reset();
 }
 
 TEST_F(ProfileSyncServiceTest, BookmarkModelOperations) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSyncService();
 
   // Test addition.
   const BookmarkNode* folder =
@@ skipping 853 matching lines @@
   FilePath sync_file3 = temp_directory.AppendASCII("nonsense_file");
   file_util::CreateDirectory(temp_directory);
   file_util::WriteFile(sync_file1, nonsense1, strlen(nonsense1));
   file_util::WriteFile(sync_file2, nonsense2, strlen(nonsense2));
   file_util::WriteFile(sync_file3, nonsense3, strlen(nonsense3));
 
   LoadBookmarkModel(LOAD_FROM_STORAGE, SAVE_TO_STORAGE);
   if (!service_.get()) {
     service_.reset(
         new TestProfileSyncService(&factory_, profile_.get(),
-                                   false, true, NULL));
-
+                                   "test", true, NULL));
     service_->dont_set_initial_sync_ended_on_init();
+    service_->set_synchronous_sync_configuration();
     profile_->GetPrefs()->SetBoolean(prefs::kSyncHasSetupCompleted, false);
 
     model_associator_ = new TestBookmarkModelAssociator(service_.get(),
                                                         service_.get());
     change_processor_ = new BookmarkChangeProcessor(model_associator_,
                                                     service_.get());
     EXPECT_CALL(factory_, CreateBookmarkSyncComponents(_, _)).
         WillOnce(Return(ProfileSyncFactory::SyncComponents(
             model_associator_, change_processor_)));
     EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
         WillOnce(ReturnNewDataTypeManager());
 
     service_->RegisterDataTypeController(
         new browser_sync::BookmarkDataTypeController(&factory_,
                                                      profile_.get(),
                                                      service_.get()));
 
     service_->Initialize(); // will call disableForUser because sync setup
                             // hasn't been completed.
   }
 
   ASSERT_FALSE(service_->backend());
   ASSERT_FALSE(service_->HasSyncSetupCompleted());
 
-  // This will actually start up the sync service.
-  service_->EnableForUser(NULL);
+  // Create some tokens in the token service; the service will startup when
+  // it is notified that tokens are available.
+  profile_->GetTokenService()->IssueAuthTokenForTest(
+      GaiaConstants::kSyncService, "sync_token");
+
   syncable::ModelTypeSet set;
   set.insert(syncable::BOOKMARKS);
   service_->OnUserChoseDatatypes(false, set);
 
-  MessageLoop::current()->Run();
+  MessageLoop::current()->RunAllPending();
 
   // Stop the service so we can read the new Sync Data files that were created.
   service_.reset();
 
   // This file should have been deleted when the whole directory was nuked.
   ASSERT_FALSE(file_util::PathExists(sync_file3));
+  ASSERT_FALSE(file_util::PathExists(sync_file1));
 
-  // These two will still exist, but their texts should have changed.
-  ASSERT_TRUE(file_util::PathExists(sync_file1));
-  std::string file1text;
-  file_util::ReadFileToString(sync_file1, &file1text);
-  ASSERT_FALSE(file1text.compare(nonsense1) == 0);
-
+  // This will still exist, but the text should have changed.
   ASSERT_TRUE(file_util::PathExists(sync_file2));
   std::string file2text;
   file_util::ReadFileToString(sync_file2, &file2text);
   ASSERT_FALSE(file2text.compare(nonsense2) == 0);
 }