chrome/browser/signin/fake_profile_oauth2_token_service.h

   1 // Copyright 2013 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_SIGNIN_FAKE_PROFILE_OAUTH2_TOKEN_SERVICE_H_
   6 #define CHROME_BROWSER_SIGNIN_FAKE_PROFILE_OAUTH2_TOKEN_SERVICE_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/weak_ptr.h"
  13
  14 #if defined(OS_ANDROID)
  15 #include "chrome/browser/signin/android_profile_oauth2_token_service.h"
  16 #else
  17 #include "components/signin/core/browser/profile_oauth2_token_service.h"
  18 #endif
  19
  20 // Helper class to simplify writing unittests that depend on an instance of
  21 // ProfileOAuth2TokenService.
  22 //
  23 // Tests would typically do something like the following:
  24 //
  25 // FakeProfileOAuth2TokenService service;
  26 // ...
  27 // service.IssueRefreshToken("token");  // Issue refresh token/notify observers
  28 // ...
  29 // // Confirm that there is at least one active request.
  30 // EXPECT_GT(0U, service.GetPendingRequests().size());
  31 // ...
  32 // // Make any pending token fetches for a given scope succeed.
  33 // ScopeSet scopes;
  34 // scopes.insert(GaiaConstants::kYourServiceScope);
  35 // IssueTokenForScope(scopes, "access_token", base::Time()::Max());
  36 // ...
  37 // // ...or make them fail...
  38 // IssueErrorForScope(scopes, GoogleServiceAuthError(INVALID_GAIA_CREDENTIALS));
  39 //
  40 class FakeProfileOAuth2TokenService
  41 #if defined(OS_ANDROID)
  42   : public AndroidProfileOAuth2TokenService {
  43 #else
  44   : public ProfileOAuth2TokenService {
  45 #endif
  46  public:
  47   struct PendingRequest {
  48     PendingRequest();
  49     ~PendingRequest();
  50
  51     std::string account_id;
  52     std::string client_id;
  53     std::string client_secret;
  54     ScopeSet scopes;
  55     base::WeakPtr<RequestImpl> request;
  56   };
  57
  58   FakeProfileOAuth2TokenService();
  59   virtual ~FakeProfileOAuth2TokenService();
  60
  61   // Overriden to make sure it works on Android.
  62   virtual bool RefreshTokenIsAvailable(
  63       const std::string& account_id) const OVERRIDE;
  64
  65   // Overriden to make sure it works on iOS.
  66   virtual void LoadCredentials(const std::string& primary_account_id) OVERRIDE;
  67
  68   virtual std::vector<std::string> GetAccounts() OVERRIDE;
  69
  70   // Overriden to make sure it works on Android.  Simply calls
  71   // IssueRefreshToken().
  72   virtual void UpdateCredentials(const std::string& account_id,
  73                                  const std::string& refresh_token) OVERRIDE;
  74
  75   // Sets the current refresh token. If |token| is non-empty, this will invoke
  76   // OnRefreshTokenAvailable() on all Observers, otherwise this will invoke
  77   // OnRefreshTokenRevoked().
  78   void IssueRefreshToken(const std::string& token);
  79
  80   // TODO(fgorski,rogerta): Merge with UpdateCredentials when this class fully
  81   // supports multiple accounts.
  82   void IssueRefreshTokenForUser(const std::string& account_id,
  83                                 const std::string& token);
  84
  85   // Gets a list of active requests (can be used by tests to validate that the
  86   // correct request has been issued).
  87   std::vector<PendingRequest> GetPendingRequests();
  88
  89   // Helper routines to issue tokens for pending requests.
  90   void IssueAllTokensForAccount(const std::string& account_id,
  91                                 const std::string& access_token,
  92                                 const base::Time& expiration);
  93
  94   void IssueTokenForScope(const ScopeSet& scopes,
  95                           const std::string& access_token,
  96                           const base::Time& expiration);
  97
  98   void IssueErrorForScope(const ScopeSet& scopes,
  99                           const GoogleServiceAuthError& error);
 100
 101   void IssueTokenForAllPendingRequests(const std::string& access_token,
 102                                        const base::Time& expiration);
 103
 104   void IssueErrorForAllPendingRequests(const GoogleServiceAuthError& error);
 105
 106   void set_auto_post_fetch_response_on_message_loop(bool auto_post_response) {
 107     auto_post_fetch_response_on_message_loop_ = auto_post_response;
 108   }
 109
 110  protected:
 111   // OAuth2TokenService overrides.
 112   virtual void FetchOAuth2Token(RequestImpl* request,
 113                                 const std::string& account_id,
 114                                 net::URLRequestContextGetter* getter,
 115                                 const std::string& client_id,
 116                                 const std::string& client_secret,
 117                                 const ScopeSet& scopes) OVERRIDE;
 118
 119   virtual OAuth2AccessTokenFetcher* CreateAccessTokenFetcher(
 120       const std::string& account_id,
 121       net::URLRequestContextGetter* getter,
 122       OAuth2AccessTokenConsumer* consumer) OVERRIDE;
 123
 124   virtual void InvalidateOAuth2Token(const std::string& account_id,
 125                                      const std::string& client_id,
 126                                      const ScopeSet& scopes,
 127                                      const std::string& access_token) OVERRIDE;
 128
 129   virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE;
 130
 131  private:
 132   // Helper function to complete pending requests - if |all_scopes| is true,
 133   // then all pending requests are completed, otherwise, only those requests
 134   // matching |scopes| are completed.  If |account_id| is empty, then pending
 135   // requests for all accounts are completed, otherwise only requests for the
 136   // given account.
 137   void CompleteRequests(const std::string& account_id,
 138                         bool all_scopes,
 139                         const ScopeSet& scopes,
 140                         const GoogleServiceAuthError& error,
 141                         const std::string& access_token,
 142                         const base::Time& expiration);
 143
 144   std::string GetRefreshToken(const std::string& account_id) const;
 145
 146   std::vector<PendingRequest> pending_requests_;
 147
 148   // Maps account ids to their refresh token strings.
 149   std::map<std::string, std::string> refresh_tokens_;
 150
 151   // If true, then this fake service will post responses to
 152   // |FetchOAuth2Token| on the current run loop. There is no need to call
 153   // |IssueTokenForScope| in this case.
 154   bool auto_post_fetch_response_on_message_loop_;
 155
 156   DISALLOW_COPY_AND_ASSIGN(FakeProfileOAuth2TokenService);
 157 };
 158
 159 #endif  // CHROME_BROWSER_SIGNIN_FAKE_PROFILE_OAUTH2_TOKEN_SERVICE_H_