Home | History | Annotate | Download | only in login 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_MOCK_AUTHENTICATOR_H_
      6 #define CHROME_BROWSER_CHROMEOS_LOGIN_MOCK_AUTHENTICATOR_H_
      7 #pragma once
      8 
      9 #include <string>
     10 
     11 #include "chrome/browser/chromeos/login/authenticator.h"
     12 #include "chrome/browser/chromeos/login/background_view.h"
     13 #include "chrome/browser/chromeos/login/login_utils.h"
     14 #include "chrome/common/net/gaia/google_service_auth_error.h"
     15 #include "content/browser/browser_thread.h"
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 
     18 class Profile;
     19 
     20 namespace chromeos {
     21 
     22 class LoginStatusConsumer;
     23 
     24 class MockAuthenticator : public Authenticator {
     25  public:
     26   MockAuthenticator(LoginStatusConsumer* consumer,
     27                     const std::string& expected_username,
     28                     const std::string& expected_password)
     29       : Authenticator(consumer),
     30         expected_username_(expected_username),
     31         expected_password_(expected_password) {
     32   }
     33 
     34   // Returns true after posting task to UI thread to call OnLoginSuccess().
     35   // This is called on the FILE thread now, so we need to do this.
     36   virtual bool AuthenticateToLogin(Profile* profile,
     37                                    const std::string& username,
     38                                    const std::string& password,
     39                                    const std::string& login_token,
     40                                    const std::string& login_captcha) {
     41     if (expected_username_ == username && expected_password_ == password) {
     42       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
     43           NewRunnableMethod(this, &MockAuthenticator::OnLoginSuccess,
     44                             GaiaAuthConsumer::ClientLoginResult(), false));
     45       return true;
     46     }
     47     GoogleServiceAuthError error(
     48         GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
     49     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
     50         NewRunnableMethod(this, &MockAuthenticator::OnLoginFailure,
     51                           LoginFailure::FromNetworkAuthFailure(error)));
     52     return false;
     53   }
     54 
     55   virtual bool AuthenticateToUnlock(const std::string& username,
     56                                     const std::string& password) {
     57     return AuthenticateToLogin(NULL /* not used */, username, password,
     58                                std::string(), std::string());
     59   }
     60 
     61   virtual void LoginOffTheRecord() {
     62     consumer_->OnOffTheRecordLoginSuccess();
     63   }
     64 
     65   void OnLoginSuccess(const GaiaAuthConsumer::ClientLoginResult& credentials,
     66                       bool request_pending) {
     67     // If we want to be more like the real thing, we could save username
     68     // in AuthenticateToLogin, but there's not much of a point.
     69     consumer_->OnLoginSuccess(expected_username_,
     70                               expected_password_,
     71                               credentials,
     72                               request_pending);
     73   }
     74 
     75   void OnLoginFailure(const LoginFailure& failure) {
     76       consumer_->OnLoginFailure(failure);
     77       VLOG(1) << "Posting a QuitTask to UI thread";
     78       BrowserThread::PostTask(
     79           BrowserThread::UI, FROM_HERE, new MessageLoop::QuitTask);
     80   }
     81 
     82   virtual void RecoverEncryptedData(
     83       const std::string& old_password,
     84       const GaiaAuthConsumer::ClientLoginResult& credentials) {}
     85 
     86   virtual void ResyncEncryptedData(
     87       const GaiaAuthConsumer::ClientLoginResult& credentials) {}
     88 
     89   virtual void RetryAuth(Profile* profile,
     90                          const std::string& username,
     91                          const std::string& password,
     92                          const std::string& login_token,
     93                          const std::string& login_captcha) {}
     94 
     95  private:
     96   std::string expected_username_;
     97   std::string expected_password_;
     98 
     99   DISALLOW_COPY_AND_ASSIGN(MockAuthenticator);
    100 };
    101 
    102 class MockLoginUtils : public LoginUtils {
    103  public:
    104   explicit MockLoginUtils(const std::string& expected_username,
    105                           const std::string& expected_password)
    106       : expected_username_(expected_username),
    107         expected_password_(expected_password) {
    108   }
    109 
    110   virtual bool ShouldWaitForWifi() {
    111     return false;
    112   }
    113 
    114   virtual void PrepareProfile(const std::string& username,
    115                               const std::string& password,
    116                               const GaiaAuthConsumer::ClientLoginResult& res,
    117                               bool pending_requests,
    118                               Delegate* delegate) {
    119     EXPECT_EQ(expected_username_, username);
    120     EXPECT_EQ(expected_password_, password);
    121     // Profile hasn't been loaded.
    122     delegate->OnProfilePrepared(NULL);
    123   }
    124 
    125   virtual void CompleteOffTheRecordLogin(const GURL& start_url) {
    126   }
    127 
    128   virtual void SetFirstLoginPrefs(PrefService* prefs) {
    129   }
    130 
    131   virtual Authenticator* CreateAuthenticator(LoginStatusConsumer* consumer) {
    132     return new MockAuthenticator(
    133         consumer, expected_username_, expected_password_);
    134   }
    135 
    136   virtual void PrewarmAuthentication() {
    137   }
    138 
    139   virtual void FetchCookies(
    140       Profile* profile,
    141       const GaiaAuthConsumer::ClientLoginResult& credentials) {
    142   }
    143 
    144   virtual void FetchTokens(
    145       Profile* profile,
    146       const GaiaAuthConsumer::ClientLoginResult& credentials) {
    147   }
    148 
    149   void SetBackgroundView(BackgroundView* background_view) {
    150     background_view_ = background_view;
    151   }
    152 
    153   BackgroundView* GetBackgroundView() {
    154     return background_view_;
    155   }
    156 
    157   virtual std::string GetOffTheRecordCommandLine(
    158       const GURL& start_url,
    159       const CommandLine& base_command_line,
    160       CommandLine* command_line) {
    161     return std::string();
    162   }
    163 
    164  private:
    165   std::string expected_username_;
    166   std::string expected_password_;
    167   std::string auth_token_;
    168   chromeos::BackgroundView* background_view_;
    169 
    170   DISALLOW_COPY_AND_ASSIGN(MockLoginUtils);
    171 };
    172 
    173 }  // namespace chromeos
    174 
    175 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_MOCK_AUTHENTICATOR_H_
    176