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 {
- public:
-  MockUbertokenFetcher(Profile* profile, UbertokenConsumer* consumer) :
-      UbertokenFetcher(profile, consumer), account_id("") {}
-
-  void completePendingRequest() {
-    OnUberAuthTokenSuccess("mock token: " + account_id);
-  }
-
-  virtual void StartFetchingToken(const std::string& id) OVERRIDE {
-    account_id = id;
-  }
-
-  std::string account_id;
-};
-
 // 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) {
     total++;
   }
 
   virtual ~InstrumentedGoogleAutoLoginHelper() {
     total--;
   }
 
-  virtual void OnUbertokenSuccess(const std::string& token) OVERRIDE {
-    OnMergeSessionSuccess(token);
-  }
+  MOCK_METHOD0(StartFetching, void());
+  MOCK_METHOD1(SignalComplete,
+               void(const GoogleServiceAuthError& error));
 
-  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);
-  }
+  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) {
+TEST_F(GoogleAutoLoginHelperTest, Success) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  SimulateMergeSessionSuccess(&helper, "token");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, FailedMergeSession) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(error()));
+
+  helper.LogIn("acc1@gmail.com");
+  SimulateMergeSessionFailure(&helper, error());
+}
+
+TEST_F(GoogleAutoLoginHelperTest, FailedUbertoken) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(error()));
+
+  helper.LogIn("acc1@gmail.com");
+  SimulateUbertokenFailure(&helper, error());
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterSuccess) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  testing::InSequence sequence;
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(no_error()));
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateMergeSessionSuccess(&helper, "data");
+  SimulateMergeSessionSuccess(&helper, "data");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterFailure1) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  testing::InSequence sequence;
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(error()));
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateMergeSessionFailure(&helper, error());
+  SimulateMergeSessionSuccess(&helper, "data");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, ContinueAfterFailure2) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  testing::InSequence sequence;
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(error()));
+  EXPECT_CALL(helper, StartFetching());
+  EXPECT_CALL(helper, SignalComplete(no_error()));
+
+  helper.LogIn("acc1@gmail.com");
+  helper.LogIn("acc2@gmail.com");
+  SimulateUbertokenFailure(&helper, error());
+  SimulateMergeSessionSuccess(&helper, "data");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, AllRequestsInMultipleGoes) {
+  InstrumentedGoogleAutoLoginHelper helper(profile());
+  helper.disable_auto_delete_when_done();
+
+  const int kNumAccounts = 4;
+
+  testing::InSequence sequence;
+  for (int i = 0; i < kNumAccounts; ++i) {
+    EXPECT_CALL(helper, StartFetching());
+    EXPECT_CALL(helper, SignalComplete(no_error()));
+  }
+
+  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");
+}
+
+TEST_F(GoogleAutoLoginHelperTest, AutoDelete) {
   total = 0;
 
-  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"));
+  // In auto delete mode, the helper deletes itself when done.  So the same
+  // variable is used with all new instances.  The code checks at the end that
+  // all instances have been destroyed.
+  typedef testing::NiceMock<InstrumentedGoogleAutoLoginHelper> NiceHelper;
+  InstrumentedGoogleAutoLoginHelper* helper = NULL;
 
-  // 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 = new NiceHelper(profile());
   helper->LogIn("acc1@gmail.com");
+  SimulateMergeSessionSuccess(helper, "token1");
+
+  helper = new NiceHelper(profile());
   helper->LogIn("acc2@gmail.com");
+  SimulateMergeSessionFailure(helper, error());
+
+  helper = new NiceHelper(profile());
   helper->LogIn("acc3@gmail.com");
-  helper->LogIn("acc4@gmail.com");
-  helper->LogIn("acc5@gmail.com");
-  helper->completePendingFetchers();
+  SimulateUbertokenFailure(helper, error());
 
-  // Make sure GoogleAutoLoginHelper cleans itself up after everything is done.
-  message_loop_.RunUntilIdle();
-  EXPECT_EQ(0, total);
+  ASSERT_EQ(3, total);
+  base::MessageLoop::current()->RunUntilIdle();
+  ASSERT_EQ(0, total);
 }