Implement the gaia captcha state and unlock capability in the sync setup wiza...

chrome/browser/sync/sync_setup_wizard_unittest.cc

 // Copyright (c) 2009 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/json/json_writer.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/google_service_auth_error.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_setup_flow.h"
 #include "chrome/browser/sync/sync_setup_wizard.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/test/browser_with_test_window_test.h"
 #include "chrome/test/testing_profile.h"
 #include "chrome/test/test_browser_window.h"
 
 static const char* kTestUser = "chrome.p13n.test@gmail.com";
 static const char* kTestPassword = "passwd";
+static const char* kTestCaptcha = "pizzamyheart";
+static const char* kTestCaptchaUrl = "http://pizzamyheart/";
 
 typedef GoogleServiceAuthError AuthError;
 
 // A PSS subtype to inject.
 class ProfileSyncServiceForWizardTest : public ProfileSyncService {
  public:
   explicit ProfileSyncServiceForWizardTest(Profile* profile)
     : ProfileSyncService(profile), user_accepted_merge_and_sync_(false),
       user_cancelled_dialog_(false) {
     RegisterPreferences();
   }
 
   virtual ~ProfileSyncServiceForWizardTest() { }
 
   virtual void OnUserSubmittedAuth(const std::string& username,
-                                   const std::string& password) {
+                                   const std::string& password,
+                                   const std::string& captcha) {
     username_ = username;
     password_ = password;
+    captcha_ = captcha;
   }
   virtual void OnUserAcceptedMergeAndSync() {
     user_accepted_merge_and_sync_ = true;
   }
   virtual void OnUserCancelledDialog() {
     user_cancelled_dialog_ = true;
   }
 
   virtual string16 GetAuthenticatedUsername() const {
     return UTF8ToUTF16(username_);
   }
 
   void set_auth_state(const std::string& last_email,
-                      const AuthError::State& state) {
+                      const AuthError& error) {
     last_attempted_user_email_ = last_email;
-    last_auth_error_ = AuthError(state);
+    last_auth_error_ = error;
   }
 
   void ResetTestStats() {
     username_.clear();
     password_.clear();
+    captcha_.clear();
     user_accepted_merge_and_sync_ = false;
     user_cancelled_dialog_ = false;
   }
 
   std::string username_;
   std::string password_;
+  std::string captcha_;
   bool user_accepted_merge_and_sync_;
   bool user_cancelled_dialog_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceForWizardTest);
 };
 
 class TestingProfileWithSyncService : public TestingProfile {
  public:
   TestingProfileWithSyncService() {
@@ skipping 102 matching lines @@
 };
 
 TEST_F(SyncSetupWizardTest, InitialStepLogin) {
   DictionaryValue dialog_args;
   SyncSetupFlow::GetArgsForGaiaLogin(service_, &dialog_args);
   std::string json_start_args;
   base::JSONWriter::Write(&dialog_args, false, &json_start_args);
   ListValue credentials;
   std::string auth = "{\"user\":\"";
   auth += std::string(kTestUser) + "\",\"pass\":\"";
-  auth += std::string(kTestPassword) + "\"}";
+  auth += std::string(kTestPassword) + "\",\"captcha\":\"";
+  auth += std::string(kTestCaptcha) + "\"}";
   credentials.Append(new StringValue(auth));
 
   EXPECT_FALSE(wizard_->IsVisible());
   EXPECT_FALSE(test_window_->flow());
   wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
 
   EXPECT_TRUE(wizard_->IsVisible());
   EXPECT_TRUE(test_window_->TestAndResetWasShowHTMLDialogCalled());
   EXPECT_EQ(SyncSetupWizard::GAIA_LOGIN, test_window_->flow()->current_state_);
   EXPECT_EQ(SyncSetupWizard::DONE, test_window_->flow()->end_state_);
   EXPECT_EQ(json_start_args, test_window_->flow()->dialog_start_args_);
 
   // Simulate the user submitting credentials.
   test_window_->flow()->flow_handler_->HandleSubmitAuth(&credentials);
   EXPECT_TRUE(wizard_->IsVisible());
   EXPECT_EQ(SyncSetupWizard::GAIA_LOGIN, test_window_->flow()->current_state_);
   EXPECT_EQ(kTestUser, service_->username_);
   EXPECT_EQ(kTestPassword, service_->password_);
+  EXPECT_EQ(kTestCaptcha, service_->captcha_);
   EXPECT_FALSE(service_->user_accepted_merge_and_sync_);
   EXPECT_FALSE(service_->user_cancelled_dialog_);
   service_->ResetTestStats();
 
   // Simulate failed credentials.
-  service_->set_auth_state(kTestUser, AuthError::INVALID_GAIA_CREDENTIALS);
+  AuthError invalid_gaia(AuthError::INVALID_GAIA_CREDENTIALS);
+  service_->set_auth_state(kTestUser, invalid_gaia);
   wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
   EXPECT_TRUE(wizard_->IsVisible());
   EXPECT_FALSE(test_window_->TestAndResetWasShowHTMLDialogCalled());
   EXPECT_EQ(SyncSetupWizard::GAIA_LOGIN, test_window_->flow()->current_state_);
   dialog_args.Clear();
   SyncSetupFlow::GetArgsForGaiaLogin(service_, &dialog_args);
-  EXPECT_TRUE(2 == dialog_args.GetSize());
+  EXPECT_TRUE(3 == dialog_args.GetSize());
   std::string actual_user;
   dialog_args.GetString(L"user", &actual_user);
   EXPECT_EQ(kTestUser, actual_user);
   int error = -1;
   dialog_args.GetInteger(L"error", &error);
   EXPECT_EQ(static_cast<int>(AuthError::INVALID_GAIA_CREDENTIALS), error);
-  service_->set_auth_state(kTestUser, AuthError::NONE);
+  service_->set_auth_state(kTestUser, AuthError::None());
+
+  // Simulate captcha.
+  AuthError captcha_error(AuthError::FromCaptchaChallenge(
+      std::string(), GURL(kTestCaptchaUrl), GURL()));
+  service_->set_auth_state(kTestUser, captcha_error);
+  wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
+  SyncSetupFlow::GetArgsForGaiaLogin(service_, &dialog_args);
+  EXPECT_TRUE(3 == dialog_args.GetSize());
+  std::string captcha_url;
+  dialog_args.GetString(L"captchaUrl", &captcha_url);
+  EXPECT_EQ(kTestCaptchaUrl, GURL(captcha_url).spec());
+  error = -1;
+  dialog_args.GetInteger(L"error", &error);
+  EXPECT_EQ(static_cast<int>(AuthError::CAPTCHA_REQUIRED), error);
+  service_->set_auth_state(kTestUser, AuthError::None());
 
   // Simulate success.
   wizard_->Step(SyncSetupWizard::GAIA_SUCCESS);
   EXPECT_TRUE(wizard_->IsVisible());
   EXPECT_FALSE(test_window_->TestAndResetWasShowHTMLDialogCalled());
   EXPECT_EQ(SyncSetupWizard::GAIA_SUCCESS,
             test_window_->flow()->current_state_);
 
   wizard_->Step(SyncSetupWizard::DONE);  // No merge and sync.
   EXPECT_TRUE(wizard_->IsVisible());
@@ skipping 118 matching lines @@
   wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
   wizard_->Step(SyncSetupWizard::GAIA_SUCCESS);
   wizard_->Step(SyncSetupWizard::MERGE_AND_SYNC);
   wizard_->Step(SyncSetupWizard::DONE);
   test_window_->CloseDialog();
   EXPECT_TRUE(test_window_->TestAndResetWasShowHTMLDialogCalled());
 
   wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
   EXPECT_EQ(SyncSetupWizard::GAIA_SUCCESS, test_window_->flow()->end_state_);
 
-  service_->set_auth_state(kTestUser, AuthError::INVALID_GAIA_CREDENTIALS);
+  AuthError invalid_gaia(AuthError::INVALID_GAIA_CREDENTIALS);
+  service_->set_auth_state(kTestUser, invalid_gaia);
   wizard_->Step(SyncSetupWizard::GAIA_LOGIN);
   EXPECT_TRUE(wizard_->IsVisible());
   SyncSetupFlow::GetArgsForGaiaLogin(service_, &dialog_args);
-  EXPECT_TRUE(2 == dialog_args.GetSize());
+  EXPECT_TRUE(3 == dialog_args.GetSize());
   std::string actual_user;
   dialog_args.GetString(L"user", &actual_user);
   EXPECT_EQ(kTestUser, actual_user);
   int error = -1;
   dialog_args.GetInteger(L"error", &error);
   EXPECT_EQ(static_cast<int>(AuthError::INVALID_GAIA_CREDENTIALS), error);
-  service_->set_auth_state(kTestUser, AuthError::NONE);
+  service_->set_auth_state(kTestUser, AuthError::None());
 
   wizard_->Step(SyncSetupWizard::GAIA_SUCCESS);
   EXPECT_TRUE(test_window_->TestAndResetWasShowHTMLDialogCalled());
 }