Integrate OAuth2 login token generation into TokenService:

chrome/browser/net/gaia/token_service_unittest.cc

 // Copyright (c) 2011 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.
 //
 // This file defines a unit test for the profile's token service.
 
 #include "chrome/browser/net/gaia/token_service_unittest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 96 matching lines @@
   message_loop_.RunAllPending();
 }
 
 class TokenServiceTest : public TokenServiceTestHarness {
  public:
   virtual void SetUp() {
     TokenServiceTestHarness::SetUp();
     service_.UpdateCredentials(credentials_);
     service_.UpdateOAuthCredentials(oauth_token_, oauth_secret_);
   }
+ protected:
+  void TestLoadSingleToken(
+      std::map<std::string, std::string>* db_tokens,
+      std::map<std::string, std::string>* memory_tokens,
+      const std::string& service) {
+    std::string token = service + "_token";
+    (*db_tokens)[service] = token;
+    size_t prev_success_size = success_tracker_.size();
+    service_.LoadTokensIntoMemory(*db_tokens, memory_tokens);
+
+    // Check notification.
+    EXPECT_EQ(prev_success_size + 1, success_tracker_.size());
+    TokenService::TokenAvailableDetails details = success_tracker_.details();
+    EXPECT_EQ(details.service(), service);
+    EXPECT_EQ(details.token(), token);
+    // Check memory tokens.
+    EXPECT_EQ(1U, memory_tokens->count(service));
+    EXPECT_EQ((*memory_tokens)[service], token);
+  }
 };
 
 TEST_F(TokenServiceTest, SanityCheck) {
   EXPECT_TRUE(service_.HasLsid());
   EXPECT_EQ(service_.GetLsid(), "lsid");
   EXPECT_FALSE(service_.HasTokenForService("nonexistent service"));
   EXPECT_TRUE(service_.HasOAuthCredentials());
   EXPECT_EQ(service_.GetOAuthToken(), "oauth");
   EXPECT_EQ(service_.GetOAuthSecret(), "secret");
 }
 
 TEST_F(TokenServiceTest, NoToken) {
   EXPECT_FALSE(service_.HasTokenForService("nonexistent service"));
   EXPECT_EQ(service_.GetTokenForService("nonexistent service"), std::string());
 }
 
 TEST_F(TokenServiceTest, NotificationSuccess) {
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
   service_.OnIssueAuthTokenSuccess(GaiaConstants::kSyncService, "token");
   EXPECT_EQ(1U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
 
   TokenService::TokenAvailableDetails details = success_tracker_.details();
   // MSVC doesn't like this comparison as EQ.
   EXPECT_TRUE(details.service() == GaiaConstants::kSyncService);
   EXPECT_EQ(details.token(), "token");
 }
 
+TEST_F(TokenServiceTest, NotificationOAuthLoginTokenSuccess) {
+  EXPECT_EQ(0U, success_tracker_.size());
+  EXPECT_EQ(0U, failure_tracker_.size());
+  service_.OnOAuthLoginTokenSuccess("rt1", "at1", 3600);
+  EXPECT_EQ(1U, success_tracker_.size());
+  EXPECT_EQ(0U, failure_tracker_.size());
+
+  TokenService::TokenAvailableDetails details = success_tracker_.details();
+  // MSVC doesn't like this comparison as EQ.
+  EXPECT_TRUE(details.service() ==
+      GaiaConstants::kGaiaOAuth2LoginRefreshToken);
+  EXPECT_EQ(details.token(), "rt1");
+}
+
 TEST_F(TokenServiceTest, NotificationSuccessOAuth) {
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
   service_.OnOAuthWrapBridgeSuccess(
       GaiaConstants::kSyncServiceOAuth, "token", "3600");
   EXPECT_EQ(1U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
 
   TokenService::TokenAvailableDetails details = success_tracker_.details();
   // MSVC doesn't like this comparison as EQ.
   EXPECT_TRUE(details.service() == GaiaConstants::kSyncServiceOAuth);
   EXPECT_EQ(details.token(), "token");
 }
 
 TEST_F(TokenServiceTest, NotificationFailed) {
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
   GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
   service_.OnIssueAuthTokenFailure(GaiaConstants::kSyncService, error);
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(1U, failure_tracker_.size());
 
   TokenService::TokenRequestFailedDetails details = failure_tracker_.details();
 
   // MSVC doesn't like this comparison as EQ.
   EXPECT_TRUE(details.service() == GaiaConstants::kSyncService);
   EXPECT_TRUE(details.error() == error);  // Struct has no print function.
 }
 
+TEST_F(TokenServiceTest, NotificationOAuthLoginTokenFailed) {
+  EXPECT_EQ(0U, success_tracker_.size());
+  EXPECT_EQ(0U, failure_tracker_.size());
+  GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
+  service_.OnOAuthLoginTokenFailure(error);
+  EXPECT_EQ(0U, success_tracker_.size());
+  EXPECT_EQ(1U, failure_tracker_.size());
+
+  TokenService::TokenRequestFailedDetails details = failure_tracker_.details();
+
+  // MSVC doesn't like this comparison as EQ.
+  EXPECT_TRUE(details.service() ==
+      GaiaConstants::kGaiaOAuth2LoginRefreshToken);
+  EXPECT_TRUE(details.error() == error);  // Struct has no print function.
+}
+
 TEST_F(TokenServiceTest, NotificationFailedOAuth) {
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(0U, failure_tracker_.size());
   GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
   service_.OnOAuthWrapBridgeFailure(GaiaConstants::kSyncServiceOAuth, error);
   EXPECT_EQ(0U, success_tracker_.size());
   EXPECT_EQ(1U, failure_tracker_.size());
 
   TokenService::TokenRequestFailedDetails details = failure_tracker_.details();
 
   // MSVC doesn't like this comparison as EQ.
   EXPECT_TRUE(details.service() == GaiaConstants::kSyncServiceOAuth);
   EXPECT_TRUE(details.error() == error);  // Struct has no print function.
 }
 
 TEST_F(TokenServiceTest, OnTokenSuccessUpdate) {
   service_.OnIssueAuthTokenSuccess(GaiaConstants::kSyncService, "token");
   EXPECT_TRUE(service_.HasTokenForService(GaiaConstants::kSyncService));
   EXPECT_EQ(service_.GetTokenForService(GaiaConstants::kSyncService), "token");
 
   service_.OnIssueAuthTokenSuccess(GaiaConstants::kSyncService, "token2");
   EXPECT_TRUE(service_.HasTokenForService(GaiaConstants::kSyncService));
   EXPECT_EQ(service_.GetTokenForService(GaiaConstants::kSyncService), "token2");
 
   service_.OnIssueAuthTokenSuccess(GaiaConstants::kSyncService, "");
   EXPECT_TRUE(service_.HasTokenForService(GaiaConstants::kSyncService));
   EXPECT_EQ(service_.GetTokenForService(GaiaConstants::kSyncService), "");
 }
 
+TEST_F(TokenServiceTest, OnOAuth2LoginTokenSuccessUpdate) {
+  std::string service = GaiaConstants::kGaiaOAuth2LoginRefreshToken;
+  service_.OnOAuthLoginTokenSuccess("rt1", "at1", 3600);
+  EXPECT_TRUE(service_.HasOAuthLoginToken());
+  EXPECT_EQ(service_.GetOAuth2LoginRefreshToken(), "rt1");
+
+  service_.OnOAuthLoginTokenSuccess("rt2", "at2", 3600);
+  EXPECT_TRUE(service_.HasOAuthLoginToken());
+  EXPECT_EQ(service_.GetOAuth2LoginRefreshToken(), "rt2");
+
+  service_.OnOAuthLoginTokenSuccess("rt3", "at3", 3600);
+  EXPECT_TRUE(service_.HasOAuthLoginToken());
+  EXPECT_EQ(service_.GetOAuth2LoginRefreshToken(), "rt3");
+}
+
 TEST_F(TokenServiceTest, OnTokenSuccess) {
   // Don't "start fetching", just go ahead and issue the callback.
   service_.OnIssueAuthTokenSuccess(GaiaConstants::kSyncService, "token");
   EXPECT_TRUE(service_.HasTokenForService(GaiaConstants::kSyncService));
   EXPECT_FALSE(service_.HasTokenForService(GaiaConstants::kSyncServiceOAuth));
   EXPECT_FALSE(service_.HasTokenForService(GaiaConstants::kTalkService));
   // Gaia returns the entire result as the token so while this is a shared
   // result with ClientLogin, it doesn't matter, we should still get it back.
   EXPECT_EQ(service_.GetTokenForService(GaiaConstants::kSyncService), "token");
 
@@ skipping 156 matching lines @@
 TEST_F(TokenServiceTest, LoadTokensIntoMemoryBasic) {
   // Validate that the method sets proper data in notifications and map.
   std::map<std::string, std::string> db_tokens;
   std::map<std::string, std::string> memory_tokens;
 
   service_.LoadTokensIntoMemory(db_tokens, &memory_tokens);
   EXPECT_TRUE(db_tokens.empty());
   EXPECT_TRUE(memory_tokens.empty());
   EXPECT_EQ(0U, success_tracker_.size());
 
-  db_tokens[GaiaConstants::kSyncServiceOAuth] = "token";
-  service_.LoadTokensIntoMemory(db_tokens, &memory_tokens);
-  EXPECT_EQ(1U, success_tracker_.size());
-
-  TokenService::TokenAvailableDetails details = success_tracker_.details();
-  // MSVC doesn't like this comparison as EQ.
-  EXPECT_TRUE(details.service() == GaiaConstants::kSyncServiceOAuth);
-  EXPECT_EQ(details.token(), "token");
-  EXPECT_EQ(1U, memory_tokens.count(GaiaConstants::kSyncServiceOAuth));
-  EXPECT_EQ(memory_tokens[GaiaConstants::kSyncServiceOAuth], "token");
+  std::string service;
+  std::string token;
+  for (int i = 0; i < TokenService::kNumServices; ++i) {
+    service = TokenService::kServices[i];
+    TestLoadSingleToken(&db_tokens, &memory_tokens, service);
+  }
+  for (int i = 0; i < TokenService::kNumOAuthServices; ++i) {
+    service = TokenService::kOAuthServices[i];
+    TestLoadSingleToken(&db_tokens, &memory_tokens, service);
+  }
+  service = GaiaConstants::kGaiaOAuth2LoginRefreshToken;
+  TestLoadSingleToken(&db_tokens, &memory_tokens, service);
+  service = GaiaConstants::kGaiaOAuth2LoginAccessToken;
+  TestLoadSingleToken(&db_tokens, &memory_tokens, service);
 }
 
 TEST_F(TokenServiceTest, LoadTokensIntoMemoryAdvanced) {
   // LoadTokensIntoMemory should avoid setting tokens already in the
   // token map.
   std::map<std::string, std::string> db_tokens;
   std::map<std::string, std::string> memory_tokens;
 
   db_tokens["ignore"] = "token";
 
@@ skipping 109 matching lines @@
 
     *CommandLine::ForCurrentProcess() = original_cl;
   }
 };
 
 TEST_F(TokenServiceCommandLineTest, TestValueOverride) {
   EXPECT_TRUE(service_.HasTokenForService("my_service"));
   EXPECT_EQ("my_value", service_.GetTokenForService("my_service"));
 }
 #endif   // ifndef NDEBUG