Remove support for ClientOAuth from GaiaAuthFetcher.

google_apis/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 <string>
 
 #include "base/json/json_reader.h"
@@ skipping 39 matching lines @@
 static const char kClientOAuthValidResponse[] =
     "{"
     "  \"oauth2\": {"
     "    \"refresh_token\": \"rt1\","
     "    \"access_token\": \"at1\","
     "    \"expires_in\": 3600,"
     "    \"token_type\": \"Bearer\""
     "  }"
     "}";
 
-static void ExpectCaptchaChallenge(const GoogleServiceAuthError& error) {
-  // Make sure this is a captcha server challange.
-  EXPECT_EQ(GoogleServiceAuthError::CAPTCHA_REQUIRED, error.state());
-  EXPECT_EQ("challengetokenblob", error.captcha().token);
-  EXPECT_EQ("http://www.audio.com/", error.captcha().audio_url.spec());
-  EXPECT_EQ("http://www.image.com/", error.captcha().image_url.spec());
-  EXPECT_EQ(640, error.captcha().image_width);
-  EXPECT_EQ(480, error.captcha().image_height);
-}
-
-static void ExpectBadAuth(const GoogleServiceAuthError& error) {
-  EXPECT_EQ(GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS, error.state());
-}
-
-static void ExpectTwoFactorChallenge(const GoogleServiceAuthError& error) {
-  // Make sure this is a captcha server challange.
-  EXPECT_EQ(GoogleServiceAuthError::TWO_FACTOR, error.state());
-  EXPECT_EQ("challengetokenblob", error.second_factor().token);
-  EXPECT_EQ("prompt_text", error.second_factor().prompt_text);
-  EXPECT_EQ("alternate_text", error.second_factor().alternate_text);
-  EXPECT_EQ(10, error.second_factor().field_length);
-}
-
 }  // namespace
 
 MockFetcher::MockFetcher(bool success,
                          const GURL& url,
                          const std::string& results,
                          net::URLFetcher::RequestType request_type,
                          net::URLFetcherDelegate* d)
     : TestURLFetcher(0, url, d) {
   set_url(url);
   net::URLRequestStatus::Status code;
@@ skipping 38 matching lines @@
         issue_auth_token_source_(
             GaiaUrls::GetInstance()->issue_auth_token_url()),
         client_login_to_oauth2_source_(
             GaiaUrls::GetInstance()->client_login_to_oauth2_url()),
         oauth2_token_source_(GaiaUrls::GetInstance()->oauth2_token_url()),
         token_auth_source_(GaiaUrls::GetInstance()->token_auth_url()),
         merge_session_source_(GaiaUrls::GetInstance()->merge_session_url()),
         uberauth_token_source_(base::StringPrintf(
             "%s?source=&issueuberauth=1",
             GaiaUrls::GetInstance()->oauth1_login_url().c_str())),
-        client_oauth_source_(GaiaUrls::GetInstance()->client_oauth_url()),
         oauth_login_gurl_(GaiaUrls::GetInstance()->oauth1_login_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;
 
@@ skipping 28 matching lines @@
   }
 
   net::ResponseCookies cookies_;
   GURL client_login_source_;
   GURL issue_auth_token_source_;
   GURL client_login_to_oauth2_source_;
   GURL oauth2_token_source_;
   GURL token_auth_source_;
   GURL merge_session_source_;
   GURL uberauth_token_source_;
-  GURL client_oauth_source_;
   GURL oauth_login_gurl_;
   TestingProfile profile_;
  protected:
   MessageLoop message_loop_;
 };
 
 class MockGaiaConsumer : public GaiaAuthConsumer {
  public:
   MockGaiaConsumer() {}
   ~MockGaiaConsumer() {}
@@ skipping 606 matching lines @@
   {  // Single valid cookie (like in real responses).
     std::string auth_code;
     net::ResponseCookies cookies;
     cookies.push_back(kGetAuthCodeValidCookie);
     EXPECT_TRUE(GaiaAuthFetcher::ParseClientLoginToOAuth2Response(
         cookies, &auth_code));
     EXPECT_EQ("test-code", auth_code);
   }
 }
 
-TEST_F(GaiaAuthFetcherTest, ClientOAuthSuccess) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_results(kClientOAuthValidResponse);
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthSuccess(
-      GaiaAuthConsumer::ClientOAuthResult("rt1", "at1", 3600))).Times(1);
-
-  GaiaAuthFetcher auth(&consumer, "tests", profile_.GetRequestContext());
-  std::vector<std::string> scopes;
-  scopes.push_back(GaiaUrls::GetInstance()->oauth1_login_scope());
-  scopes.push_back("https://some.other.scope.com");
-  auth.StartClientOAuth("username", "password", scopes, std::string(), "en");
-
-  std::string expected_text = base::StringPrintf(
-      "{"
-      "\"email\": \"username\","
-      "\"password\": \"password\","
-      "\"scopes\": [\"https://www.google.com/accounts/OAuthLogin\","
-      "             \"https://some.other.scope.com\"],"
-      "\"oauth2_client_id\": \"%s\","
-      "\"friendly_device_name\": \"tests\","
-      "\"accepts_challenges\": [\"Captcha\", \"TwoStep\"],"
-      "\"locale\": \"en\","
-      "\"fallback\": { \"name\": \"GetOAuth2Token\" }"
-      "}",
-      google_apis::GetOAuth2ClientID(google_apis::CLIENT_MAIN).c_str());
-
-  scoped_ptr<base::Value> actual(base::JSONReader::Read(auth.request_body_));
-  scoped_ptr<base::Value> expected(base::JSONReader::Read(expected_text));
-  EXPECT_TRUE(expected->Equals(actual.get()));
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthWithQuote) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_results(kClientOAuthValidResponse);
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthSuccess(
-      GaiaAuthConsumer::ClientOAuthResult("rt1", "at1", 3600))).Times(1);
-
-  GaiaAuthFetcher auth(&consumer, "te\"sts", profile_.GetRequestContext());
-  std::vector<std::string> scopes;
-  scopes.push_back("https://some.\"other.scope.com");
-  auth.StartClientOAuth(
-      "user\"name", "pass\"word", scopes, std::string(), "e\"n");
-
-  std::string expected_text = base::StringPrintf(
-      "{"
-      "\"email\": \"user\\\"name\","
-      "\"password\": \"pass\\\"word\","
-      "\"scopes\": [\"https://some.\\\"other.scope.com\"],"
-      "\"oauth2_client_id\": \"%s\","
-      "\"friendly_device_name\": \"te\\\"sts\","
-      "\"accepts_challenges\": [\"Captcha\", \"TwoStep\"],"
-      "\"locale\": \"e\\\"n\","
-      "\"fallback\": { \"name\": \"GetOAuth2Token\" }"
-      "}",
-      google_apis::GetOAuth2ClientID(google_apis::CLIENT_MAIN).c_str());
-  scoped_ptr<base::Value> actual(base::JSONReader::Read(auth.request_body_));
-  scoped_ptr<base::Value> expected(base::JSONReader::Read(expected_text));
-  EXPECT_TRUE(expected->Equals(actual.get()));
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthBadAuth) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_success(false);
-  factory.set_results("{"
-                      "  \"cause\" : \"BadAuthentication\","
-                      "  \"fallback\" : {"
-                      "    \"name\" : \"Terminating\","
-                      "    \"url\" : \"https://www.terminating.com\""
-                      "  }"
-                      "}");
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthFailure(_))
-      .WillOnce(Invoke(ExpectBadAuth));
-
-  GaiaAuthFetcher auth(&consumer, "tests", profile_.GetRequestContext());
-  std::vector<std::string> scopes;
-  scopes.push_back(GaiaUrls::GetInstance()->oauth1_login_scope());
-  auth.StartClientOAuth("username", "password", scopes, std::string(), "en");
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthCaptchaChallenge) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_success(false);
-  factory.set_results("{"
-                      "  \"cause\" : \"NeedsAdditional\","
-                      "  \"fallback\" : {"
-                      "    \"name\" : \"Terminating\","
-                      "    \"url\" : \"https://www.terminating.com\""
-                      "  },"
-                      "  \"challenge\" : {"
-                      "    \"name\" : \"Captcha\","
-                      "    \"image_url\" : \"http://www.image.com/\","
-                      "    \"image_width\" : 640,"
-                      "    \"image_height\" : 480,"
-                      "    \"audio_url\" : \"http://www.audio.com/\","
-                      "    \"challenge_token\" : \"challengetokenblob\""
-                      "  }"
-                      "}");
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthFailure(_))
-      .WillOnce(Invoke(ExpectCaptchaChallenge));
-
-  GaiaAuthFetcher auth(&consumer, "tests", profile_.GetRequestContext());
-  std::vector<std::string> scopes;
-  scopes.push_back(GaiaUrls::GetInstance()->oauth1_login_scope());
-  auth.StartClientOAuth("username", "password", scopes, std::string(), "en");
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthTwoFactorChallenge) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_success(false);
-  factory.set_results("{"
-                      "  \"cause\" : \"NeedsAdditional\","
-                      "  \"fallback\" : {"
-                      "    \"name\" : \"Terminating\","
-                      "    \"url\" : \"https://www.terminating.com\""
-                      "  },"
-                      "  \"challenge\" : {"
-                      "    \"name\" : \"TwoStep\","
-                      "    \"prompt_text\" : \"prompt_text\","
-                      "    \"alternate_text\" : \"alternate_text\","
-                      "    \"challenge_token\" : \"challengetokenblob\","
-                      "    \"field_length\" : 10"
-                      "  }"
-                      "}");
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthFailure(_))
-      .WillOnce(Invoke(ExpectTwoFactorChallenge));
-
-  GaiaAuthFetcher auth(&consumer, "tests", profile_.GetRequestContext());
-  std::vector<std::string> scopes;
-  scopes.push_back(GaiaUrls::GetInstance()->oauth1_login_scope());
-  auth.StartClientOAuth("username", "password", scopes, std::string(), "en");
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthChallengeSuccess) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_results(kClientOAuthValidResponse);
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthSuccess(
-      GaiaAuthConsumer::ClientOAuthResult("rt1", "at1", 3600))).Times(2);
-
-  GaiaAuthFetcher auth1(&consumer, std::string(), profile_.GetRequestContext());
-  auth1.StartClientOAuthChallengeResponse(GoogleServiceAuthError::TWO_FACTOR,
-                                          "token", "mysolution");
-
-  scoped_ptr<base::Value> actual1(base::JSONReader::Read(auth1.request_body_));
-  scoped_ptr<base::Value> expected1(base::JSONReader::Read(
-      "{"
-      "  \"challenge_reply\" : {"
-      "    \"name\" : \"TwoStep\","
-      "    \"challenge_token\" : \"token\","
-      "    \"otp\" : \"mysolution\""
-      "  }"
-      "}"));
-  EXPECT_TRUE(expected1->Equals(actual1.get()));
-
-  GaiaAuthFetcher auth2(&consumer, "tests", profile_.GetRequestContext());
-  auth2.StartClientOAuthChallengeResponse(
-      GoogleServiceAuthError::CAPTCHA_REQUIRED, "token", "mysolution");
-
-  scoped_ptr<base::Value> actual2(base::JSONReader::Read(auth2.request_body_));
-  scoped_ptr<base::Value> expected2(base::JSONReader::Read(
-      "{"
-      "  \"challenge_reply\" : {"
-      "    \"name\" : \"Captcha\","
-      "    \"challenge_token\" : \"token\","
-      "    \"solution\" : \"mysolution\""
-      "  }"
-      "}"));
-  EXPECT_TRUE(expected2->Equals(actual2.get()));
-}
-
-TEST_F(GaiaAuthFetcherTest, ClientOAuthChallengeQuote) {
-  MockURLFetcherFactory<MockFetcher> factory;
-  factory.set_results(kClientOAuthValidResponse);
-
-  MockGaiaConsumer consumer;
-  EXPECT_CALL(consumer, OnClientOAuthSuccess(
-      GaiaAuthConsumer::ClientOAuthResult("rt1", "at1", 3600))).Times(1);
-
-  GaiaAuthFetcher auth(&consumer, std::string(), profile_.GetRequestContext());
-  auth.StartClientOAuthChallengeResponse(GoogleServiceAuthError::TWO_FACTOR,
-                                         "to\"ken", "my\"solution");
-
-  scoped_ptr<base::Value> actual(base::JSONReader::Read(auth.request_body_));
-  scoped_ptr<base::Value> expected(base::JSONReader::Read(
-      "{"
-      "  \"challenge_reply\" : {"
-      "    \"name\" : \"TwoStep\","
-      "    \"challenge_token\" : \"to\\\"ken\","
-      "    \"otp\" : \"my\\\"solution\""
-      "  }"
-      "}"));
-  EXPECT_TRUE(expected->Equals(actual.get()));
-}
-
 TEST_F(GaiaAuthFetcherTest, StartOAuthLogin) {
   // OAuthLogin returns the same as the ClientLogin endpoint, minus CAPTCHA
   // responses.
   std::string data("SID=sid\nLSID=lsid\nAuth=auth\n");
 
   GaiaAuthConsumer::ClientLoginResult result;
   result.lsid = "lsid";
   result.sid = "sid";
   result.token = "auth";
   result.data = data;
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnClientLoginSuccess(result))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   MockFetcher mock_fetcher(
       oauth_login_gurl_, status, net::HTTP_OK, cookies_, data,
       net::URLFetcher::GET, &auth);
   auth.OnURLFetchComplete(&mock_fetcher);
 }