Delay loading the NTP after sign in until MergeSession has been performed in

chrome/browser/signin/google_auto_login_helper_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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
+#include "base/strings/stringprintf.h"
 #include "chrome/browser/signin/google_auto_login_helper.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-class MockUbertokenFetcher : public UbertokenFetcher {
+class MockObserver : public GoogleAutoLoginHelper::Observer {
  public:
-  MockUbertokenFetcher(Profile* profile, UbertokenConsumer* consumer) :
-      UbertokenFetcher(profile, consumer), account_id("") {}
-
-  void completePendingRequest() {
-    OnUberAuthTokenSuccess("mock token: " + account_id);
+  explicit MockObserver(GoogleAutoLoginHelper* helper) : helper_(helper) {
+    helper_->AddObserver(this);
   }
 
-  virtual void StartFetchingToken(const std::string& id) OVERRIDE {
-    account_id = id;
+  ~MockObserver() {
+    helper_->RemoveObserver(this);
   }
 
-  std::string account_id;
+  MOCK_METHOD2(MergeSessionCompleted,
+               void(const std::string&,
+                    const GoogleServiceAuthError& ));
+ private:
+  GoogleAutoLoginHelper* helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockObserver);
 };
 
 // Counts number of InstrumentedGoogleAutoLoginHelper created.
 // We can EXPECT_* to be zero at the end of our unit tests
 // to make sure everything is properly deleted.
 
 int total = 0;
 
 class InstrumentedGoogleAutoLoginHelper : public GoogleAutoLoginHelper {
  public:
-  std::vector<MockUbertokenFetcher*>* mock_uber_fetchers_;
-  TestingProfile profile_;
-
-  InstrumentedGoogleAutoLoginHelper(
-    std::vector<MockUbertokenFetcher*>* fetchers) :
-    GoogleAutoLoginHelper(0), mock_uber_fetchers_(fetchers) {
+  explicit InstrumentedGoogleAutoLoginHelper(Profile* profile) :
+    GoogleAutoLoginHelper(profile, NULL) {
     total++;
   }
 
   virtual ~InstrumentedGoogleAutoLoginHelper() {
     total--;
   }
 
-  virtual void OnUbertokenSuccess(const std::string& token) OVERRIDE {
-    OnMergeSessionSuccess(token);
-  }
+  MOCK_METHOD0(StartFetching, void());
 
-  virtual UbertokenFetcher* CreateNewUbertokenFetcher() OVERRIDE {
-    MockUbertokenFetcher* m = new MockUbertokenFetcher(&profile_, this);
-    mock_uber_fetchers_->push_back(m);
-    return m;
-  }
-
-  void completePendingFetchers() {
-    while (!mock_uber_fetchers_->empty()) {
-      MockUbertokenFetcher* fetcher = mock_uber_fetchers_->back();
-      mock_uber_fetchers_->pop_back();
-      fetcher->completePendingRequest();
-    }
-  }
-
-  MOCK_METHOD1(OnMergeSessionSuccess, void(const std::string& uber_token));
-
-  void OnMergeSessionSuccessConcrete(const std::string& uber_token) {
-    GoogleAutoLoginHelper::OnMergeSessionSuccess(uber_token);
-  }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InstrumentedGoogleAutoLoginHelper);
 };
 
 class GoogleAutoLoginHelperTest : public testing::Test {
  public:
-  std::vector<MockUbertokenFetcher*> mock_uber_fetchers_;
-  base::MessageLoop message_loop_;
+   GoogleAutoLoginHelperTest()
+       : no_error_(GoogleServiceAuthError::NONE),
+         error_(GoogleServiceAuthError::SERVICE_ERROR) {}
+
+  TestingProfile* profile() { return &profile_; }
+
+  void SimulateUbertokenFailure(UbertokenConsumer* consumer,
+                                const GoogleServiceAuthError& error) {
+    consumer->OnUbertokenFailure(error);
+  }
+
+  void SimulateMergeSessionSuccess(GaiaAuthConsumer* consumer,
+                                   const std::string& data) {
+    consumer->OnMergeSessionSuccess(data);
+  }
+
+  void SimulateMergeSessionFailure(GaiaAuthConsumer* consumer,
+                                   const GoogleServiceAuthError& error) {
+    consumer->OnMergeSessionFailure(error);
+  }
+
+  const GoogleServiceAuthError& no_error() { return no_error_; }
+  const GoogleServiceAuthError& error() { return error_; }
+
+ private:
+  content::TestBrowserThreadBundle thread_bundle_;
+  TestingProfile profile_;
+  GoogleServiceAuthError no_error_;
+  GoogleServiceAuthError error_;
 };
 
 } // namespace
 
-using ::testing::Invoke;
 using ::testing::_;
 
-TEST_F(GoogleAutoLoginHelperTest, AllRequestsInOneGo) {
-  total = 0;
+TEST_F(GoogleAutoLoginHelperTest, Success) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
 
-  InstrumentedGoogleAutoLoginHelper* helper =
-      new InstrumentedGoogleAutoLoginHelper(&mock_uber_fetchers_);
-  EXPECT_CALL(*helper, OnMergeSessionSuccess("mock token: acc1@gmail.com"));
-  EXPECT_CALL(*helper, OnMergeSessionSuccess("mock token: acc2@gmail.com"));
-  EXPECT_CALL(*helper, OnMergeSessionSuccess("mock token: acc3@gmail.com"));
-  EXPECT_CALL(*helper, OnMergeSessionSuccess("mock token: acc4@gmail.com"));
-  EXPECT_CALL(*helper, OnMergeSessionSuccess("mock token: acc5@gmail.com"));
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", no_error()));
 
-  // Don't completely mock out OnMergeSessionSuccess, let GoogleAutoLoginHelper
-  // actually call OnMergeSessionSuccess to clean up it's work queue because
-  // it'll delete itself once the work queue becomes empty.
-  ON_CALL(*helper, OnMergeSessionSuccess(_)).WillByDefault(Invoke(helper,
-          &InstrumentedGoogleAutoLoginHelper::OnMergeSessionSuccessConcrete));
-  helper->LogIn("acc1@gmail.com");
-  helper->LogIn("acc2@gmail.com");
-  helper->LogIn("acc3@gmail.com");
-  helper->LogIn("acc4@gmail.com");
-  helper->LogIn("acc5@gmail.com");
-  helper->completePendingFetchers();
+  helper.LogIn("acc1@gmail.com");
+  SimulateMergeSessionSuccess(&helper, "token");
+}
 
-  // Make sure GoogleAutoLoginHelper cleans itself up after everything is done.
-  message_loop_.RunUntilIdle();
-  EXPECT_EQ(0, total);
+TEST_F(GoogleAutoLoginHelperTest, FailedMergeSession) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", error()));
+
+  helper.LogIn("acc1@gmail.com");
+  SimulateMergeSessionFailure(&helper, error());
 }
+
+TEST_F(GoogleAutoLoginHelperTest, FailedUbertoken) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", error()));
+
+  helper.LogIn("acc1@gmail.com");
+  SimulateUbertokenFailure(&helper, error());
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterSuccess) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching()).Times(2);
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", no_error()));
+  EXPECT_CALL(observer, MergeSessionCompleted("acc2@gmail.com", no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateMergeSessionSuccess(&helper, "token1");
+  SimulateMergeSessionSuccess(&helper, "token2");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterFailure1) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching()).Times(2);
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", error()));
+  EXPECT_CALL(observer, MergeSessionCompleted("acc2@gmail.com", no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateMergeSessionFailure(&helper, error());
+  SimulateMergeSessionSuccess(&helper, "token2");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterFailure2) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching()).Times(2);
+  EXPECT_CALL(observer, MergeSessionCompleted("acc1@gmail.com", error()));
+  EXPECT_CALL(observer, MergeSessionCompleted("acc2@gmail.com", no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateUbertokenFailure(&helper, error());
+  SimulateMergeSessionSuccess(&helper, "token2");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, AllRequestsInMultipleGoes) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  MockObserver observer(&helper);
+
+  EXPECT_CALL(helper, StartFetching()).Times(4);
+  EXPECT_CALL(observer, MergeSessionCompleted(_, no_error())).Times(4);
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+
+  SimulateMergeSessionSuccess(&helper, "token1");
+
+  helper.LogIn("acc3@gmail.com");
+
+  SimulateMergeSessionSuccess(&helper, "token2");
+  SimulateMergeSessionSuccess(&helper, "token3");
+
+  helper.LogIn("acc4@gmail.com");
+
+  SimulateMergeSessionSuccess(&helper, "token4");
+}