Pre- and Auto-login should not log the user out of an already signed in

chrome/common/net/gaia/gaia_auth_fetcher_unittest.cc

 // Copyright (c) 2011 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.
 //
 // A complete set of unit tests for GaiaAuthFetcher.
 // Originally ported from GoogleAuthenticator tests.
 
 #include "chrome/common/net/gaia/gaia_auth_fetcher_unittest.h"
 
 #include <string>
 
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/common/net/gaia/gaia_auth_fetcher.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/net/http_return.h"
 #include "chrome/test/base/testing_browser_process_test.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/common/url_fetcher.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 
 MockFetcher::MockFetcher(bool success,
                          const GURL& url,
                          const std::string& results,
@@ skipping 26 matching lines @@
                                  results_);
 }
 
 
 class GaiaAuthFetcherTest : public TestingBrowserProcessTest {
  public:
   GaiaAuthFetcherTest()
       : client_login_source_(GaiaUrls::GetInstance()->client_login_url()),
         issue_auth_token_source_(
             GaiaUrls::GetInstance()->issue_auth_token_url()),
-        token_auth_source_(GaiaUrls::GetInstance()->token_auth_url()) {}
+        token_auth_source_(GaiaUrls::GetInstance()->token_auth_url()),
+        merge_session_source_(GaiaUrls::GetInstance()->merge_session_url()) {}
 
   void RunParsingTest(const std::string& data,
                       const std::string& sid,
                       const std::string& lsid,
                       const std::string& token) {
     std::string out_sid;
     std::string out_lsid;
     std::string out_token;
 
     GaiaAuthFetcher::ParseClientLoginResponse(data,
@@ skipping 23 matching lines @@
     EXPECT_EQ(error, out_error);
     EXPECT_EQ(error_url, out_error_url);
     EXPECT_EQ(captcha_url, out_captcha_url);
     EXPECT_EQ(captcha_token, out_captcha_token);
   }
 
   net::ResponseCookies cookies_;
   GURL client_login_source_;
   GURL issue_auth_token_source_;
   GURL token_auth_source_;
+  GURL merge_session_source_;
   TestingProfile profile_;
  protected:
   MessageLoop message_loop_;
 };
 
 class MockGaiaConsumer : public GaiaAuthConsumer {
  public:
   MockGaiaConsumer() {}
   ~MockGaiaConsumer() {}
 
   MOCK_METHOD1(OnClientLoginSuccess, void(const ClientLoginResult& result));
   MOCK_METHOD2(OnIssueAuthTokenSuccess, void(const std::string& service,
       const std::string& token));
   MOCK_METHOD1(OnTokenAuthSuccess, void(const std::string& data));
+  MOCK_METHOD1(OnMergeSessionSuccess, void(const std::string& data));
   MOCK_METHOD1(OnClientLoginFailure,
       void(const GoogleServiceAuthError& error));
   MOCK_METHOD2(OnIssueAuthTokenFailure, void(const std::string& service,
       const GoogleServiceAuthError& error));
   MOCK_METHOD1(OnTokenAuthFailure, void(const GoogleServiceAuthError& error));
+  MOCK_METHOD1(OnMergeSessionFailure, void(
+      const GoogleServiceAuthError& error));
 };
 
 TEST_F(GaiaAuthFetcherTest, ErrorComparator) {
   GoogleServiceAuthError expected_error =
       GoogleServiceAuthError::FromConnectionError(-101);
 
   GoogleServiceAuthError matching_error =
       GoogleServiceAuthError::FromConnectionError(-101);
 
   EXPECT_TRUE(expected_error == matching_error);
@@ skipping 442 matching lines @@
   EXPECT_TRUE(auth.HasPendingFetch());
   auth.OnURLFetchComplete(
       NULL,
       token_auth_source_,
       net::URLRequestStatus(net::URLRequestStatus::FAILED, 0),
       RC_REQUEST_OK,
       cookies_,
       "");
   EXPECT_FALSE(auth.HasPendingFetch());
 }
+
+TEST_F(GaiaAuthFetcherTest, MergeSessionSuccess) {
+  MockGaiaConsumer consumer;
+  EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>"))
+      .Times(1);
+
+  TestingProfile profile;
+  TestURLFetcherFactory factory;
+
+  GaiaAuthFetcher auth(&consumer, std::string(),
+      profile_.GetRequestContext());
+  auth.StartMergeSession("myubertoken");
+
+  EXPECT_TRUE(auth.HasPendingFetch());
+  auth.OnURLFetchComplete(
+      NULL,
+      merge_session_source_,
+      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
+      RC_REQUEST_OK,
+      cookies_,
+      "<html></html>");
+  EXPECT_FALSE(auth.HasPendingFetch());
+}
+
+TEST_F(GaiaAuthFetcherTest, MergeSessionSuccessRedirect) {
+  MockGaiaConsumer consumer;
+  EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>"))
+      .Times(1);
+
+  TestingProfile profile;
+  TestURLFetcherFactory factory;
+
+  GaiaAuthFetcher auth(&consumer, std::string(),
+      profile_.GetRequestContext());
+  auth.StartMergeSession("myubertoken");
+
+  // Make sure the fetcher created has the expected flags.  Set its url()
+  // properties to reflect a redirect.
+  TestURLFetcher* test_fetcher = factory.GetFetcherByID(0);
+  EXPECT_TRUE(test_fetcher != NULL);
+  EXPECT_TRUE(test_fetcher->load_flags() == net::LOAD_NORMAL);
+  EXPECT_TRUE(auth.HasPendingFetch());
+
+  GURL final_url("http://www.google.com/CheckCookie");
+  test_fetcher->set_url(final_url);
+
+  auth.OnURLFetchComplete(
+      test_fetcher,
+      test_fetcher->url(),
+      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
+      RC_REQUEST_OK,
+      cookies_,
+      "<html></html>");
+  EXPECT_FALSE(auth.HasPendingFetch());
+}