google_apis/gcm/engine/registration_request_unittest.cc

   1 // Copyright 2014 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 <map>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_tokenizer.h"
  11 #include "google_apis/gcm/engine/gcm_registration_request_handler.h"
  12 #include "google_apis/gcm/engine/gcm_request_test_base.h"
  13 #include "google_apis/gcm/engine/instance_id_get_token_request_handler.h"
  14 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
  15 #include "net/base/load_flags.h"
  16 #include "net/url_request/url_request_status.h"
  17
  18 namespace gcm {
  19
  20 namespace {
  21 const uint64 kAndroidId = 42UL;
  22 const char kAppId[] = "TestAppId";
  23 const char kDeveloperId[] = "Project1";
  24 const char kLoginHeader[] = "AidLogin";
  25 const char kRegistrationURL[] = "http://foo.bar/register";
  26 const uint64 kSecurityToken = 77UL;
  27 const int kGCMVersion = 40;
  28 const char kInstanceId[] = "IID1";
  29 const char kScope[] = "GCM";
  30
  31 }  // namespace
  32
  33 class RegistrationRequestTest : public GCMRequestTestBase {
  34  public:
  35   RegistrationRequestTest();
  36   ~RegistrationRequestTest() override;
  37
  38   void RegistrationCallback(RegistrationRequest::Status status,
  39                             const std::string& registration_id);
  40
  41   void CompleteFetch() override;
  42
  43   void set_max_retry_count(int max_retry_count) {
  44     max_retry_count_ = max_retry_count;
  45   }
  46
  47  protected:
  48   int max_retry_count_;
  49   RegistrationRequest::Status status_;
  50   std::string registration_id_;
  51   bool callback_called_;
  52   std::map<std::string, std::string> extras_;
  53   scoped_ptr<RegistrationRequest> request_;
  54   FakeGCMStatsRecorder recorder_;
  55 };
  56
  57 RegistrationRequestTest::RegistrationRequestTest()
  58     : max_retry_count_(2),
  59       status_(RegistrationRequest::SUCCESS),
  60       callback_called_(false) {}
  61
  62 RegistrationRequestTest::~RegistrationRequestTest() {}
  63
  64 void RegistrationRequestTest::RegistrationCallback(
  65     RegistrationRequest::Status status,
  66     const std::string& registration_id) {
  67   status_ = status;
  68   registration_id_ = registration_id;
  69   callback_called_ = true;
  70 }
  71
  72 void RegistrationRequestTest::CompleteFetch() {
  73   registration_id_.clear();
  74   status_ = RegistrationRequest::SUCCESS;
  75   callback_called_ = false;
  76
  77   GCMRequestTestBase::CompleteFetch();
  78 }
  79
  80 class GCMRegistrationRequestTest : public RegistrationRequestTest {
  81  public:
  82   GCMRegistrationRequestTest();
  83   ~GCMRegistrationRequestTest() override;
  84
  85   void CreateRequest(const std::string& sender_ids);
  86 };
  87
  88 GCMRegistrationRequestTest::GCMRegistrationRequestTest() {
  89 }
  90
  91 GCMRegistrationRequestTest::~GCMRegistrationRequestTest() {
  92 }
  93
  94 void GCMRegistrationRequestTest::CreateRequest(const std::string& sender_ids) {
  95   RegistrationRequest::RequestInfo request_info(
  96       kAndroidId, kSecurityToken, kAppId);
  97   scoped_ptr<GCMRegistrationRequestHandler> request_handler(
  98       new GCMRegistrationRequestHandler(sender_ids));
  99   request_.reset(new RegistrationRequest(
 100       GURL(kRegistrationURL),
 101       request_info,
 102       request_handler.Pass(),
 103       GetBackoffPolicy(),
 104       base::Bind(&RegistrationRequestTest::RegistrationCallback,
 105                  base::Unretained(this)),
 106       max_retry_count_,
 107       url_request_context_getter(),
 108       &recorder_,
 109       sender_ids));
 110 }
 111
 112 TEST_F(GCMRegistrationRequestTest, RequestSuccessful) {
 113   set_max_retry_count(0);
 114   CreateRequest("sender1,sender2");
 115   request_->Start();
 116
 117   SetResponse(net::HTTP_OK, "token=2501");
 118   CompleteFetch();
 119
 120   EXPECT_TRUE(callback_called_);
 121   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 122   EXPECT_EQ("2501", registration_id_);
 123 }
 124
 125 TEST_F(GCMRegistrationRequestTest, RequestDataAndURL) {
 126   CreateRequest(kDeveloperId);
 127   request_->Start();
 128
 129   // Get data sent by request.
 130   net::TestURLFetcher* fetcher = GetFetcher();
 131   ASSERT_TRUE(fetcher);
 132
 133   EXPECT_EQ(GURL(kRegistrationURL), fetcher->GetOriginalURL());
 134
 135   // Verify that authorization header was put together properly.
 136   net::HttpRequestHeaders headers;
 137   fetcher->GetExtraRequestHeaders(&headers);
 138   std::string auth_header;
 139   headers.GetHeader(net::HttpRequestHeaders::kAuthorization, &auth_header);
 140   base::StringTokenizer auth_tokenizer(auth_header, " :");
 141   ASSERT_TRUE(auth_tokenizer.GetNext());
 142   EXPECT_EQ(kLoginHeader, auth_tokenizer.token());
 143   ASSERT_TRUE(auth_tokenizer.GetNext());
 144   EXPECT_EQ(base::Uint64ToString(kAndroidId), auth_tokenizer.token());
 145   ASSERT_TRUE(auth_tokenizer.GetNext());
 146   EXPECT_EQ(base::Uint64ToString(kSecurityToken), auth_tokenizer.token());
 147
 148   std::map<std::string, std::string> expected_pairs;
 149   expected_pairs["app"] = kAppId;
 150   expected_pairs["sender"] = kDeveloperId;
 151   expected_pairs["device"] = base::Uint64ToString(kAndroidId);
 152
 153   // Verify data was formatted properly.
 154   std::string upload_data = fetcher->upload_data();
 155   base::StringTokenizer data_tokenizer(upload_data, "&=");
 156   while (data_tokenizer.GetNext()) {
 157     std::map<std::string, std::string>::iterator iter =
 158         expected_pairs.find(data_tokenizer.token());
 159     ASSERT_TRUE(iter != expected_pairs.end());
 160     ASSERT_TRUE(data_tokenizer.GetNext());
 161     EXPECT_EQ(iter->second, data_tokenizer.token());
 162     // Ensure that none of the keys appears twice.
 163     expected_pairs.erase(iter);
 164   }
 165
 166   EXPECT_EQ(0UL, expected_pairs.size());
 167 }
 168
 169 TEST_F(GCMRegistrationRequestTest, RequestRegistrationWithMultipleSenderIds) {
 170   CreateRequest("sender1,sender2@gmail.com");
 171   request_->Start();
 172
 173   net::TestURLFetcher* fetcher = GetFetcher();
 174   ASSERT_TRUE(fetcher);
 175
 176   // Verify data was formatted properly.
 177   std::string upload_data = fetcher->upload_data();
 178   base::StringTokenizer data_tokenizer(upload_data, "&=");
 179
 180   // Skip all tokens until you hit entry for senders.
 181   while (data_tokenizer.GetNext() && data_tokenizer.token() != "sender")
 182     continue;
 183
 184   ASSERT_TRUE(data_tokenizer.GetNext());
 185   std::string senders(net::UnescapeURLComponent(data_tokenizer.token(),
 186       net::UnescapeRule::URL_SPECIAL_CHARS));
 187   base::StringTokenizer sender_tokenizer(senders, ",");
 188   ASSERT_TRUE(sender_tokenizer.GetNext());
 189   EXPECT_EQ("sender1", sender_tokenizer.token());
 190   ASSERT_TRUE(sender_tokenizer.GetNext());
 191   EXPECT_EQ("sender2@gmail.com", sender_tokenizer.token());
 192 }
 193
 194 TEST_F(GCMRegistrationRequestTest, ResponseParsing) {
 195   CreateRequest("sender1,sender2");
 196   request_->Start();
 197
 198   SetResponse(net::HTTP_OK, "token=2501");
 199   CompleteFetch();
 200
 201   EXPECT_TRUE(callback_called_);
 202   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 203   EXPECT_EQ("2501", registration_id_);
 204 }
 205
 206 TEST_F(GCMRegistrationRequestTest, ResponseHttpStatusNotOK) {
 207   CreateRequest("sender1,sender2");
 208   request_->Start();
 209
 210   SetResponse(net::HTTP_UNAUTHORIZED, "token=2501");
 211   CompleteFetch();
 212
 213   EXPECT_FALSE(callback_called_);
 214
 215   SetResponse(net::HTTP_OK, "token=2501");
 216   CompleteFetch();
 217
 218   EXPECT_TRUE(callback_called_);
 219   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 220   EXPECT_EQ("2501", registration_id_);
 221 }
 222
 223 TEST_F(GCMRegistrationRequestTest, ResponseMissingRegistrationId) {
 224   CreateRequest("sender1,sender2");
 225   request_->Start();
 226
 227   SetResponse(net::HTTP_OK, "");
 228   CompleteFetch();
 229
 230   EXPECT_FALSE(callback_called_);
 231
 232   SetResponse(net::HTTP_OK, "some error in response");
 233   CompleteFetch();
 234
 235   EXPECT_FALSE(callback_called_);
 236
 237   // Ensuring a retry happened and succeeds.
 238   SetResponse(net::HTTP_OK, "token=2501");
 239   CompleteFetch();
 240
 241   EXPECT_TRUE(callback_called_);
 242   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 243   EXPECT_EQ("2501", registration_id_);
 244 }
 245
 246 TEST_F(GCMRegistrationRequestTest, ResponseDeviceRegistrationError) {
 247   CreateRequest("sender1,sender2");
 248   request_->Start();
 249
 250   SetResponse(net::HTTP_OK, "Error=PHONE_REGISTRATION_ERROR");
 251   CompleteFetch();
 252
 253   EXPECT_FALSE(callback_called_);
 254
 255   // Ensuring a retry happened and succeeds.
 256   SetResponse(net::HTTP_OK, "token=2501");
 257   CompleteFetch();
 258
 259   EXPECT_TRUE(callback_called_);
 260   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 261   EXPECT_EQ("2501", registration_id_);
 262 }
 263
 264 TEST_F(GCMRegistrationRequestTest, ResponseAuthenticationError) {
 265   CreateRequest("sender1,sender2");
 266   request_->Start();
 267
 268   SetResponse(net::HTTP_UNAUTHORIZED,
 269                              "Error=AUTHENTICATION_FAILED");
 270   CompleteFetch();
 271
 272   EXPECT_FALSE(callback_called_);
 273
 274   // Ensuring a retry happened and succeeds.
 275   SetResponse(net::HTTP_OK, "token=2501");
 276   CompleteFetch();
 277
 278   EXPECT_TRUE(callback_called_);
 279   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 280   EXPECT_EQ("2501", registration_id_);
 281 }
 282
 283 TEST_F(GCMRegistrationRequestTest, ResponseInvalidParameters) {
 284   CreateRequest("sender1,sender2");
 285   request_->Start();
 286
 287   SetResponse(net::HTTP_OK, "Error=INVALID_PARAMETERS");
 288   CompleteFetch();
 289
 290   EXPECT_TRUE(callback_called_);
 291   EXPECT_EQ(RegistrationRequest::INVALID_PARAMETERS, status_);
 292   EXPECT_EQ(std::string(), registration_id_);
 293 }
 294
 295 TEST_F(GCMRegistrationRequestTest, ResponseInvalidSender) {
 296   CreateRequest("sender1,sender2");
 297   request_->Start();
 298
 299   SetResponse(net::HTTP_OK, "Error=INVALID_SENDER");
 300   CompleteFetch();
 301
 302   EXPECT_TRUE(callback_called_);
 303   EXPECT_EQ(RegistrationRequest::INVALID_SENDER, status_);
 304   EXPECT_EQ(std::string(), registration_id_);
 305 }
 306
 307 TEST_F(GCMRegistrationRequestTest, ResponseInvalidSenderBadRequest) {
 308   CreateRequest("sender1");
 309   request_->Start();
 310
 311   SetResponse(net::HTTP_BAD_REQUEST, "Error=INVALID_SENDER");
 312   CompleteFetch();
 313
 314   EXPECT_TRUE(callback_called_);
 315   EXPECT_EQ(RegistrationRequest::INVALID_SENDER, status_);
 316   EXPECT_EQ(std::string(), registration_id_);
 317 }
 318
 319 TEST_F(GCMRegistrationRequestTest, RequestNotSuccessful) {
 320   CreateRequest("sender1,sender2");
 321   request_->Start();
 322
 323   net::URLRequestStatus request_status(net::URLRequestStatus::FAILED, 1);
 324   SetResponse(net::HTTP_OK, "token=2501");
 325
 326   net::TestURLFetcher* fetcher = GetFetcher();
 327   ASSERT_TRUE(fetcher);
 328   GetFetcher()->set_status(request_status);
 329
 330   CompleteFetch();
 331
 332   EXPECT_FALSE(callback_called_);
 333
 334   // Ensuring a retry happened and succeeded.
 335   SetResponse(net::HTTP_OK, "token=2501");
 336   CompleteFetch();
 337
 338   EXPECT_TRUE(callback_called_);
 339   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 340   EXPECT_EQ("2501", registration_id_);
 341 }
 342
 343 TEST_F(GCMRegistrationRequestTest, ResponseHttpNotOk) {
 344   CreateRequest("sender1,sender2");
 345   request_->Start();
 346
 347   SetResponse(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
 348   CompleteFetch();
 349
 350   EXPECT_FALSE(callback_called_);
 351
 352   // Ensuring a retry happened and succeeded.
 353   SetResponse(net::HTTP_OK, "token=2501");
 354   CompleteFetch();
 355
 356   EXPECT_TRUE(callback_called_);
 357   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 358   EXPECT_EQ("2501", registration_id_);
 359 }
 360
 361 TEST_F(GCMRegistrationRequestTest, MaximumAttemptsReachedWithZeroRetries) {
 362   set_max_retry_count(0);
 363   CreateRequest("sender1,sender2");
 364   request_->Start();
 365
 366   SetResponse(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
 367   CompleteFetch();
 368
 369   EXPECT_TRUE(callback_called_);
 370   EXPECT_EQ(RegistrationRequest::REACHED_MAX_RETRIES, status_);
 371   EXPECT_EQ(std::string(), registration_id_);
 372 }
 373
 374 TEST_F(GCMRegistrationRequestTest, MaximumAttemptsReached) {
 375   CreateRequest("sender1,sender2");
 376   request_->Start();
 377
 378   SetResponse(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
 379   CompleteFetch();
 380
 381   EXPECT_FALSE(callback_called_);
 382
 383   SetResponse(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
 384   CompleteFetch();
 385
 386   EXPECT_FALSE(callback_called_);
 387
 388   SetResponse(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
 389   CompleteFetch();
 390
 391   EXPECT_TRUE(callback_called_);
 392   EXPECT_EQ(RegistrationRequest::REACHED_MAX_RETRIES, status_);
 393   EXPECT_EQ(std::string(), registration_id_);
 394 }
 395
 396 class InstanceIDGetTokenRequestTest : public RegistrationRequestTest {
 397  public:
 398   InstanceIDGetTokenRequestTest();
 399   ~InstanceIDGetTokenRequestTest() override;
 400
 401   void CreateRequest(const std::string& instance_id,
 402                      const std::string& authorized_entity,
 403                      const std::string& scope,
 404                      const std::map<std::string, std::string>& options);
 405 };
 406
 407 InstanceIDGetTokenRequestTest::InstanceIDGetTokenRequestTest() {
 408 }
 409
 410 InstanceIDGetTokenRequestTest::~InstanceIDGetTokenRequestTest() {
 411 }
 412
 413 void InstanceIDGetTokenRequestTest::CreateRequest(
 414     const std::string& instance_id,
 415     const std::string& authorized_entity,
 416     const std::string& scope,
 417     const std::map<std::string, std::string>& options) {
 418   RegistrationRequest::RequestInfo request_info(
 419       kAndroidId, kSecurityToken, kAppId);
 420   scoped_ptr<InstanceIDGetTokenRequestHandler> request_handler(
 421       new InstanceIDGetTokenRequestHandler(
 422           instance_id, authorized_entity, scope, kGCMVersion, options));
 423   request_.reset(new RegistrationRequest(
 424       GURL(kRegistrationURL),
 425       request_info,
 426       request_handler.Pass(),
 427       GetBackoffPolicy(),
 428       base::Bind(&RegistrationRequestTest::RegistrationCallback,
 429                  base::Unretained(this)),
 430       max_retry_count_,
 431       url_request_context_getter(),
 432       &recorder_,
 433       authorized_entity));
 434 }
 435
 436 TEST_F(InstanceIDGetTokenRequestTest, RequestSuccessful) {
 437   std::map<std::string, std::string> options;
 438   options["Foo"] = "Bar";
 439
 440   set_max_retry_count(0);
 441   CreateRequest(kInstanceId, kDeveloperId, kScope, options);
 442   request_->Start();
 443
 444   SetResponse(net::HTTP_OK, "token=2501");
 445   CompleteFetch();
 446
 447   EXPECT_TRUE(callback_called_);
 448   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 449   EXPECT_EQ("2501", registration_id_);
 450 }
 451
 452 TEST_F(InstanceIDGetTokenRequestTest, RequestDataAndURL) {
 453   std::map<std::string, std::string> options;
 454   options["Foo"] = "Bar";
 455   CreateRequest(kInstanceId, kDeveloperId, kScope, options);
 456   request_->Start();
 457
 458   // Get data sent by request.
 459   net::TestURLFetcher* fetcher = GetFetcher();
 460   ASSERT_TRUE(fetcher);
 461
 462   EXPECT_EQ(GURL(kRegistrationURL), fetcher->GetOriginalURL());
 463
 464   // Verify that the no-cookie flag is set.
 465   int flags = fetcher->GetLoadFlags();
 466   EXPECT_TRUE(flags & net::LOAD_DO_NOT_SEND_COOKIES);
 467   EXPECT_TRUE(flags & net::LOAD_DO_NOT_SAVE_COOKIES);
 468
 469   // Verify that authorization header was put together properly.
 470   net::HttpRequestHeaders headers;
 471   fetcher->GetExtraRequestHeaders(&headers);
 472   std::string auth_header;
 473   headers.GetHeader(net::HttpRequestHeaders::kAuthorization, &auth_header);
 474   base::StringTokenizer auth_tokenizer(auth_header, " :");
 475   ASSERT_TRUE(auth_tokenizer.GetNext());
 476   EXPECT_EQ(kLoginHeader, auth_tokenizer.token());
 477   ASSERT_TRUE(auth_tokenizer.GetNext());
 478   EXPECT_EQ(base::Uint64ToString(kAndroidId), auth_tokenizer.token());
 479   ASSERT_TRUE(auth_tokenizer.GetNext());
 480   EXPECT_EQ(base::Uint64ToString(kSecurityToken), auth_tokenizer.token());
 481
 482   std::map<std::string, std::string> expected_pairs;
 483   expected_pairs["gmsv"] = base::IntToString(kGCMVersion);
 484   expected_pairs["app"] = kAppId;
 485   expected_pairs["sender"] = kDeveloperId;
 486   expected_pairs["X-subtype"] = kDeveloperId;
 487   expected_pairs["device"] = base::Uint64ToString(kAndroidId);
 488   expected_pairs["appid"] = kInstanceId;
 489   expected_pairs["scope"] = kScope;
 490   expected_pairs["X-scope"] = kScope;
 491   expected_pairs["X-Foo"] = "Bar";
 492
 493   // Verify data was formatted properly.
 494   std::string upload_data = fetcher->upload_data();
 495   base::StringTokenizer data_tokenizer(upload_data, "&=");
 496   while (data_tokenizer.GetNext()) {
 497     std::map<std::string, std::string>::iterator iter =
 498         expected_pairs.find(data_tokenizer.token());
 499     ASSERT_TRUE(iter != expected_pairs.end());
 500     ASSERT_TRUE(data_tokenizer.GetNext());
 501     EXPECT_EQ(iter->second, data_tokenizer.token());
 502     // Ensure that none of the keys appears twice.
 503     expected_pairs.erase(iter);
 504   }
 505
 506   EXPECT_EQ(0UL, expected_pairs.size());
 507 }
 508
 509 TEST_F(InstanceIDGetTokenRequestTest, ResponseHttpStatusNotOK) {
 510   std::map<std::string, std::string> options;
 511   CreateRequest(kInstanceId, kDeveloperId, kScope, options);
 512   request_->Start();
 513
 514   SetResponse(net::HTTP_UNAUTHORIZED, "token=2501");
 515   CompleteFetch();
 516
 517   EXPECT_FALSE(callback_called_);
 518
 519   SetResponse(net::HTTP_OK, "token=2501");
 520   CompleteFetch();
 521
 522   EXPECT_TRUE(callback_called_);
 523   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
 524   EXPECT_EQ("2501", registration_id_);
 525 }
 526
 527 }  // namespace gcm