google_apis/gaia/gaia_oauth_client_unittest.cc

   1 // Copyright (c) 2012 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 // A complete set of unit tests for GaiaOAuthClient.
   6
   7 #include <string>
   8
   9 #include "base/message_loop.h"
  10 #include "base/string_number_conversions.h"
  11 #include "base/string_util.h"
  12 #include "chrome/test/base/testing_profile.h"
  13 #include "google_apis/gaia/gaia_oauth_client.h"
  14 #include "googleurl/src/gurl.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/http/http_status_code.h"
  17 #include "net/url_request/test_url_fetcher_factory.h"
  18 #include "net/url_request/url_fetcher_delegate.h"
  19 #include "net/url_request/url_request_status.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using ::testing::_;
  24
  25 namespace {
  26 // Responds as though OAuth returned from the server.
  27 class MockOAuthFetcher : public net::TestURLFetcher {
  28  public:
  29   MockOAuthFetcher(int response_code,
  30                    int max_failure_count,
  31                    const GURL& url,
  32                    const std::string& results,
  33                    net::URLFetcher::RequestType request_type,
  34                    net::URLFetcherDelegate* d)
  35       : net::TestURLFetcher(0, url, d),
  36         max_failure_count_(max_failure_count),
  37         current_failure_count_(0) {
  38     set_url(url);
  39     set_response_code(response_code);
  40     SetResponseString(results);
  41   }
  42
  43   virtual ~MockOAuthFetcher() { }
  44
  45   virtual void Start() {
  46     if ((GetResponseCode() != net::HTTP_OK) && (max_failure_count_ != -1) &&
  47         (current_failure_count_ == max_failure_count_)) {
  48       set_response_code(net::HTTP_OK);
  49     }
  50
  51     net::URLRequestStatus::Status code = net::URLRequestStatus::SUCCESS;
  52     if (GetResponseCode() != net::HTTP_OK) {
  53       code = net::URLRequestStatus::FAILED;
  54       current_failure_count_++;
  55     }
  56     set_status(net::URLRequestStatus(code, 0));
  57
  58     delegate()->OnURLFetchComplete(this);
  59   }
  60
  61  private:
  62   int max_failure_count_;
  63   int current_failure_count_;
  64   DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcher);
  65 };
  66
  67 class MockOAuthFetcherFactory : public net::URLFetcherFactory,
  68                                 public net::ScopedURLFetcherFactory {
  69  public:
  70   MockOAuthFetcherFactory()
  71       : net::ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
  72         response_code_(net::HTTP_OK) {
  73   }
  74   ~MockOAuthFetcherFactory() {}
  75   virtual net::URLFetcher* CreateURLFetcher(
  76       int id,
  77       const GURL& url,
  78       net::URLFetcher::RequestType request_type,
  79       net::URLFetcherDelegate* d) {
  80     return new MockOAuthFetcher(
  81         response_code_,
  82         max_failure_count_,
  83         url,
  84         results_,
  85         request_type,
  86         d);
  87   }
  88   void set_response_code(int response_code) {
  89     response_code_ = response_code;
  90   }
  91   void set_max_failure_count(int count) {
  92     max_failure_count_ = count;
  93   }
  94   void set_results(const std::string& results) {
  95     results_ = results;
  96   }
  97  private:
  98   int response_code_;
  99   int max_failure_count_;
 100   std::string results_;
 101   DISALLOW_COPY_AND_ASSIGN(MockOAuthFetcherFactory);
 102 };
 103
 104 const std::string kTestAccessToken = "1/fFAGRNJru1FTz70BzhT3Zg";
 105 const std::string kTestRefreshToken =
 106     "1/6BMfW9j53gdGImsixUH6kU5RsR4zwI9lUVX-tqf8JXQ";
 107 const std::string kTestUserEmail = "a_user@gmail.com";
 108 const int kTestExpiresIn = 3920;
 109
 110 const std::string kDummyGetTokensResult =
 111   "{\"access_token\":\"" + kTestAccessToken + "\","
 112   "\"expires_in\":" + base::IntToString(kTestExpiresIn) + ","
 113   "\"refresh_token\":\"" + kTestRefreshToken + "\"}";
 114
 115 const std::string kDummyRefreshTokenResult =
 116   "{\"access_token\":\"" + kTestAccessToken + "\","
 117   "\"expires_in\":" + base::IntToString(kTestExpiresIn) + "}";
 118
 119 const std::string kDummyUserInfoResult =
 120   "{\"email\":\"" + kTestUserEmail + "\"}";
 121 }
 122
 123 namespace gaia {
 124
 125 class GaiaOAuthClientTest : public testing::Test {
 126  public:
 127   GaiaOAuthClientTest() {}
 128
 129   TestingProfile profile_;
 130  protected:
 131   MessageLoop message_loop_;
 132 };
 133
 134 class MockGaiaOAuthClientDelegate : public gaia::GaiaOAuthClient::Delegate {
 135  public:
 136   MockGaiaOAuthClientDelegate() {}
 137   ~MockGaiaOAuthClientDelegate() {}
 138
 139   MOCK_METHOD3(OnGetTokensResponse, void(const std::string& refresh_token,
 140                                          const std::string& access_token,
 141                                          int expires_in_seconds));
 142   MOCK_METHOD2(OnRefreshTokenResponse, void(const std::string& access_token,
 143                                             int expires_in_seconds));
 144   MOCK_METHOD1(OnGetUserInfoResponse, void(const std::string& user_email));
 145   MOCK_METHOD0(OnOAuthError, void());
 146   MOCK_METHOD1(OnNetworkError, void(int response_code));
 147 };
 148
 149 TEST_F(GaiaOAuthClientTest, NetworkFailure) {
 150   int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
 151
 152   MockGaiaOAuthClientDelegate delegate;
 153   EXPECT_CALL(delegate, OnNetworkError(response_code))
 154       .Times(1);
 155
 156   TestingProfile profile;
 157
 158   MockOAuthFetcherFactory factory;
 159   factory.set_response_code(response_code);
 160   factory.set_max_failure_count(4);
 161
 162   OAuthClientInfo client_info;
 163   client_info.client_id = "test_client_id";
 164   client_info.client_secret = "test_client_secret";
 165   client_info.redirect_uri = "test_redirect_uri";
 166   GaiaOAuthClient auth(kGaiaOAuth2Url,
 167                        profile_.GetRequestContext());
 168   auth.GetTokensFromAuthCode(client_info, "auth_code", 2, &delegate);
 169 }
 170
 171 TEST_F(GaiaOAuthClientTest, NetworkFailureRecover) {
 172   int response_code = net::HTTP_INTERNAL_SERVER_ERROR;
 173
 174   MockGaiaOAuthClientDelegate delegate;
 175   EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
 176       kTestExpiresIn)).Times(1);
 177
 178   TestingProfile profile;
 179
 180   MockOAuthFetcherFactory factory;
 181   factory.set_response_code(response_code);
 182   factory.set_max_failure_count(4);
 183   factory.set_results(kDummyGetTokensResult);
 184
 185   OAuthClientInfo client_info;
 186   client_info.client_id = "test_client_id";
 187   client_info.client_secret = "test_client_secret";
 188   client_info.redirect_uri = "test_redirect_uri";
 189   GaiaOAuthClient auth(kGaiaOAuth2Url,
 190                        profile_.GetRequestContext());
 191   auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
 192 }
 193
 194 TEST_F(GaiaOAuthClientTest, OAuthFailure) {
 195   int response_code = net::HTTP_BAD_REQUEST;
 196
 197   MockGaiaOAuthClientDelegate delegate;
 198   EXPECT_CALL(delegate, OnOAuthError()).Times(1);
 199
 200   TestingProfile profile;
 201
 202   MockOAuthFetcherFactory factory;
 203   factory.set_response_code(response_code);
 204   factory.set_max_failure_count(-1);
 205   factory.set_results(kDummyGetTokensResult);
 206
 207   OAuthClientInfo client_info;
 208   client_info.client_id = "test_client_id";
 209   client_info.client_secret = "test_client_secret";
 210   client_info.redirect_uri = "test_redirect_uri";
 211   GaiaOAuthClient auth(kGaiaOAuth2Url,
 212                        profile_.GetRequestContext());
 213   auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
 214 }
 215
 216
 217 TEST_F(GaiaOAuthClientTest, GetTokensSuccess) {
 218   MockGaiaOAuthClientDelegate delegate;
 219   EXPECT_CALL(delegate, OnGetTokensResponse(kTestRefreshToken, kTestAccessToken,
 220       kTestExpiresIn)).Times(1);
 221
 222   TestingProfile profile;
 223
 224   MockOAuthFetcherFactory factory;
 225   factory.set_results(kDummyGetTokensResult);
 226
 227   OAuthClientInfo client_info;
 228   client_info.client_id = "test_client_id";
 229   client_info.client_secret = "test_client_secret";
 230   client_info.redirect_uri = "test_redirect_uri";
 231   GaiaOAuthClient auth(kGaiaOAuth2Url,
 232                        profile_.GetRequestContext());
 233   auth.GetTokensFromAuthCode(client_info, "auth_code", -1, &delegate);
 234 }
 235
 236 TEST_F(GaiaOAuthClientTest, RefreshTokenSuccess) {
 237   MockGaiaOAuthClientDelegate delegate;
 238   EXPECT_CALL(delegate, OnRefreshTokenResponse(kTestAccessToken,
 239       kTestExpiresIn)).Times(1);
 240
 241   TestingProfile profile;
 242
 243   MockOAuthFetcherFactory factory;
 244   factory.set_results(kDummyRefreshTokenResult);
 245
 246   OAuthClientInfo client_info;
 247   client_info.client_id = "test_client_id";
 248   client_info.client_secret = "test_client_secret";
 249   client_info.redirect_uri = "test_redirect_uri";
 250   GaiaOAuthClient auth(kGaiaOAuth2Url,
 251                        profile_.GetRequestContext());
 252   auth.RefreshToken(client_info, "refresh_token", -1, &delegate);
 253 }
 254
 255 TEST_F(GaiaOAuthClientTest, GetUserInfo) {
 256   MockGaiaOAuthClientDelegate delegate;
 257   EXPECT_CALL(delegate, OnGetUserInfoResponse(kTestUserEmail)).Times(1);
 258
 259   TestingProfile profile;
 260
 261   MockOAuthFetcherFactory factory;
 262   factory.set_results(kDummyUserInfoResult);
 263
 264   OAuthClientInfo client_info;
 265   client_info.client_id = "test_client_id";
 266   client_info.client_secret = "test_client_secret";
 267   client_info.redirect_uri = "test_redirect_uri";
 268   GaiaOAuthClient auth(kGaiaOAuth2Url,
 269                        profile_.GetRequestContext());
 270   auth.GetUserInfo("access_token", 1, &delegate);
 271 }
 272
 273 }  // namespace gaia