components/signin/core/browser/gaia_cookie_manager_service_unittest.cc

   1 // Copyright 2014 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 <algorithm>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/location.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/prefs/pref_registry_simple.h"
  14 #include "base/prefs/testing_pref_service.h"
  15 #include "base/single_thread_task_runner.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/test/histogram_tester.h"
  18 #include "base/thread_task_runner_handle.h"
  19 #include "components/signin/core/browser/gaia_cookie_manager_service.h"
  20 #include "components/signin/core/browser/test_signin_client.h"
  21 #include "components/signin/core/common/signin_pref_names.h"
  22 #include "google_apis/gaia/fake_oauth2_token_service.h"
  23 #include "google_apis/gaia/gaia_constants.h"
  24 #include "google_apis/gaia/gaia_urls.h"
  25 #include "net/url_request/test_url_fetcher_factory.h"
  26 #include "net/url_request/url_request_test_util.h"
  27 #include "testing/gmock/include/gmock/gmock.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29
  30 namespace {
  31
  32 class MockObserver : public GaiaCookieManagerService::Observer {
  33  public:
  34   explicit MockObserver(GaiaCookieManagerService* helper) : helper_(helper) {
  35     helper_->AddObserver(this);
  36   }
  37
  38   ~MockObserver() { helper_->RemoveObserver(this); }
  39
  40   MOCK_METHOD2(OnAddAccountToCookieCompleted,
  41                void(const std::string&, const GoogleServiceAuthError&));
  42   MOCK_METHOD2(OnGaiaAccountsInCookieUpdated,
  43                void(const std::vector<gaia::ListedAccount>&,
  44                     const GoogleServiceAuthError&));
  45  private:
  46   GaiaCookieManagerService* helper_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(MockObserver);
  49 };
  50
  51 // Counts number of InstrumentedGaiaCookieManagerService created.
  52 // We can EXPECT_* to be zero at the end of our unit tests
  53 // to make sure everything is properly deleted.
  54
  55 int total = 0;
  56
  57 class InstrumentedGaiaCookieManagerService : public GaiaCookieManagerService {
  58  public:
  59   InstrumentedGaiaCookieManagerService(
  60       OAuth2TokenService* token_service,
  61       SigninClient* signin_client)
  62       : GaiaCookieManagerService(token_service,
  63                                  GaiaConstants::kChromeSource,
  64                                  signin_client) {
  65     total++;
  66   }
  67
  68   virtual ~InstrumentedGaiaCookieManagerService() { total--; }
  69
  70   MOCK_METHOD0(StartFetchingUbertoken, void());
  71   MOCK_METHOD0(StartFetchingListAccounts, void());
  72   MOCK_METHOD0(StartFetchingLogOut, void());
  73   MOCK_METHOD0(StartFetchingMergeSession, void());
  74
  75  private:
  76   DISALLOW_COPY_AND_ASSIGN(InstrumentedGaiaCookieManagerService);
  77 };
  78
  79 class GaiaCookieManagerServiceTest : public testing::Test {
  80  public:
  81   GaiaCookieManagerServiceTest()
  82       : no_error_(GoogleServiceAuthError::NONE),
  83         error_(GoogleServiceAuthError::SERVICE_ERROR),
  84         canceled_(GoogleServiceAuthError::REQUEST_CANCELED) {}
  85
  86   void SetUp() override {
  87     pref_service_.registry()->RegisterIntegerPref(
  88         prefs::kAccountIdMigrationState,
  89         AccountTrackerService::MIGRATION_NOT_STARTED);
  90     signin_client_.reset(new TestSigninClient(&pref_service_));
  91   }
  92
  93   OAuth2TokenService* token_service() { return &token_service_; }
  94   TestSigninClient* signin_client() { return signin_client_.get(); }
  95
  96   void SimulateUbertokenSuccess(UbertokenConsumer* consumer,
  97                                 const std::string& uber_token) {
  98     consumer->OnUbertokenSuccess(uber_token);
  99   }
 100
 101   void SimulateUbertokenFailure(UbertokenConsumer* consumer,
 102                                 const GoogleServiceAuthError& error) {
 103     consumer->OnUbertokenFailure(error);
 104   }
 105
 106   void SimulateMergeSessionSuccess(GaiaAuthConsumer* consumer,
 107                                    const std::string& data) {
 108     consumer->OnMergeSessionSuccess(data);
 109   }
 110
 111   void SimulateMergeSessionFailure(GaiaAuthConsumer* consumer,
 112                                    const GoogleServiceAuthError& error) {
 113     consumer->OnMergeSessionFailure(error);
 114   }
 115
 116   void SimulateListAccountsSuccess(GaiaAuthConsumer* consumer,
 117                                    const std::string& data) {
 118     consumer->OnListAccountsSuccess(data);
 119   }
 120
 121   void SimulateLogOutSuccess(GaiaAuthConsumer* consumer) {
 122     consumer->OnLogOutSuccess();
 123   }
 124
 125   void SimulateLogOutFailure(GaiaAuthConsumer* consumer,
 126                              const GoogleServiceAuthError& error) {
 127     consumer->OnLogOutFailure(error);
 128   }
 129
 130   void SimulateGetCheckConnctionInfoSuccess(net::TestURLFetcher* fetcher,
 131                                             const std::string& data) {
 132     fetcher->set_status(net::URLRequestStatus());
 133     fetcher->set_response_code(200);
 134     fetcher->SetResponseString(data);
 135     fetcher->delegate()->OnURLFetchComplete(fetcher);
 136   }
 137
 138   void SimulateGetCheckConnctionInfoResult(net::URLFetcher* fetcher,
 139                                            const std::string& result) {
 140     net::TestURLFetcher* test_fetcher =
 141         static_cast<net::TestURLFetcher*>(fetcher);
 142     test_fetcher->set_status(net::URLRequestStatus());
 143     test_fetcher->set_response_code(200);
 144     test_fetcher->SetResponseString(result);
 145     test_fetcher->delegate()->OnURLFetchComplete(fetcher);
 146   }
 147
 148   const GoogleServiceAuthError& no_error() { return no_error_; }
 149   const GoogleServiceAuthError& error() { return error_; }
 150   const GoogleServiceAuthError& canceled() { return canceled_; }
 151
 152   net::TestURLFetcherFactory* factory() { return &factory_; }
 153
 154  private:
 155   base::MessageLoop message_loop_;
 156   net::TestURLFetcherFactory factory_;
 157   FakeOAuth2TokenService token_service_;
 158   GoogleServiceAuthError no_error_;
 159   GoogleServiceAuthError error_;
 160   GoogleServiceAuthError canceled_;
 161   TestingPrefServiceSimple pref_service_;
 162   scoped_ptr<TestSigninClient> signin_client_;
 163 };
 164
 165 }  // namespace
 166
 167 using ::testing::_;
 168
 169 TEST_F(GaiaCookieManagerServiceTest, Success) {
 170   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 171   MockObserver observer(&helper);
 172
 173   EXPECT_CALL(helper, StartFetchingUbertoken());
 174   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 175                                                       no_error()));
 176
 177   helper.AddAccountToCookie("acc1@gmail.com");
 178   SimulateMergeSessionSuccess(&helper, "token");
 179 }
 180
 181 TEST_F(GaiaCookieManagerServiceTest, FailedMergeSession) {
 182   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 183   MockObserver observer(&helper);
 184   base::HistogramTester histograms;
 185
 186   EXPECT_CALL(helper, StartFetchingUbertoken());
 187   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 188                                                       error()));
 189
 190   helper.AddAccountToCookie("acc1@gmail.com");
 191   SimulateMergeSessionFailure(&helper, error());
 192   // Persistent error incurs no further retries.
 193   DCHECK(!helper.is_running());
 194   histograms.ExpectUniqueSample("OAuth2Login.MergeSessionFailure",
 195       GoogleServiceAuthError::SERVICE_ERROR, 1);
 196 }
 197
 198 TEST_F(GaiaCookieManagerServiceTest, AddAccountCookiesDisabled) {
 199   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 200   MockObserver observer(&helper);
 201   signin_client()->set_are_signin_cookies_allowed(false);
 202
 203   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 204                                                       canceled()));
 205
 206   helper.AddAccountToCookie("acc1@gmail.com");
 207 }
 208
 209 TEST_F(GaiaCookieManagerServiceTest, MergeSessionRetried) {
 210   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 211   MockObserver observer(&helper);
 212
 213   EXPECT_CALL(helper, StartFetchingUbertoken());
 214   EXPECT_CALL(helper, StartFetchingMergeSession());
 215   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 216                                                       no_error()));
 217
 218   helper.AddAccountToCookie("acc1@gmail.com");
 219   SimulateMergeSessionFailure(&helper, canceled());
 220   DCHECK(helper.is_running());
 221   // Transient error incurs a retry after 1 second.
 222   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 223       FROM_HERE, base::MessageLoop::QuitClosure(),
 224       base::TimeDelta::FromMilliseconds(1100));
 225   base::MessageLoop::current()->Run();
 226   SimulateMergeSessionSuccess(&helper, "token");
 227   DCHECK(!helper.is_running());
 228 }
 229
 230 TEST_F(GaiaCookieManagerServiceTest, MergeSessionRetriedTwice) {
 231   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 232   MockObserver observer(&helper);
 233   base::HistogramTester histograms;
 234
 235   EXPECT_CALL(helper, StartFetchingUbertoken());
 236   EXPECT_CALL(helper, StartFetchingMergeSession()).Times(2);
 237   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 238                                                       no_error()));
 239
 240   helper.AddAccountToCookie("acc1@gmail.com");
 241   SimulateMergeSessionFailure(&helper, canceled());
 242   DCHECK(helper.is_running());
 243   // Transient error incurs a retry after 1 second.
 244   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 245       FROM_HERE, base::MessageLoop::QuitClosure(),
 246       base::TimeDelta::FromMilliseconds(1100));
 247   base::MessageLoop::current()->Run();
 248   SimulateMergeSessionFailure(&helper, canceled());
 249   DCHECK(helper.is_running());
 250   // Next transient error incurs a retry after 3 seconds.
 251   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 252       FROM_HERE, base::MessageLoop::QuitClosure(),
 253       base::TimeDelta::FromMilliseconds(3100));
 254   base::MessageLoop::current()->Run();
 255   SimulateMergeSessionSuccess(&helper, "token");
 256   DCHECK(!helper.is_running());
 257   histograms.ExpectUniqueSample("OAuth2Login.MergeSessionRetry",
 258       GoogleServiceAuthError::REQUEST_CANCELED, 2);
 259 }
 260
 261 TEST_F(GaiaCookieManagerServiceTest, FailedUbertoken) {
 262   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 263   MockObserver observer(&helper);
 264
 265   EXPECT_CALL(helper, StartFetchingUbertoken());
 266   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 267                                                       error()));
 268
 269   helper.AddAccountToCookie("acc1@gmail.com");
 270   SimulateUbertokenFailure(&helper, error());
 271 }
 272
 273 TEST_F(GaiaCookieManagerServiceTest, ContinueAfterSuccess) {
 274   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 275   MockObserver observer(&helper);
 276
 277   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 278   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 279                                                       no_error()));
 280   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 281                                                       no_error()));
 282
 283   helper.AddAccountToCookie("acc1@gmail.com");
 284   helper.AddAccountToCookie("acc2@gmail.com");
 285   SimulateMergeSessionSuccess(&helper, "token1");
 286   SimulateMergeSessionSuccess(&helper, "token2");
 287 }
 288
 289 TEST_F(GaiaCookieManagerServiceTest, ContinueAfterFailure1) {
 290   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 291   MockObserver observer(&helper);
 292
 293   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 294   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 295                                                       error()));
 296   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 297                                                       no_error()));
 298
 299   helper.AddAccountToCookie("acc1@gmail.com");
 300   helper.AddAccountToCookie("acc2@gmail.com");
 301   SimulateMergeSessionFailure(&helper, error());
 302   SimulateMergeSessionSuccess(&helper, "token2");
 303 }
 304
 305 TEST_F(GaiaCookieManagerServiceTest, ContinueAfterFailure2) {
 306   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 307   MockObserver observer(&helper);
 308
 309   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 310   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 311                                                       error()));
 312   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 313                                                       no_error()));
 314
 315   helper.AddAccountToCookie("acc1@gmail.com");
 316   helper.AddAccountToCookie("acc2@gmail.com");
 317   SimulateUbertokenFailure(&helper, error());
 318   SimulateMergeSessionSuccess(&helper, "token2");
 319 }
 320
 321 TEST_F(GaiaCookieManagerServiceTest, AllRequestsInMultipleGoes) {
 322   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 323   MockObserver observer(&helper);
 324
 325   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(4);
 326   EXPECT_CALL(observer, OnAddAccountToCookieCompleted(_, no_error())).Times(4);
 327
 328   helper.AddAccountToCookie("acc1@gmail.com");
 329   helper.AddAccountToCookie("acc2@gmail.com");
 330
 331   SimulateMergeSessionSuccess(&helper, "token1");
 332
 333   helper.AddAccountToCookie("acc3@gmail.com");
 334
 335   SimulateMergeSessionSuccess(&helper, "token2");
 336   SimulateMergeSessionSuccess(&helper, "token3");
 337
 338   helper.AddAccountToCookie("acc4@gmail.com");
 339
 340   SimulateMergeSessionSuccess(&helper, "token4");
 341 }
 342
 343 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsNoQueue) {
 344   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 345   MockObserver observer(&helper);
 346
 347   EXPECT_CALL(helper, StartFetchingUbertoken());
 348   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 349                                                       no_error()));
 350   EXPECT_CALL(helper, StartFetchingLogOut());
 351
 352   helper.AddAccountToCookie("acc2@gmail.com");
 353   SimulateMergeSessionSuccess(&helper, "token1");
 354
 355   helper.LogOutAllAccounts();
 356   SimulateLogOutSuccess(&helper);
 357   ASSERT_FALSE(helper.is_running());
 358 }
 359
 360 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsFails) {
 361   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 362   MockObserver observer(&helper);
 363
 364   EXPECT_CALL(helper, StartFetchingUbertoken());
 365   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 366                                                       no_error()));
 367   EXPECT_CALL(helper, StartFetchingLogOut());
 368
 369   helper.AddAccountToCookie("acc2@gmail.com");
 370   SimulateMergeSessionSuccess(&helper, "token1");
 371
 372   helper.LogOutAllAccounts();
 373   SimulateLogOutFailure(&helper, error());
 374   // CookieManagerService is still running; it is retrying the failed logout.
 375   ASSERT_TRUE(helper.is_running());
 376 }
 377
 378 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsAfterOneAddInQueue) {
 379   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 380   MockObserver observer(&helper);
 381
 382   EXPECT_CALL(helper, StartFetchingUbertoken());
 383   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 384                                                       no_error()));
 385   EXPECT_CALL(helper, StartFetchingLogOut());
 386
 387   helper.AddAccountToCookie("acc2@gmail.com");
 388   helper.LogOutAllAccounts();
 389
 390   SimulateMergeSessionSuccess(&helper, "token1");
 391   SimulateLogOutSuccess(&helper);
 392 }
 393
 394 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsAfterTwoAddsInQueue) {
 395   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 396   MockObserver observer(&helper);
 397
 398   EXPECT_CALL(helper, StartFetchingUbertoken());
 399   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 400                                                       no_error()));
 401   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 402                                                       canceled()));
 403   EXPECT_CALL(helper, StartFetchingLogOut());
 404
 405   helper.AddAccountToCookie("acc1@gmail.com");
 406   // The Log Out should prevent this AddAccount from being fetched.
 407   helper.AddAccountToCookie("acc2@gmail.com");
 408   helper.LogOutAllAccounts();
 409
 410   SimulateMergeSessionSuccess(&helper, "token1");
 411   SimulateLogOutSuccess(&helper);
 412 }
 413
 414 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsTwice) {
 415   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 416   MockObserver observer(&helper);
 417
 418   EXPECT_CALL(helper, StartFetchingUbertoken());
 419   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 420                                                       no_error()));
 421   EXPECT_CALL(helper, StartFetchingLogOut());
 422
 423   helper.AddAccountToCookie("acc2@gmail.com");
 424   SimulateMergeSessionSuccess(&helper, "token1");
 425
 426   helper.LogOutAllAccounts();
 427   // Only one LogOut will be fetched.
 428   helper.LogOutAllAccounts();
 429   SimulateLogOutSuccess(&helper);
 430 }
 431
 432 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsBeforeAdd) {
 433   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 434   MockObserver observer(&helper);
 435
 436   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 437   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 438                                                       no_error()));
 439   EXPECT_CALL(helper, StartFetchingLogOut());
 440   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc3@gmail.com",
 441                                                       no_error()));
 442   helper.AddAccountToCookie("acc2@gmail.com");
 443   SimulateMergeSessionSuccess(&helper, "token1");
 444
 445   helper.LogOutAllAccounts();
 446   helper.AddAccountToCookie("acc3@gmail.com");
 447
 448   SimulateLogOutSuccess(&helper);
 449   // After LogOut the MergeSession should be fetched.
 450   SimulateMergeSessionSuccess(&helper, "token2");
 451 }
 452
 453 TEST_F(GaiaCookieManagerServiceTest, LogOutAllAccountsBeforeLogoutAndAdd) {
 454   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 455   MockObserver observer(&helper);
 456
 457
 458   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 459   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 460                                                       no_error()));
 461   EXPECT_CALL(helper, StartFetchingLogOut());
 462   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc3@gmail.com",
 463                                                       no_error()));
 464
 465   helper.AddAccountToCookie("acc2@gmail.com");
 466   SimulateMergeSessionSuccess(&helper, "token1");
 467
 468   helper.LogOutAllAccounts();
 469   // Second LogOut will never be fetched.
 470   helper.LogOutAllAccounts();
 471   helper.AddAccountToCookie("acc3@gmail.com");
 472
 473   SimulateLogOutSuccess(&helper);
 474   // After LogOut the MergeSession should be fetched.
 475   SimulateMergeSessionSuccess(&helper, "token2");
 476 }
 477
 478 TEST_F(GaiaCookieManagerServiceTest, PendingSigninThenSignout) {
 479   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 480   MockObserver observer(&helper);
 481
 482   // From the first Signin.
 483   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 484                                                       no_error()));
 485
 486   // From the sign out and then re-sign in.
 487   EXPECT_CALL(helper, StartFetchingLogOut());
 488   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc3@gmail.com",
 489                                                       no_error()));
 490
 491   // Total sign in 2 times, not enforcing ordered sequences.
 492   EXPECT_CALL(helper, StartFetchingUbertoken()).Times(2);
 493
 494   helper.AddAccountToCookie("acc1@gmail.com");
 495   helper.LogOutAllAccounts();
 496
 497   SimulateMergeSessionSuccess(&helper, "token1");
 498   SimulateLogOutSuccess(&helper);
 499
 500   helper.AddAccountToCookie("acc3@gmail.com");
 501   SimulateMergeSessionSuccess(&helper, "token3");
 502 }
 503
 504 TEST_F(GaiaCookieManagerServiceTest, CancelSignIn) {
 505   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 506   MockObserver observer(&helper);
 507
 508   EXPECT_CALL(helper, StartFetchingUbertoken());
 509   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc2@gmail.com",
 510                                                       canceled()));
 511   EXPECT_CALL(observer, OnAddAccountToCookieCompleted("acc1@gmail.com",
 512                                                       no_error()));
 513   EXPECT_CALL(helper, StartFetchingLogOut());
 514
 515   helper.AddAccountToCookie("acc1@gmail.com");
 516   helper.AddAccountToCookie("acc2@gmail.com");
 517   helper.LogOutAllAccounts();
 518
 519   SimulateMergeSessionSuccess(&helper, "token1");
 520   SimulateLogOutSuccess(&helper);
 521 }
 522
 523 TEST_F(GaiaCookieManagerServiceTest, ListAccountsFirstReturnsEmpty) {
 524   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 525   MockObserver observer(&helper);
 526
 527   std::vector<gaia::ListedAccount> list_accounts;
 528
 529   EXPECT_CALL(helper, StartFetchingListAccounts());
 530
 531   ASSERT_FALSE(helper.ListAccounts(&list_accounts));
 532   ASSERT_TRUE(list_accounts.empty());
 533 }
 534
 535 TEST_F(GaiaCookieManagerServiceTest, ListAccountsFindsOneAccount) {
 536   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 537   MockObserver observer(&helper);
 538
 539   std::vector<gaia::ListedAccount> list_accounts;
 540   std::vector<gaia::ListedAccount> expected_accounts;
 541   gaia::ListedAccount listed_account;
 542   listed_account.email = "a@b.com";
 543   listed_account.raw_email = "a@b.com";
 544   listed_account.gaia_id = "8";
 545   listed_account.valid = true;
 546   expected_accounts.push_back(listed_account);
 547
 548   EXPECT_CALL(helper, StartFetchingListAccounts());
 549   EXPECT_CALL(observer, OnGaiaAccountsInCookieUpdated(expected_accounts,
 550                                                       no_error()));
 551
 552   ASSERT_FALSE(helper.ListAccounts(&list_accounts));
 553
 554   SimulateListAccountsSuccess(&helper,
 555       "[\"f\", [[\"b\", 0, \"n\", \"a@b.com\", \"p\", 0, 0, 0, 0, 1, \"8\"]]]");
 556 }
 557
 558 TEST_F(GaiaCookieManagerServiceTest, ExternalCcResultFetcher) {
 559   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 560   GaiaCookieManagerService::ExternalCcResultFetcher result_fetcher(&helper);
 561   EXPECT_CALL(helper, StartFetchingMergeSession());
 562   result_fetcher.Start();
 563
 564   // Simulate a successful completion of GetCheckConnctionInfo.
 565   net::TestURLFetcher* fetcher = factory()->GetFetcherByID(0);
 566   ASSERT_TRUE(NULL != fetcher);
 567   SimulateGetCheckConnctionInfoSuccess(
 568       fetcher,
 569       "[{\"carryBackToken\": \"yt\", \"url\": \"http://www.yt.com\"},"
 570       " {\"carryBackToken\": \"bl\", \"url\": \"http://www.bl.com\"}]");
 571
 572   // Simulate responses for the two connection URLs.
 573   GaiaCookieManagerService::ExternalCcResultFetcher::URLToTokenAndFetcher
 574       fetchers = result_fetcher.get_fetcher_map_for_testing();
 575   ASSERT_EQ(2u, fetchers.size());
 576   ASSERT_EQ(1u, fetchers.count(GURL("http://www.yt.com")));
 577   ASSERT_EQ(1u, fetchers.count(GURL("http://www.bl.com")));
 578
 579   ASSERT_EQ("bl:null,yt:null", result_fetcher.GetExternalCcResult());
 580   SimulateGetCheckConnctionInfoResult(
 581       fetchers[GURL("http://www.yt.com")].second, "yt_result");
 582   ASSERT_EQ("bl:null,yt:yt_result", result_fetcher.GetExternalCcResult());
 583   SimulateGetCheckConnctionInfoResult(
 584       fetchers[GURL("http://www.bl.com")].second, "bl_result");
 585   ASSERT_EQ("bl:bl_result,yt:yt_result", result_fetcher.GetExternalCcResult());
 586 }
 587
 588 TEST_F(GaiaCookieManagerServiceTest, ExternalCcResultFetcherTimeout) {
 589   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 590   GaiaCookieManagerService::ExternalCcResultFetcher result_fetcher(&helper);
 591   EXPECT_CALL(helper, StartFetchingMergeSession());
 592   result_fetcher.Start();
 593
 594   // Simulate a successful completion of GetCheckConnctionInfo.
 595   net::TestURLFetcher* fetcher = factory()->GetFetcherByID(0);
 596   ASSERT_TRUE(NULL != fetcher);
 597   SimulateGetCheckConnctionInfoSuccess(
 598       fetcher,
 599       "[{\"carryBackToken\": \"yt\", \"url\": \"http://www.yt.com\"},"
 600       " {\"carryBackToken\": \"bl\", \"url\": \"http://www.bl.com\"}]");
 601
 602   GaiaCookieManagerService::ExternalCcResultFetcher::URLToTokenAndFetcher
 603       fetchers = result_fetcher.get_fetcher_map_for_testing();
 604   ASSERT_EQ(2u, fetchers.size());
 605   ASSERT_EQ(1u, fetchers.count(GURL("http://www.yt.com")));
 606   ASSERT_EQ(1u, fetchers.count(GURL("http://www.bl.com")));
 607
 608   // Simulate response only for "yt".
 609   ASSERT_EQ("bl:null,yt:null", result_fetcher.GetExternalCcResult());
 610   SimulateGetCheckConnctionInfoResult(
 611       fetchers[GURL("http://www.yt.com")].second, "yt_result");
 612   ASSERT_EQ("bl:null,yt:yt_result", result_fetcher.GetExternalCcResult());
 613
 614   // Now timeout.
 615   result_fetcher.TimeoutForTests();
 616   ASSERT_EQ("bl:null,yt:yt_result", result_fetcher.GetExternalCcResult());
 617   fetchers = result_fetcher.get_fetcher_map_for_testing();
 618   ASSERT_EQ(0u, fetchers.size());
 619 }
 620
 621 TEST_F(GaiaCookieManagerServiceTest, ExternalCcResultFetcherTruncate) {
 622   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 623   GaiaCookieManagerService::ExternalCcResultFetcher result_fetcher(&helper);
 624   EXPECT_CALL(helper, StartFetchingMergeSession());
 625   result_fetcher.Start();
 626
 627   // Simulate a successful completion of GetCheckConnctionInfo.
 628   net::TestURLFetcher* fetcher = factory()->GetFetcherByID(0);
 629   ASSERT_TRUE(NULL != fetcher);
 630   SimulateGetCheckConnctionInfoSuccess(
 631       fetcher,
 632       "[{\"carryBackToken\": \"yt\", \"url\": \"http://www.yt.com\"}]");
 633
 634   GaiaCookieManagerService::ExternalCcResultFetcher::URLToTokenAndFetcher
 635       fetchers = result_fetcher.get_fetcher_map_for_testing();
 636   ASSERT_EQ(1u, fetchers.size());
 637   ASSERT_EQ(1u, fetchers.count(GURL("http://www.yt.com")));
 638
 639   // Simulate response for "yt" with a string that is too long.
 640   SimulateGetCheckConnctionInfoResult(
 641       fetchers[GURL("http://www.yt.com")].second, "1234567890123456trunc");
 642   ASSERT_EQ("yt:1234567890123456", result_fetcher.GetExternalCcResult());
 643 }
 644
 645 TEST_F(GaiaCookieManagerServiceTest, UbertokenSuccessFetchesExternalCC) {
 646   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 647
 648   EXPECT_CALL(helper, StartFetchingUbertoken());
 649   helper.AddAccountToCookie("acc1@gmail.com");
 650
 651   ASSERT_FALSE(factory()->GetFetcherByID(0));
 652   SimulateUbertokenSuccess(&helper, "token");
 653
 654   // Check there is now a fetcher that belongs to the ExternalCCResultFetcher.
 655   net::TestURLFetcher* fetcher = factory()->GetFetcherByID(0);
 656   ASSERT_TRUE(NULL != fetcher);
 657   SimulateGetCheckConnctionInfoSuccess(
 658       fetcher,
 659       "[{\"carryBackToken\": \"bl\", \"url\": \"http://www.bl.com\"}]");
 660   GaiaCookieManagerService::ExternalCcResultFetcher* result_fetcher =
 661       helper.external_cc_result_fetcher_for_testing();
 662   GaiaCookieManagerService::ExternalCcResultFetcher::URLToTokenAndFetcher
 663       fetchers = result_fetcher->get_fetcher_map_for_testing();
 664   ASSERT_EQ(1u, fetchers.size());
 665   ASSERT_EQ(1u, fetchers.count(GURL("http://www.bl.com")));
 666 }
 667
 668 TEST_F(GaiaCookieManagerServiceTest, UbertokenSuccessFetchesExternalCCOnce) {
 669   InstrumentedGaiaCookieManagerService helper(token_service(), signin_client());
 670
 671   helper.external_cc_result_fetcher_for_testing()->Start();
 672
 673   EXPECT_CALL(helper, StartFetchingUbertoken());
 674   helper.AddAccountToCookie("acc2@gmail.com");
 675   // There is already a ExternalCCResultFetch underway. This will trigger
 676   // StartFetchingMergeSession.
 677   EXPECT_CALL(helper, StartFetchingMergeSession());
 678   SimulateUbertokenSuccess(&helper, "token3");
 679 }