Reland 203015 "Add ManagedUserTokenFetcher to fetch scoped-down ..."

chrome/browser/managed_mode/managed_user_registration_service_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/bind.h"
+#include "base/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h"
 #include "chrome/browser/managed_mode/managed_user_registration_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using ::sync_pb::ManagedUserSpecifics;
+using sync_pb::ManagedUserSpecifics;
 using syncer::MANAGED_USERS;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 using syncer::SyncChangeProcessor;
 using syncer::SyncData;
 using syncer::SyncDataList;
 using syncer::SyncError;
 using syncer::SyncErrorFactory;
 using syncer::SyncMergeResult;
 
 namespace {
 
+const char kManagedUserToken[] = "managedusertoken";
+
 class MockChangeProcessor : public SyncChangeProcessor {
  public:
   MockChangeProcessor() {}
   virtual ~MockChangeProcessor() {}
 
   // SyncChangeProcessor implementation:
   virtual SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const SyncChangeList& change_list) OVERRIDE;
 
@@ skipping 13 matching lines @@
 
 SyncChange MockChangeProcessor::GetChange(const std::string& id) const {
   for (SyncChangeList::const_iterator it = change_list_.begin();
        it != change_list_.end(); ++it) {
     if (it->sync_data().GetSpecifics().managed_user().id() == id)
       return *it;
   }
   return SyncChange();
 }
 
+class MockManagedUserRefreshTokenFetcher
+    : public ManagedUserRefreshTokenFetcher {
+ public:
+  MockManagedUserRefreshTokenFetcher() {}
+  virtual ~MockManagedUserRefreshTokenFetcher() {}
+
+  // ManagedUserRefreshTokenFetcher implementation:
+  virtual void Start(const std::string& managed_user_id,
+                     const string16& name,
+                     const std::string& device_name,
+                     const TokenCallback& callback) OVERRIDE {
+    GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
+    callback.Run(error, kManagedUserToken);
+  }
+};
+
 }  // namespace
 
 class ManagedUserRegistrationServiceTest : public ::testing::Test {
  public:
   ManagedUserRegistrationServiceTest();
   virtual ~ManagedUserRegistrationServiceTest();
 
+  virtual void TearDown() OVERRIDE;
+
  protected:
   scoped_ptr<SyncChangeProcessor> CreateChangeProcessor();
   scoped_ptr<SyncErrorFactory> CreateErrorFactory();
   SyncData CreateRemoteData(const std::string& id, const std::string& name);
 
   SyncMergeResult StartInitialSync();
 
   ManagedUserRegistrationService::RegistrationCallback
       GetRegistrationCallback();
 
   void Acknowledge();
   void ResetService();
 
   PrefService* prefs() { return &prefs_; }
   ManagedUserRegistrationService* service() { return service_.get(); }
   MockChangeProcessor* change_processor() { return change_processor_; }
 
   bool received_callback() const { return received_callback_; }
   const GoogleServiceAuthError& error() const { return error_; }
   const std::string& token() const { return token_; }
 
  private:
   void OnManagedUserRegistered(const GoogleServiceAuthError& error,
                                const std::string& token);
 
+  base::MessageLoop message_loop_;
+  base::RunLoop run_loop_;
   base::WeakPtrFactory<ManagedUserRegistrationServiceTest> weak_ptr_factory_;
   TestingPrefServiceSyncable prefs_;
   scoped_ptr<ManagedUserRegistrationService> service_;
 
   // Owned by the ManagedUserRegistrationService.
   MockChangeProcessor* change_processor_;
 
   // A unique ID for creating "remote" Sync data.
   int64 sync_data_id_;
 
   // Whether OnManagedUserRegistered has been called.
   bool received_callback_;
 
   // Hold the registration result (either an error, or a token).
   GoogleServiceAuthError error_;
   std::string token_;
 };
 
 ManagedUserRegistrationServiceTest::ManagedUserRegistrationServiceTest()
     : weak_ptr_factory_(this),
-      service_(new ManagedUserRegistrationService(&prefs_)),
       change_processor_(NULL),
       sync_data_id_(0),
       received_callback_(false),
       error_(GoogleServiceAuthError::NUM_STATES) {
   ManagedUserRegistrationService::RegisterUserPrefs(prefs_.registry());
+  scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher(
+      new MockManagedUserRefreshTokenFetcher);
+  service_.reset(
+      new ManagedUserRegistrationService(&prefs_, token_fetcher.Pass()));
 }
 
 ManagedUserRegistrationServiceTest::~ManagedUserRegistrationServiceTest() {
   EXPECT_FALSE(weak_ptr_factory_.HasWeakPtrs());
 }
 
+void ManagedUserRegistrationServiceTest::TearDown() {
+  base::RunLoop().RunUntilIdle();
+}
+
 scoped_ptr<SyncChangeProcessor>
 ManagedUserRegistrationServiceTest::CreateChangeProcessor() {
   EXPECT_FALSE(change_processor_);
   change_processor_ = new MockChangeProcessor();
   return scoped_ptr<SyncChangeProcessor>(change_processor_);
 }
 
 scoped_ptr<SyncErrorFactory>
 ManagedUserRegistrationServiceTest::CreateErrorFactory() {
   return scoped_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock());
@@ skipping 34 matching lines @@
        ++it) {
     EXPECT_EQ(SyncChange::ACTION_ADD, it->change_type());
     ::sync_pb::EntitySpecifics specifics = it->sync_data().GetSpecifics();
     EXPECT_FALSE(specifics.managed_user().acknowledged());
     specifics.mutable_managed_user()->set_acknowledged(true);
     new_changes.push_back(
         SyncChange(FROM_HERE, SyncChange::ACTION_UPDATE,
                    SyncData::CreateRemoteData(++sync_data_id_, specifics)));
   }
   service()->ProcessSyncChanges(FROM_HERE, new_changes);
+
+  run_loop_.Run();
 }
 
 void ManagedUserRegistrationServiceTest::ResetService() {
   service_->StopSyncing(MANAGED_USERS);
   service_->Shutdown();
   service_.reset();
 }
 
 void ManagedUserRegistrationServiceTest::OnManagedUserRegistered(
     const GoogleServiceAuthError& error,
     const std::string& token) {
   received_callback_ = true;
   error_ = error;
   token_ = token;
+  run_loop_.Quit();
 }
 
 TEST_F(ManagedUserRegistrationServiceTest, MergeEmpty) {
   SyncMergeResult result = StartInitialSync();
   EXPECT_EQ(0, result.num_items_added());
   EXPECT_EQ(0, result.num_items_modified());
   EXPECT_EQ(0, result.num_items_deleted());
   EXPECT_EQ(0, result.num_items_before_association());
   EXPECT_EQ(0, result.num_items_after_association());
   EXPECT_EQ(0u, prefs()->GetDictionary(prefs::kManagedUsers)->size());
@@ skipping 120 matching lines @@
 }
 
 TEST_F(ManagedUserRegistrationServiceTest, StopSyncing) {
   StartInitialSync();
   service()->Register(ASCIIToUTF16("Mike"), GetRegistrationCallback());
   service()->StopSyncing(MANAGED_USERS);
   EXPECT_TRUE(received_callback());
   EXPECT_EQ(GoogleServiceAuthError::REQUEST_CANCELED, error().state());
   EXPECT_EQ(std::string(), token());
 }