Integrate AppNotifyChannelSetup with TokenService.

chrome/browser/extensions/app_notify_channel_setup_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.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/extensions/app_notify_channel_setup.h"
+#include "chrome/browser/extensions/app_notify_channel_ui.h"
+#include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/net/gaia/token_service_unittest.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
+using testing::_;
+using testing::Return;
 
 namespace {
 
 const int kRouteId = 4;
 const int kCallbackId = 5;
 const char* kFakeExtensionId = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 
+class MockTokenService : public TokenService {
+ public:
+  MockTokenService() { }
+  virtual ~MockTokenService() { }
+
+  bool AreCredentialsValid() const OVERRIDE {
+    return true;
+  }
+
+  MOCK_CONST_METHOD1(HasTokenForService, bool(const char*));
+};
+
+class TestProfile : public TestingProfile {
+ public:
+  TestProfile() : TestingProfile() { }
+  virtual ~TestProfile() { }
+
+  virtual TokenService* GetTokenService() OVERRIDE {
+    return &token_service_;
+  }
+
+  void SetTokenServiceHasTokenResult(bool result) {
+    EXPECT_CALL(token_service_, HasTokenForService(_))
+        .WillRepeatedly(Return(result));
+  }
+
+ private:
+  MockTokenService token_service_;
+};
+
 class TestDelegate : public AppNotifyChannelSetup::Delegate,
                      public base::SupportsWeakPtr<TestDelegate> {
  public:
   TestDelegate() : was_called_(false) {}
   virtual ~TestDelegate() {}
 
   virtual void AppNotifyChannelSetupComplete(
       const std::string& channel_id,
       const std::string& error,
       int route_id,
@@ skipping 82 matching lines @@
 
   virtual void SetLoggedInUser(const std::string username) {
     TestingPrefService* prefs = profile_.GetTestingPrefService();
     prefs->SetUserPref(prefs::kGoogleServicesUsername,
                        new StringValue(username));
   }
 
   virtual AppNotifyChannelSetup* CreateInstance() {
     GURL page_url("http://www.google.com");
     return new AppNotifyChannelSetup(&profile_,
-                                  kFakeExtensionId,
-                                  "1234",
-                                  page_url,
-                                  kRouteId,
-                                  kCallbackId,
-                                  ui_.release(),
-                                  delegate_.AsWeakPtr());
+                                     kFakeExtensionId,
+                                     "1234",
+                                     page_url,
+                                     kRouteId,
+                                     kCallbackId,
+                                     ui_.release(),
+                                     delegate_.AsWeakPtr());
   }
 
   virtual void SetupLogin(bool should_succeed) {
     if (should_succeed)
       SetLoggedInUser("user@gmail.com");
     else
       ui_->SetSyncSetupResult(false);
   }
 
+  virtual void SetupFetchTokens(bool should_have_tokens, bool should_succeed) {
+    profile_.SetTokenServiceHasTokenResult(should_have_tokens);
+    if (!should_have_tokens) {
+      factory_.SetFakeResponse(
+          GaiaUrls::GetInstance()->issue_auth_token_url(),
+          "some_token",
+          should_succeed);
+    }
+  }
+
   virtual void SetupRecordGrant(bool should_succeed) {
     factory_.SetFakeResponse(
         AppNotifyChannelSetup::GetOAuth2IssueTokenURL().spec(),
         "whatever",
         should_succeed);
   }
 
   virtual void SetupGetChannelId(bool should_succeed) {
     factory_.SetFakeResponse(
         AppNotifyChannelSetup::GetCWSChannelServiceURL().spec(),
         "{\"id\": \"dummy_do_not_use\"}",
         should_succeed);
   }
 
-
   virtual void RunServerTest(AppNotifyChannelSetup* setup,
                              const std::string& expected_code,
                              const std::string& expected_error) {
     setup->Start();
     message_loop_.Run();
     delegate_.ExpectWasCalled(expected_code, expected_error);
   }
 
  protected:
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
-  TestingProfile profile_;
+  TestProfile profile_;
   TestDelegate delegate_;
   scoped_ptr<TestUI> ui_;
   FakeURLFetcherFactory factory_;
 };
 
 TEST_F(AppNotifyChannelSetupTest, LoginFailure) {
-  // Set login to fail.
   SetupLogin(false);
 
   scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
   RunServerTest(setup, "", "canceled_by_user");
 }
 
-TEST_F(AppNotifyChannelSetupTest, RecordGrantFailure) {
+TEST_F(AppNotifyChannelSetupTest, FetchTokensFailure) {
   SetupLogin(true);
+  SetupFetchTokens(false, false);
+
+  scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
+  RunServerTest(setup, "", "internal_error");
+}
+
+TEST_F(AppNotifyChannelSetupTest, TokensAvailableRecordGrantFailure) {
+  SetupLogin(true);
+  SetupFetchTokens(true, false);
+  SetupRecordGrant(false);
+
+  scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
+  RunServerTest(setup, "", "internal_error");
+}
+
+TEST_F(AppNotifyChannelSetupTest, TokenFetchSuccessAndRecordGrantFailure) {
+  SetupLogin(true);
+  SetupFetchTokens(false , true);
   SetupRecordGrant(false);
 
   scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
   RunServerTest(setup, "", "internal_error");
 }
 
 TEST_F(AppNotifyChannelSetupTest, GetChannelIdFailure) {
   SetupLogin(true);
+  SetupFetchTokens(true, false);
   SetupRecordGrant(true);
   SetupGetChannelId(false);
 
   scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
   RunServerTest(setup, "", "internal_error");
 }
 
 TEST_F(AppNotifyChannelSetupTest, ServerSuccess) {
   SetupLogin(true);
+  SetupFetchTokens(true, false);
   SetupRecordGrant(true);
   SetupGetChannelId(true);
 
   scoped_refptr<AppNotifyChannelSetup> setup = CreateInstance();
   RunServerTest(setup, "dummy_do_not_use", "");
 }