Support chrome_to_mobile job receiving

chrome/browser/chrome_to_mobile/common/cloud_print_request_impl_unittest.cc

+// Copyright 2012 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 <set>
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
+#include "base/time.h"
+#include "chrome/browser/chrome_to_mobile/common/cloud_print_request.h"
+#include "chrome/browser/chrome_to_mobile/common/cloud_print_request_impl.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
+#include "content/public/test/test_browser_thread.h"
+#include "googleurl/src/gurl.h"
+#include "google_apis/gaia/gaia_constants.h"
+#include "google_apis/gaia/google_service_auth_error.h"
+#include "google_apis/gaia/oauth2_access_token_consumer.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using namespace chrome_to_mobile;
+
+namespace {
+
+class MockOAuth2TokenService : public OAuth2TokenService {
+ public:
+  explicit MockOAuth2TokenService(net::URLRequestContextGetter* getter);
+  virtual ~MockOAuth2TokenService();
+
+  virtual Request* StartRequest(const std::vector<std::string>& scopes,
+                                OAuth2AccessTokenConsumer* consumer) OVERRIDE;
+  // Helper to set if oauth2 token fetch should be successful.
+  void SetSucceed(bool succeed);
+
+ private:
+  bool succeed_;
+};
+
+MockOAuth2TokenService::MockOAuth2TokenService(
+    net::URLRequestContextGetter* getter) : succeed_(true) {
+}
+
+MockOAuth2TokenService::~MockOAuth2TokenService() {
+}
+
+OAuth2TokenService::Request* MockOAuth2TokenService::StartRequest(
+    const std::vector<std::string>& scopes,
+    OAuth2AccessTokenConsumer* consumer) {
+  if (succeed_) {
+    base::Time expiration_time;
+    consumer->OnGetTokenSuccess(std::string("acces token"), expiration_time);
+  } else {
+    consumer->OnGetTokenFailure(GoogleServiceAuthError(
+        GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS));
+  }
+  return NULL;
+}
+
+void MockOAuth2TokenService::SetSucceed(bool succeed) {
+  succeed_ = succeed;
+}
+
+class MockCloudPrintRequestDelegate : public CloudPrintRequest::Delegate {
+ public:
+  MockCloudPrintRequestDelegate();
+  virtual ~MockCloudPrintRequestDelegate();
+
+  virtual void OnRequestComplete(CloudPrintRequest* source) OVERRIDE;
+
+  const std::set<CloudPrintRequest*>* GetCompletedRequests() const;
+
+ private:
+  std::set<CloudPrintRequest*> requests_;
+};
+
+MockCloudPrintRequestDelegate::MockCloudPrintRequestDelegate() {
+}
+
+MockCloudPrintRequestDelegate::~MockCloudPrintRequestDelegate() {
+}
+
+void MockCloudPrintRequestDelegate::OnRequestComplete(
+    CloudPrintRequest* source) {
+  requests_.insert(source);
+}
+
+const std::set<CloudPrintRequest*>* MockCloudPrintRequestDelegate::
+    GetCompletedRequests() const {
+  return &requests_;
+}
+
+}  // namespace
+
+class CloudPrintRequestImplTest :  public testing::Test {
+ public:
+  CloudPrintRequestImplTest();
+  virtual ~CloudPrintRequestImplTest();
+
+  virtual void SetUp() OVERRIDE;
+
+ protected:
+  MessageLoop test_loop_;
+  scoped_ptr<content::TestBrowserThread> test_thread_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  scoped_ptr<MockOAuth2TokenService> mock_oauth2_token_service_;
+  scoped_ptr<MockCloudPrintRequestDelegate> delegate_;
+  net::TestURLFetcherFactory factory_;
+  scoped_ptr<CloudPrintRequestImpl> request_;
+};
+
+CloudPrintRequestImplTest::CloudPrintRequestImplTest() {
+}
+
+CloudPrintRequestImplTest::~CloudPrintRequestImplTest() {
+}
+
+void CloudPrintRequestImplTest::SetUp() {
+  testing::Test::SetUp();
+
+  test_thread_.reset(new content::TestBrowserThread(content::BrowserThread::UI,
+                                                    &test_loop_));
+  request_context_getter_ = new TestURLRequestContextGetter(
+      test_loop_.message_loop_proxy());
+  mock_oauth2_token_service_.reset(new MockOAuth2TokenService(
+      request_context_getter_));
+  delegate_.reset(new MockCloudPrintRequestDelegate());
+
+  CloudPrintRequest::Settings settings;
+  settings.cloud_print_client_id = std::string("client id");
+  settings.request_context_getter = request_context_getter_;
+  settings.oauth2_token_service = mock_oauth2_token_service_.get();
+  request_.reset(new CloudPrintRequestImpl(GURL("http://www.test.test.test"),
+                                           std::string(""),
+                                           net::URLFetcher::GET,
+                                           std::string(""),
+                                           std::string(""),
+                                           settings,
+                                           delegate_.get()));
+}
+
+TEST_F(CloudPrintRequestImplTest,
+       Success) {
+  request_->Start();
+  EXPECT_EQ(0U, delegate_->GetCompletedRequests()->size());
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  EXPECT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  fetcher->SetResponseString("test test test");
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  bool succeed;
+  EXPECT_EQ(1U, delegate_->GetCompletedRequests()->size());
+  EXPECT_TRUE(delegate_->GetCompletedRequests()->find(request_.get()) !=
+              delegate_->GetCompletedRequests()->end());
+  EXPECT_FALSE(request_->HasOAuth2AccessTokenFailure());
+  EXPECT_FALSE(request_->HasCloudPrintAuthError());
+  EXPECT_STREQ("test test test", request_->GetResponseData(&succeed).c_str());
+  EXPECT_TRUE(succeed);
+}
+
+TEST_F(CloudPrintRequestImplTest,
+       OAuth2Error) {
+  mock_oauth2_token_service_->SetSucceed(false);
+  request_->Start();
+
+  EXPECT_EQ(1U, delegate_->GetCompletedRequests()->size());
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  EXPECT_FALSE(fetcher);
+
+  bool succeed;
+  EXPECT_EQ(1U, delegate_->GetCompletedRequests()->size());
+  EXPECT_TRUE(delegate_->GetCompletedRequests()->find(request_.get()) !=
+              delegate_->GetCompletedRequests()->end());
+  EXPECT_TRUE(request_->HasOAuth2AccessTokenFailure());
+  EXPECT_FALSE(request_->HasCloudPrintAuthError());
+  EXPECT_STREQ("", request_->GetResponseData(&succeed).c_str());
+  EXPECT_FALSE(succeed);
+}
+
+TEST_F(CloudPrintRequestImplTest,
+       CloudPrintAuthError) {
+  request_->Start();
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  EXPECT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_FORBIDDEN);
+  fetcher->SetResponseString("");
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  bool succeed;
+  EXPECT_EQ(1U, delegate_->GetCompletedRequests()->size());
+  EXPECT_TRUE(delegate_->GetCompletedRequests()->find(request_.get()) !=
+              delegate_->GetCompletedRequests()->end());
+  EXPECT_FALSE(request_->HasOAuth2AccessTokenFailure());
+  EXPECT_TRUE(request_->HasCloudPrintAuthError());
+  EXPECT_STREQ("", request_->GetResponseData(&succeed).c_str());
+  EXPECT_FALSE(succeed);
+}