Changes to the GAIA auth fetching to support one-click login.

chrome/common/net/gaia/gaia_auth_fetcher_unittest.cc

 // Copyright (c) 2012 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>
@@ skipping 112 matching lines @@
 
   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,
-                                                 &out_sid,
-                                                 &out_lsid,
-                                                 &out_token);
+                                              &out_sid,
+                                              &out_lsid,
+                                              &out_token);
     EXPECT_EQ(lsid, out_lsid);
     EXPECT_EQ(sid, out_sid);
     EXPECT_EQ(token, out_token);
   }
 
   void RunErrorParsingTest(const std::string& data,
                            const std::string& error,
                            const std::string& error_url,
                            const std::string& captcha_url,
                            const std::string& captcha_token) {
     std::string out_error;
     std::string out_error_url;
     std::string out_captcha_url;
     std::string out_captcha_token;
 
     GaiaAuthFetcher::ParseClientLoginFailure(data,
-                                                &out_error,
-                                                &out_error_url,
-                                                &out_captcha_url,
-                                                &out_captcha_token);
+                                             &out_error,
+                                             &out_error_url,
+                                             &out_captcha_url,
+                                             &out_captcha_token);
     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 client_login_to_oauth2_source_;
@@ skipping 11 matching lines @@
   MockGaiaConsumer() {}
   ~MockGaiaConsumer() {}
 
   MOCK_METHOD1(OnClientLoginSuccess, void(const ClientLoginResult& result));
   MOCK_METHOD2(OnIssueAuthTokenSuccess, void(const std::string& service,
       const std::string& token));
   MOCK_METHOD3(OnOAuthLoginTokenSuccess,
       void(const std::string& refresh_token,
            const std::string& access_token,
            int expires_in_secs));
-  MOCK_METHOD1(OnTokenAuthSuccess, void(const std::string& data));
+  MOCK_METHOD2(OnTokenAuthSuccess,
+               void(const net::ResponseCookies&, const std::string& data));
   MOCK_METHOD1(OnMergeSessionSuccess, void(const std::string& data));
   MOCK_METHOD1(OnUberAuthTokenSuccess, 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(OnOAuthLoginTokenFailure,
       void(const GoogleServiceAuthError& error));
   MOCK_METHOD1(OnTokenAuthFailure, void(const GoogleServiceAuthError& error));
   MOCK_METHOD1(OnMergeSessionFailure, void(
@@ skipping 389 matching lines @@
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnOAuthLoginTokenSuccess("rt1", "at1", 3600))
       .Times(1);
 
   TestingProfile profile;
 
   TestURLFetcherFactory factory;
   GaiaAuthFetcher auth(&consumer, std::string(),
                        profile_.GetRequestContext());
   auth.StartOAuthLoginTokenFetch("lso_token");
+  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  EXPECT_TRUE(NULL != fetcher);
+  EXPECT_EQ(net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES,
+            fetcher->GetLoadFlags());
 
   net::ResponseCookies cookies;
   cookies.push_back(kGetAuthCodeValidCookie);
   EXPECT_TRUE(auth.HasPendingFetch());
   MockFetcher mock_fetcher1(
       client_login_to_oauth2_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
       net::HTTP_OK, cookies, "",
       content::URLFetcher::POST, &auth);
   auth.OnURLFetchComplete(&mock_fetcher1);
   EXPECT_TRUE(auth.HasPendingFetch());
   MockFetcher mock_fetcher2(
       oauth2_token_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
       net::HTTP_OK, cookies_, kGetTokenPairValidResponse,
       content::URLFetcher::POST, &auth);
   auth.OnURLFetchComplete(&mock_fetcher2);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
+TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenWithEmptyToken) {
+  MockGaiaConsumer consumer;
+  TestingProfile profile;
+  TestURLFetcherFactory factory;
+  GaiaAuthFetcher auth(&consumer, std::string(),
+                       profile_.GetRequestContext());
+  auth.StartOAuthLoginTokenFetch("");
+  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  EXPECT_TRUE(NULL != fetcher);
+  EXPECT_EQ(net::LOAD_NORMAL, fetcher->GetLoadFlags());
+}
+
 TEST_F(GaiaAuthFetcherTest, OAuthLoginTokenClientLoginToOAuth2Failure) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnOAuthLoginTokenFailure(_))
       .Times(1);
 
   TestingProfile profile;
 
   TestURLFetcherFactory factory;
   GaiaAuthFetcher auth(&consumer, std::string(),
                        profile_.GetRequestContext());
@@ skipping 36 matching lines @@
       oauth2_token_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
       net::HTTP_FORBIDDEN, cookies_, "",
       content::URLFetcher::POST, &auth);
   auth.OnURLFetchComplete(&mock_fetcher2);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, TokenAuthSuccess) {
   MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnTokenAuthSuccess("<html></html>"))
+  net::ResponseCookies cookies;
+  EXPECT_CALL(consumer, OnTokenAuthSuccess(cookies, "<html></html>"))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartTokenAuth("myubertoken");
 
   EXPECT_TRUE(auth.HasPendingFetch());
@@ skipping 207 matching lines @@
     std::string rt;
     std::string at;
     int exp = -1;
     EXPECT_TRUE(GaiaAuthFetcher::ParseOAuth2TokenPairResponse(
         kGetTokenPairValidResponse, &rt, &at, &exp));
     EXPECT_EQ("rt1", rt);
     EXPECT_EQ("at1", at);
     EXPECT_EQ(3600, exp);
   }
 }