chrome/browser/local_discovery/privet_confirm_api_flow_unittest.cc

   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 #include "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "chrome/browser/local_discovery/privet_confirm_api_flow.h"
   8 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
   9 #include "content/public/test/test_browser_thread.h"
  10 #include "google_apis/gaia/google_service_auth_error.h"
  11 #include "net/base/host_port_pair.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/http/http_request_headers.h"
  14 #include "net/url_request/test_url_fetcher_factory.h"
  15 #include "net/url_request/url_request_test_util.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 using testing::NiceMock;
  20
  21 namespace local_discovery {
  22
  23 namespace {
  24
  25 const char kSampleConfirmResponse[] = "{"
  26     "   \"success\": true"
  27     "}";
  28
  29 const char kFailedConfirmResponse[] = "{"
  30     "   \"success\": false"
  31     "}";
  32
  33 const char kFailedConfirmResponseBadJson[] = "["
  34     "   \"success\""
  35     "]";
  36
  37 const char kAccountId[] = "account_id";
  38
  39 class TestOAuth2TokenService : public OAuth2TokenService {
  40  public:
  41   explicit TestOAuth2TokenService(net::URLRequestContextGetter* request_context)
  42       : request_context_(request_context) {
  43   }
  44  protected:
  45   virtual std::string GetRefreshToken(const std::string& account_id) OVERRIDE {
  46     return "SampleToken";
  47   }
  48
  49   virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE {
  50     return request_context_.get();
  51   }
  52
  53  private:
  54   scoped_refptr<net::URLRequestContextGetter> request_context_;
  55 };
  56
  57 class MockableConfirmCallback {
  58  public:
  59   MOCK_METHOD1(ConfirmCallback, void(CloudPrintBaseApiFlow::Status));
  60
  61   PrivetConfirmApiCallFlow::ResponseCallback callback() {
  62     return base::Bind(&MockableConfirmCallback::ConfirmCallback,
  63                       base::Unretained(this));
  64   }
  65 };
  66
  67 class PrivetConfirmApiFlowTest : public testing::Test {
  68  public:
  69   PrivetConfirmApiFlowTest()
  70       : ui_thread_(content::BrowserThread::UI,
  71                    &loop_),
  72         request_context_(new net::TestURLRequestContextGetter(
  73             base::MessageLoopProxy::current())),
  74         token_service_(request_context_.get()),
  75         account_id_(kAccountId) {
  76     ui_thread_.Stop();  // HACK: Fake being on the UI thread
  77   }
  78
  79   virtual ~PrivetConfirmApiFlowTest() {
  80   }
  81
  82  protected:
  83   base::MessageLoopForUI loop_;
  84   content::TestBrowserThread ui_thread_;
  85   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
  86   net::TestURLFetcherFactory fetcher_factory_;
  87   TestOAuth2TokenService token_service_;
  88   MockableConfirmCallback callback_;
  89   std::string account_id_;
  90 };
  91
  92 TEST_F(PrivetConfirmApiFlowTest, SuccessOAuth2) {
  93   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
  94                                         &token_service_,
  95                                         account_id_,
  96                                         GURL("http://SoMeUrL.com"),
  97                                         callback_.callback());
  98   CloudPrintBaseApiFlow* cloudprint_flow =
  99       confirm_flow.GetBaseApiFlowForTests();
 100
 101   confirm_flow.Start();
 102
 103   cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
 104   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 105
 106   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 107
 108   net::HttpRequestHeaders headers;
 109   fetcher->GetExtraRequestHeaders(&headers);
 110   std::string oauth_header;
 111   std::string proxy;
 112   EXPECT_TRUE(headers.GetHeader("Authorization", &oauth_header));
 113   EXPECT_EQ("Bearer SomeToken", oauth_header);
 114   EXPECT_TRUE(headers.GetHeader("X-Cloudprint-Proxy", &proxy));
 115   EXPECT_EQ("Chrome", proxy);
 116
 117   fetcher->SetResponseString(kSampleConfirmResponse);
 118   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 119                                             net::OK));
 120   fetcher->set_response_code(200);
 121
 122   EXPECT_CALL(callback_, ConfirmCallback(CloudPrintBaseApiFlow::SUCCESS));
 123
 124   fetcher->delegate()->OnURLFetchComplete(fetcher);
 125 }
 126
 127 TEST_F(PrivetConfirmApiFlowTest, SuccessCookies) {
 128   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
 129                                         1,
 130                                         "SomeToken",
 131                                         GURL("http://SoMeUrL.com?token=tkn"),
 132                                         callback_.callback());
 133
 134   confirm_flow.Start();
 135
 136   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 137
 138   EXPECT_EQ(GURL("http://SoMeUrL.com?token=tkn&xsrf=SomeToken&user=1"),
 139             fetcher->GetOriginalURL());
 140
 141   net::HttpRequestHeaders headers;
 142   fetcher->GetExtraRequestHeaders(&headers);
 143   std::string proxy;
 144   EXPECT_TRUE(headers.GetHeader("X-Cloudprint-Proxy", &proxy));
 145   EXPECT_EQ("Chrome", proxy);
 146
 147   fetcher->SetResponseString(kSampleConfirmResponse);
 148   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 149                                             net::OK));
 150   fetcher->set_response_code(200);
 151
 152   EXPECT_CALL(callback_, ConfirmCallback(CloudPrintBaseApiFlow::SUCCESS));
 153
 154   fetcher->delegate()->OnURLFetchComplete(fetcher);
 155 }
 156
 157 TEST_F(PrivetConfirmApiFlowTest, BadToken) {
 158   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
 159                                         &token_service_,
 160                                         account_id_,
 161                                         GURL("http://SoMeUrL.com"),
 162                                         callback_.callback());
 163
 164   confirm_flow.Start();
 165
 166   CloudPrintBaseApiFlow* cloudprint_flow =
 167       confirm_flow.GetBaseApiFlowForTests();
 168
 169   EXPECT_CALL(callback_,
 170               ConfirmCallback(CloudPrintBaseApiFlow::ERROR_TOKEN));
 171   cloudprint_flow->OnGetTokenFailure(NULL, GoogleServiceAuthError(
 172       GoogleServiceAuthError::USER_NOT_SIGNED_UP));
 173 }
 174
 175 TEST_F(PrivetConfirmApiFlowTest, ServerFailure) {
 176   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
 177                                         &token_service_,
 178                                         account_id_,
 179                                         GURL("http://SoMeUrL.com"),
 180                                         callback_.callback());
 181
 182   confirm_flow.Start();
 183
 184   CloudPrintBaseApiFlow* cloudprint_flow =
 185       confirm_flow.GetBaseApiFlowForTests();
 186
 187   cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
 188   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 189
 190   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 191
 192   fetcher->SetResponseString(kFailedConfirmResponse);
 193   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 194                                             net::OK));
 195   fetcher->set_response_code(200);
 196
 197   EXPECT_CALL(callback_,
 198               ConfirmCallback(CloudPrintBaseApiFlow::ERROR_FROM_SERVER));
 199
 200   fetcher->delegate()->OnURLFetchComplete(fetcher);
 201 }
 202
 203 TEST_F(PrivetConfirmApiFlowTest, BadJson) {
 204   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
 205                                         &token_service_,
 206                                         account_id_,
 207                                         GURL("http://SoMeUrL.com"),
 208                                         callback_.callback());
 209
 210   confirm_flow.Start();
 211
 212   CloudPrintBaseApiFlow* cloudprint_flow =
 213       confirm_flow.GetBaseApiFlowForTests();
 214
 215   cloudprint_flow->OnGetTokenSuccess(NULL, "SomeToken", base::Time());
 216   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 217
 218   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 219
 220   fetcher->SetResponseString(kFailedConfirmResponseBadJson);
 221   fetcher->set_status(net::URLRequestStatus(
 222       net::URLRequestStatus::SUCCESS,
 223       net::OK));
 224   fetcher->set_response_code(200);
 225
 226   EXPECT_CALL(callback_, ConfirmCallback
 227               (CloudPrintBaseApiFlow::ERROR_MALFORMED_RESPONSE));
 228
 229   fetcher->delegate()->OnURLFetchComplete(fetcher);
 230 }
 231
 232 }  // namespace
 233
 234 }  // namespace local_discovery