components/gcm_driver/gcm_client_impl_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 "components/gcm_driver/gcm_client_impl.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/time/clock.h"
  13 #include "google_apis/gcm/base/fake_encryptor.h"
  14 #include "google_apis/gcm/base/mcs_message.h"
  15 #include "google_apis/gcm/base/mcs_util.h"
  16 #include "google_apis/gcm/engine/fake_connection_factory.h"
  17 #include "google_apis/gcm/engine/fake_connection_handler.h"
  18 #include "google_apis/gcm/engine/gservices_settings.h"
  19 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
  20 #include "google_apis/gcm/protocol/android_checkin.pb.h"
  21 #include "google_apis/gcm/protocol/checkin.pb.h"
  22 #include "google_apis/gcm/protocol/mcs.pb.h"
  23 #include "net/url_request/test_url_fetcher_factory.h"
  24 #include "net/url_request/url_fetcher_delegate.h"
  25 #include "net/url_request/url_request_test_util.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 namespace gcm {
  29
  30 namespace {
  31
  32 enum LastEvent {
  33   NONE,
  34   LOADING_COMPLETED,
  35   REGISTRATION_COMPLETED,
  36   UNREGISTRATION_COMPLETED,
  37   MESSAGE_SEND_ERROR,
  38   MESSAGE_RECEIVED,
  39   MESSAGES_DELETED,
  40 };
  41
  42 const uint64 kDeviceAndroidId = 54321;
  43 const uint64 kDeviceSecurityToken = 12345;
  44 const int64 kSettingsCheckinInterval = 16 * 60 * 60;
  45 const char kAppId[] = "app_id";
  46 const char kSender[] = "project_id";
  47 const char kSender2[] = "project_id2";
  48 const char kSender3[] = "project_id3";
  49 const char kRegistrationResponsePrefix[] = "token=";
  50 const char kUnregistrationResponsePrefix[] = "deleted=";
  51
  52 // Helper for building arbitrary data messages.
  53 MCSMessage BuildDownstreamMessage(
  54     const std::string& project_id,
  55     const std::string& app_id,
  56     const std::map<std::string, std::string>& data) {
  57   mcs_proto::DataMessageStanza data_message;
  58   data_message.set_from(project_id);
  59   data_message.set_category(app_id);
  60   for (std::map<std::string, std::string>::const_iterator iter = data.begin();
  61        iter != data.end();
  62        ++iter) {
  63     mcs_proto::AppData* app_data = data_message.add_app_data();
  64     app_data->set_key(iter->first);
  65     app_data->set_value(iter->second);
  66   }
  67   return MCSMessage(kDataMessageStanzaTag, data_message);
  68 }
  69
  70 class FakeMCSClient : public MCSClient {
  71  public:
  72   FakeMCSClient(base::Clock* clock,
  73                 ConnectionFactory* connection_factory,
  74                 GCMStore* gcm_store,
  75                 GCMStatsRecorder* recorder);
  76   virtual ~FakeMCSClient();
  77   virtual void Login(uint64 android_id, uint64 security_token) OVERRIDE;
  78   virtual void SendMessage(const MCSMessage& message) OVERRIDE;
  79
  80   uint64 last_android_id() const { return last_android_id_; }
  81   uint64 last_security_token() const { return last_security_token_; }
  82   uint8 last_message_tag() const { return last_message_tag_; }
  83   const mcs_proto::DataMessageStanza& last_data_message_stanza() const {
  84     return last_data_message_stanza_;
  85   }
  86
  87  private:
  88   uint64 last_android_id_;
  89   uint64 last_security_token_;
  90   uint8 last_message_tag_;
  91   mcs_proto::DataMessageStanza last_data_message_stanza_;
  92 };
  93
  94 FakeMCSClient::FakeMCSClient(base::Clock* clock,
  95                              ConnectionFactory* connection_factory,
  96                              GCMStore* gcm_store,
  97                              GCMStatsRecorder* recorder)
  98     : MCSClient("", clock, connection_factory, gcm_store, recorder),
  99       last_android_id_(0u),
 100       last_security_token_(0u),
 101       last_message_tag_(kNumProtoTypes) {
 102 }
 103
 104 FakeMCSClient::~FakeMCSClient() {
 105 }
 106
 107 void FakeMCSClient::Login(uint64 android_id, uint64 security_token) {
 108   last_android_id_ = android_id;
 109   last_security_token_ = security_token;
 110 }
 111
 112 void FakeMCSClient::SendMessage(const MCSMessage& message) {
 113   last_message_tag_ = message.tag();
 114   if (last_message_tag_ == kDataMessageStanzaTag) {
 115     last_data_message_stanza_.CopyFrom(
 116         reinterpret_cast<const mcs_proto::DataMessageStanza&>(
 117             message.GetProtobuf()));
 118   }
 119 }
 120
 121 class AutoAdvancingTestClock : public base::Clock {
 122  public:
 123   explicit AutoAdvancingTestClock(base::TimeDelta auto_increment_time_delta);
 124   virtual ~AutoAdvancingTestClock();
 125
 126   virtual base::Time Now() OVERRIDE;
 127   void Advance(TimeDelta delta);
 128   int call_count() const { return call_count_; }
 129
 130  private:
 131   int call_count_;
 132   base::TimeDelta auto_increment_time_delta_;
 133   base::Time now_;
 134
 135   DISALLOW_COPY_AND_ASSIGN(AutoAdvancingTestClock);
 136 };
 137
 138 AutoAdvancingTestClock::AutoAdvancingTestClock(
 139     base::TimeDelta auto_increment_time_delta)
 140     : call_count_(0), auto_increment_time_delta_(auto_increment_time_delta) {
 141 }
 142
 143 AutoAdvancingTestClock::~AutoAdvancingTestClock() {
 144 }
 145
 146 base::Time AutoAdvancingTestClock::Now() {
 147   call_count_++;
 148   now_ += auto_increment_time_delta_;
 149   return now_;
 150 }
 151
 152 void AutoAdvancingTestClock::Advance(base::TimeDelta delta) {
 153   now_ += delta;
 154 }
 155
 156 class FakeGCMInternalsBuilder : public GCMInternalsBuilder {
 157  public:
 158   FakeGCMInternalsBuilder(base::TimeDelta clock_step);
 159   virtual ~FakeGCMInternalsBuilder();
 160
 161   virtual scoped_ptr<base::Clock> BuildClock() OVERRIDE;
 162   virtual scoped_ptr<MCSClient> BuildMCSClient(
 163       const std::string& version,
 164       base::Clock* clock,
 165       ConnectionFactory* connection_factory,
 166       GCMStore* gcm_store,
 167       GCMStatsRecorder* recorder) OVERRIDE;
 168   virtual scoped_ptr<ConnectionFactory> BuildConnectionFactory(
 169       const std::vector<GURL>& endpoints,
 170       const net::BackoffEntry::Policy& backoff_policy,
 171       scoped_refptr<net::HttpNetworkSession> network_session,
 172       net::NetLog* net_log,
 173       GCMStatsRecorder* recorder) OVERRIDE;
 174
 175  private:
 176   base::TimeDelta clock_step_;
 177 };
 178
 179 FakeGCMInternalsBuilder::FakeGCMInternalsBuilder(base::TimeDelta clock_step)
 180     : clock_step_(clock_step) {
 181 }
 182
 183 FakeGCMInternalsBuilder::~FakeGCMInternalsBuilder() {}
 184
 185 scoped_ptr<base::Clock> FakeGCMInternalsBuilder::BuildClock() {
 186   return make_scoped_ptr<base::Clock>(new AutoAdvancingTestClock(clock_step_));
 187 }
 188
 189 scoped_ptr<MCSClient> FakeGCMInternalsBuilder::BuildMCSClient(
 190     const std::string& version,
 191     base::Clock* clock,
 192     ConnectionFactory* connection_factory,
 193     GCMStore* gcm_store,
 194     GCMStatsRecorder* recorder) {
 195   return make_scoped_ptr<MCSClient>(new FakeMCSClient(clock,
 196                                                       connection_factory,
 197                                                       gcm_store,
 198                                                       recorder));
 199 }
 200
 201 scoped_ptr<ConnectionFactory> FakeGCMInternalsBuilder::BuildConnectionFactory(
 202     const std::vector<GURL>& endpoints,
 203     const net::BackoffEntry::Policy& backoff_policy,
 204     scoped_refptr<net::HttpNetworkSession> network_session,
 205     net::NetLog* net_log,
 206     GCMStatsRecorder* recorder) {
 207   return make_scoped_ptr<ConnectionFactory>(new FakeConnectionFactory());
 208 }
 209
 210 }  // namespace
 211
 212 class GCMClientImplTest : public testing::Test,
 213                           public GCMClient::Delegate {
 214  public:
 215   GCMClientImplTest();
 216   virtual ~GCMClientImplTest();
 217
 218   virtual void SetUp() OVERRIDE;
 219
 220   void BuildGCMClient(base::TimeDelta clock_step);
 221   void InitializeGCMClient();
 222   void StartGCMClient();
 223   void ReceiveMessageFromMCS(const MCSMessage& message);
 224   void CompleteCheckin(uint64 android_id,
 225                        uint64 security_token,
 226                        const std::string& digest,
 227                        const std::map<std::string, std::string>& settings);
 228   void CompleteRegistration(const std::string& registration_id);
 229   void CompleteUnregistration(const std::string& app_id);
 230
 231   bool ExistsRegistration(const std::string& app_id) const;
 232   void AddRegistration(const std::string& app_id,
 233                        const std::vector<std::string>& sender_ids,
 234                        const std::string& registration_id);
 235
 236   // GCMClient::Delegate overrides (for verification).
 237   virtual void OnRegisterFinished(const std::string& app_id,
 238                                   const std::string& registration_id,
 239                                   GCMClient::Result result) OVERRIDE;
 240   virtual void OnUnregisterFinished(const std::string& app_id,
 241                                     GCMClient::Result result) OVERRIDE;
 242   virtual void OnSendFinished(const std::string& app_id,
 243                               const std::string& message_id,
 244                               GCMClient::Result result) OVERRIDE {}
 245   virtual void OnMessageReceived(const std::string& registration_id,
 246                                  const GCMClient::IncomingMessage& message)
 247       OVERRIDE;
 248   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
 249   virtual void OnMessageSendError(
 250       const std::string& app_id,
 251       const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
 252   virtual void OnGCMReady() OVERRIDE;
 253   virtual void OnActivityRecorded() OVERRIDE {}
 254   virtual void OnConnected(const net::IPEndPoint& ip_endpoint) OVERRIDE {}
 255   virtual void OnDisconnected() OVERRIDE {}
 256
 257   GCMClientImpl* gcm_client() const { return gcm_client_.get(); }
 258   FakeMCSClient* mcs_client() const {
 259     return reinterpret_cast<FakeMCSClient*>(gcm_client_->mcs_client_.get());
 260   }
 261   ConnectionFactory* connection_factory() const {
 262     return gcm_client_->connection_factory_.get();
 263   }
 264
 265   void reset_last_event() {
 266     last_event_ = NONE;
 267     last_app_id_.clear();
 268     last_registration_id_.clear();
 269     last_message_id_.clear();
 270     last_result_ = GCMClient::UNKNOWN_ERROR;
 271   }
 272
 273   LastEvent last_event() const { return last_event_; }
 274   const std::string& last_app_id() const { return last_app_id_; }
 275   const std::string& last_registration_id() const {
 276     return last_registration_id_;
 277   }
 278   const std::string& last_message_id() const { return last_message_id_; }
 279   GCMClient::Result last_result() const { return last_result_; }
 280   const GCMClient::IncomingMessage& last_message() const {
 281     return last_message_;
 282   }
 283   const GCMClient::SendErrorDetails& last_error_details() const {
 284     return last_error_details_;
 285   }
 286
 287   const GServicesSettings& gservices_settings() const {
 288     return gcm_client_->gservices_settings_;
 289   }
 290
 291   int64 CurrentTime();
 292
 293   // Tooling.
 294   void PumpLoop();
 295   void PumpLoopUntilIdle();
 296   void QuitLoop();
 297   void InitializeLoop();
 298   bool CreateUniqueTempDir();
 299   AutoAdvancingTestClock* clock() const {
 300     return reinterpret_cast<AutoAdvancingTestClock*>(gcm_client_->clock_.get());
 301   }
 302
 303  private:
 304   // Variables used for verification.
 305   LastEvent last_event_;
 306   std::string last_app_id_;
 307   std::string last_registration_id_;
 308   std::string last_message_id_;
 309   GCMClient::Result last_result_;
 310   GCMClient::IncomingMessage last_message_;
 311   GCMClient::SendErrorDetails last_error_details_;
 312
 313   scoped_ptr<GCMClientImpl> gcm_client_;
 314
 315   base::MessageLoop message_loop_;
 316   scoped_ptr<base::RunLoop> run_loop_;
 317   net::TestURLFetcherFactory url_fetcher_factory_;
 318
 319   // Injected to GCM client:
 320   base::ScopedTempDir temp_directory_;
 321   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
 322 };
 323
 324 GCMClientImplTest::GCMClientImplTest()
 325     : last_event_(NONE),
 326       last_result_(GCMClient::UNKNOWN_ERROR),
 327       url_request_context_getter_(new net::TestURLRequestContextGetter(
 328           message_loop_.message_loop_proxy())) {
 329 }
 330
 331 GCMClientImplTest::~GCMClientImplTest() {}
 332
 333 void GCMClientImplTest::SetUp() {
 334   testing::Test::SetUp();
 335   ASSERT_TRUE(CreateUniqueTempDir());
 336   InitializeLoop();
 337   BuildGCMClient(base::TimeDelta());
 338   InitializeGCMClient();
 339   StartGCMClient();
 340   CompleteCheckin(kDeviceAndroidId,
 341                   kDeviceSecurityToken,
 342                   std::string(),
 343                   std::map<std::string, std::string>());
 344 }
 345
 346 void GCMClientImplTest::PumpLoop() {
 347   run_loop_->Run();
 348   run_loop_.reset(new base::RunLoop());
 349 }
 350
 351 void GCMClientImplTest::PumpLoopUntilIdle() {
 352   run_loop_->RunUntilIdle();
 353   run_loop_.reset(new base::RunLoop());
 354 }
 355
 356 void GCMClientImplTest::QuitLoop() {
 357   if (run_loop_ && run_loop_->running())
 358     run_loop_->Quit();
 359 }
 360
 361 void GCMClientImplTest::InitializeLoop() {
 362   run_loop_.reset(new base::RunLoop);
 363 }
 364
 365 bool GCMClientImplTest::CreateUniqueTempDir() {
 366   return temp_directory_.CreateUniqueTempDir();
 367 }
 368
 369 void GCMClientImplTest::BuildGCMClient(base::TimeDelta clock_step) {
 370   gcm_client_.reset(new GCMClientImpl(make_scoped_ptr<GCMInternalsBuilder>(
 371       new FakeGCMInternalsBuilder(clock_step))));
 372 }
 373
 374 void GCMClientImplTest::CompleteCheckin(
 375     uint64 android_id,
 376     uint64 security_token,
 377     const std::string& digest,
 378     const std::map<std::string, std::string>& settings) {
 379   checkin_proto::AndroidCheckinResponse response;
 380   response.set_stats_ok(true);
 381   response.set_android_id(android_id);
 382   response.set_security_token(security_token);
 383
 384   // For testing G-services settings.
 385   if (!digest.empty()) {
 386     response.set_digest(digest);
 387     for (std::map<std::string, std::string>::const_iterator it =
 388              settings.begin();
 389          it != settings.end();
 390          ++it) {
 391       checkin_proto::GservicesSetting* setting = response.add_setting();
 392       setting->set_name(it->first);
 393       setting->set_value(it->second);
 394     }
 395     response.set_settings_diff(false);
 396   }
 397
 398   std::string response_string;
 399   response.SerializeToString(&response_string);
 400
 401   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
 402   ASSERT_TRUE(fetcher);
 403   fetcher->set_response_code(net::HTTP_OK);
 404   fetcher->SetResponseString(response_string);
 405   fetcher->delegate()->OnURLFetchComplete(fetcher);
 406   url_fetcher_factory_.RemoveFetcherFromMap(0);
 407 }
 408
 409 void GCMClientImplTest::CompleteRegistration(
 410     const std::string& registration_id) {
 411   std::string response(kRegistrationResponsePrefix);
 412   response.append(registration_id);
 413   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
 414   ASSERT_TRUE(fetcher);
 415   fetcher->set_response_code(net::HTTP_OK);
 416   fetcher->SetResponseString(response);
 417   fetcher->delegate()->OnURLFetchComplete(fetcher);
 418   url_fetcher_factory_.RemoveFetcherFromMap(0);
 419 }
 420
 421 void GCMClientImplTest::CompleteUnregistration(
 422     const std::string& app_id) {
 423   std::string response(kUnregistrationResponsePrefix);
 424   response.append(app_id);
 425   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
 426   ASSERT_TRUE(fetcher);
 427   fetcher->set_response_code(net::HTTP_OK);
 428   fetcher->SetResponseString(response);
 429   fetcher->delegate()->OnURLFetchComplete(fetcher);
 430   url_fetcher_factory_.RemoveFetcherFromMap(0);
 431 }
 432
 433 bool GCMClientImplTest::ExistsRegistration(const std::string& app_id) const {
 434   return gcm_client_->registrations_.count(app_id) > 0;
 435 }
 436
 437 void GCMClientImplTest::AddRegistration(
 438     const std::string& app_id,
 439     const std::vector<std::string>& sender_ids,
 440     const std::string& registration_id) {
 441   linked_ptr<RegistrationInfo> registration(new RegistrationInfo);
 442   registration->sender_ids = sender_ids;
 443   registration->registration_id = registration_id;
 444   gcm_client_->registrations_[app_id] = registration;
 445 }
 446
 447 void GCMClientImplTest::InitializeGCMClient() {
 448   clock()->Advance(base::TimeDelta::FromMilliseconds(1));
 449
 450   // Actual initialization.
 451   GCMClient::ChromeBuildInfo chrome_build_info;
 452   gcm_client_->Initialize(chrome_build_info,
 453                           temp_directory_.path(),
 454                           message_loop_.message_loop_proxy(),
 455                           url_request_context_getter_,
 456                           make_scoped_ptr<Encryptor>(new FakeEncryptor),
 457                           this);
 458 }
 459
 460 void GCMClientImplTest::StartGCMClient() {
 461   // Start loading and check-in.
 462   gcm_client_->Start();
 463
 464   PumpLoopUntilIdle();
 465 }
 466
 467 void GCMClientImplTest::ReceiveMessageFromMCS(const MCSMessage& message) {
 468   gcm_client_->OnMessageReceivedFromMCS(message);
 469 }
 470
 471 void GCMClientImplTest::OnGCMReady() {
 472   last_event_ = LOADING_COMPLETED;
 473   QuitLoop();
 474 }
 475
 476 void GCMClientImplTest::OnMessageReceived(
 477     const std::string& registration_id,
 478     const GCMClient::IncomingMessage& message) {
 479   last_event_ = MESSAGE_RECEIVED;
 480   last_app_id_ = registration_id;
 481   last_message_ = message;
 482   QuitLoop();
 483 }
 484
 485 void GCMClientImplTest::OnRegisterFinished(const std::string& app_id,
 486                                            const std::string& registration_id,
 487                                            GCMClient::Result result) {
 488   last_event_ = REGISTRATION_COMPLETED;
 489   last_app_id_ = app_id;
 490   last_registration_id_ = registration_id;
 491   last_result_ = result;
 492 }
 493
 494 void GCMClientImplTest::OnUnregisterFinished(const std::string& app_id,
 495                                              GCMClient::Result result) {
 496   last_event_ = UNREGISTRATION_COMPLETED;
 497   last_app_id_ = app_id;
 498   last_result_ = result;
 499 }
 500
 501 void GCMClientImplTest::OnMessagesDeleted(const std::string& app_id) {
 502   last_event_ = MESSAGES_DELETED;
 503   last_app_id_ = app_id;
 504 }
 505
 506 void GCMClientImplTest::OnMessageSendError(
 507     const std::string& app_id,
 508     const gcm::GCMClient::SendErrorDetails& send_error_details) {
 509   last_event_ = MESSAGE_SEND_ERROR;
 510   last_app_id_ = app_id;
 511   last_error_details_ = send_error_details;
 512 }
 513
 514 int64 GCMClientImplTest::CurrentTime() {
 515   return clock()->Now().ToInternalValue() / base::Time::kMicrosecondsPerSecond;
 516 }
 517
 518 TEST_F(GCMClientImplTest, LoadingCompleted) {
 519   EXPECT_EQ(LOADING_COMPLETED, last_event());
 520   EXPECT_EQ(kDeviceAndroidId, mcs_client()->last_android_id());
 521   EXPECT_EQ(kDeviceSecurityToken, mcs_client()->last_security_token());
 522 }
 523
 524 TEST_F(GCMClientImplTest, CheckOut) {
 525   EXPECT_TRUE(mcs_client());
 526   EXPECT_TRUE(connection_factory());
 527   gcm_client()->CheckOut();
 528   EXPECT_FALSE(mcs_client());
 529   EXPECT_FALSE(connection_factory());
 530 }
 531
 532 TEST_F(GCMClientImplTest, RegisterApp) {
 533   EXPECT_FALSE(ExistsRegistration(kAppId));
 534
 535   std::vector<std::string> senders;
 536   senders.push_back("sender");
 537   gcm_client()->Register(kAppId, senders);
 538   CompleteRegistration("reg_id");
 539
 540   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
 541   EXPECT_EQ(kAppId, last_app_id());
 542   EXPECT_EQ("reg_id", last_registration_id());
 543   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 544   EXPECT_TRUE(ExistsRegistration(kAppId));
 545 }
 546
 547 TEST_F(GCMClientImplTest, DISABLED_RegisterAppFromCache) {
 548   EXPECT_FALSE(ExistsRegistration(kAppId));
 549
 550   std::vector<std::string> senders;
 551   senders.push_back("sender");
 552   gcm_client()->Register(kAppId, senders);
 553   CompleteRegistration("reg_id");
 554   EXPECT_TRUE(ExistsRegistration(kAppId));
 555
 556   EXPECT_EQ(kAppId, last_app_id());
 557   EXPECT_EQ("reg_id", last_registration_id());
 558   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 559   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
 560
 561   // Recreate GCMClient in order to load from the persistent store.
 562   BuildGCMClient(base::TimeDelta());
 563   InitializeGCMClient();
 564   StartGCMClient();
 565
 566   EXPECT_TRUE(ExistsRegistration(kAppId));
 567 }
 568
 569 TEST_F(GCMClientImplTest, UnregisterApp) {
 570   EXPECT_FALSE(ExistsRegistration(kAppId));
 571
 572   std::vector<std::string> senders;
 573   senders.push_back("sender");
 574   gcm_client()->Register(kAppId, senders);
 575   CompleteRegistration("reg_id");
 576   EXPECT_TRUE(ExistsRegistration(kAppId));
 577
 578   gcm_client()->Unregister(kAppId);
 579   CompleteUnregistration(kAppId);
 580
 581   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
 582   EXPECT_EQ(kAppId, last_app_id());
 583   EXPECT_EQ(GCMClient::SUCCESS, last_result());
 584   EXPECT_FALSE(ExistsRegistration(kAppId));
 585 }
 586
 587 TEST_F(GCMClientImplTest, DispatchDownstreamMessage) {
 588   // Register to receive messages from kSender and kSender2 only.
 589   std::vector<std::string> senders;
 590   senders.push_back(kSender);
 591   senders.push_back(kSender2);
 592   AddRegistration(kAppId, senders, "reg_id");
 593
 594   std::map<std::string, std::string> expected_data;
 595   expected_data["message_type"] = "gcm";
 596   expected_data["key"] = "value";
 597   expected_data["key2"] = "value2";
 598
 599   // Message for kSender will be received.
 600   MCSMessage message(BuildDownstreamMessage(kSender, kAppId, expected_data));
 601   EXPECT_TRUE(message.IsValid());
 602   ReceiveMessageFromMCS(message);
 603
 604   expected_data.erase(expected_data.find("message_type"));
 605   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
 606   EXPECT_EQ(kAppId, last_app_id());
 607   EXPECT_EQ(expected_data.size(), last_message().data.size());
 608   EXPECT_EQ(expected_data, last_message().data);
 609   EXPECT_EQ(kSender, last_message().sender_id);
 610
 611   reset_last_event();
 612
 613   // Message for kSender2 will be received.
 614   MCSMessage message2(BuildDownstreamMessage(kSender2, kAppId, expected_data));
 615   EXPECT_TRUE(message2.IsValid());
 616   ReceiveMessageFromMCS(message2);
 617
 618   EXPECT_EQ(MESSAGE_RECEIVED, last_event());
 619   EXPECT_EQ(kAppId, last_app_id());
 620   EXPECT_EQ(expected_data.size(), last_message().data.size());
 621   EXPECT_EQ(expected_data, last_message().data);
 622   EXPECT_EQ(kSender2, last_message().sender_id);
 623
 624   reset_last_event();
 625
 626   // Message from kSender3 will be dropped.
 627   MCSMessage message3(BuildDownstreamMessage(kSender3, kAppId, expected_data));
 628   EXPECT_TRUE(message3.IsValid());
 629   ReceiveMessageFromMCS(message3);
 630
 631   EXPECT_NE(MESSAGE_RECEIVED, last_event());
 632   EXPECT_NE(kAppId, last_app_id());
 633 }
 634
 635 TEST_F(GCMClientImplTest, DispatchDownstreamMessageSendError) {
 636   std::map<std::string, std::string> expected_data;
 637   expected_data["message_type"] = "send_error";
 638   expected_data["google.message_id"] = "007";
 639   expected_data["error_details"] = "some details";
 640   MCSMessage message(BuildDownstreamMessage(
 641       kSender, kAppId, expected_data));
 642   EXPECT_TRUE(message.IsValid());
 643   ReceiveMessageFromMCS(message);
 644
 645   EXPECT_EQ(MESSAGE_SEND_ERROR, last_event());
 646   EXPECT_EQ(kAppId, last_app_id());
 647   EXPECT_EQ("007", last_error_details().message_id);
 648   EXPECT_EQ(1UL, last_error_details().additional_data.size());
 649   GCMClient::MessageData::const_iterator iter =
 650       last_error_details().additional_data.find("error_details");
 651   EXPECT_TRUE(iter != last_error_details().additional_data.end());
 652   EXPECT_EQ("some details", iter->second);
 653 }
 654
 655 TEST_F(GCMClientImplTest, DispatchDownstreamMessgaesDeleted) {
 656   std::map<std::string, std::string> expected_data;
 657   expected_data["message_type"] = "deleted_messages";
 658   MCSMessage message(BuildDownstreamMessage(
 659       kSender, kAppId, expected_data));
 660   EXPECT_TRUE(message.IsValid());
 661   ReceiveMessageFromMCS(message);
 662
 663   EXPECT_EQ(MESSAGES_DELETED, last_event());
 664   EXPECT_EQ(kAppId, last_app_id());
 665 }
 666
 667 TEST_F(GCMClientImplTest, SendMessage) {
 668   mcs_proto::DataMessageStanza stanza;
 669   stanza.set_ttl(500);
 670
 671   GCMClient::OutgoingMessage message;
 672   message.id = "007";
 673   message.time_to_live = 500;
 674   message.data["key"] = "value";
 675   gcm_client()->Send(kAppId, kSender, message);
 676
 677   EXPECT_EQ(kDataMessageStanzaTag, mcs_client()->last_message_tag());
 678   EXPECT_EQ(kAppId, mcs_client()->last_data_message_stanza().category());
 679   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
 680   EXPECT_EQ(500, mcs_client()->last_data_message_stanza().ttl());
 681   EXPECT_EQ(CurrentTime(), mcs_client()->last_data_message_stanza().sent());
 682   EXPECT_EQ("007", mcs_client()->last_data_message_stanza().id());
 683   EXPECT_EQ("gcm@chrome.com", mcs_client()->last_data_message_stanza().from());
 684   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
 685   EXPECT_EQ("key", mcs_client()->last_data_message_stanza().app_data(0).key());
 686   EXPECT_EQ("value",
 687             mcs_client()->last_data_message_stanza().app_data(0).value());
 688 }
 689
 690 class GCMClientImplCheckinTest : public GCMClientImplTest {
 691  public:
 692   GCMClientImplCheckinTest();
 693   virtual ~GCMClientImplCheckinTest();
 694
 695   virtual void SetUp() OVERRIDE;
 696 };
 697
 698 GCMClientImplCheckinTest::GCMClientImplCheckinTest() {
 699 }
 700
 701 GCMClientImplCheckinTest::~GCMClientImplCheckinTest() {
 702 }
 703
 704 void GCMClientImplCheckinTest::SetUp() {
 705   testing::Test::SetUp();
 706   // Creating unique temp directory that will be used by GCMStore shared between
 707   // GCM Client and G-services settings.
 708   ASSERT_TRUE(CreateUniqueTempDir());
 709   InitializeLoop();
 710   // Time will be advancing one hour every time it is checked.
 711   BuildGCMClient(base::TimeDelta::FromSeconds(kSettingsCheckinInterval));
 712   InitializeGCMClient();
 713   StartGCMClient();
 714 }
 715
 716 TEST_F(GCMClientImplCheckinTest, GServicesSettingsAfterInitialCheckin) {
 717   std::map<std::string, std::string> settings;
 718   settings["checkin_interval"] = base::Int64ToString(kSettingsCheckinInterval);
 719   settings["checkin_url"] = "http://alternative.url/checkin";
 720   settings["gcm_hostname"] = "alternative.gcm.host";
 721   settings["gcm_secure_port"] = "7777";
 722   settings["gcm_registration_url"] = "http://alternative.url/registration";
 723   CompleteCheckin(kDeviceAndroidId,
 724                   kDeviceSecurityToken,
 725                   GServicesSettings::CalculateDigest(settings),
 726                   settings);
 727   EXPECT_EQ(base::TimeDelta::FromSeconds(kSettingsCheckinInterval),
 728             gservices_settings().GetCheckinInterval());
 729   EXPECT_EQ(GURL("http://alternative.url/checkin"),
 730             gservices_settings().GetCheckinURL());
 731   EXPECT_EQ(GURL("http://alternative.url/registration"),
 732             gservices_settings().GetRegistrationURL());
 733   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
 734             gservices_settings().GetMCSMainEndpoint());
 735   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
 736             gservices_settings().GetMCSFallbackEndpoint());
 737 }
 738
 739 // This test only checks that periodic checkin happens.
 740 TEST_F(GCMClientImplCheckinTest, PeriodicCheckin) {
 741   std::map<std::string, std::string> settings;
 742   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
 743   settings["checkin_url"] = "http://alternative.url/checkin";
 744   settings["gcm_hostname"] = "alternative.gcm.host";
 745   settings["gcm_secure_port"] = "7777";
 746   settings["gcm_registration_url"] = "http://alternative.url/registration";
 747   CompleteCheckin(kDeviceAndroidId,
 748                   kDeviceSecurityToken,
 749                   GServicesSettings::CalculateDigest(settings),
 750                   settings);
 751   EXPECT_EQ(2, clock()->call_count());
 752
 753   PumpLoopUntilIdle();
 754   CompleteCheckin(kDeviceAndroidId,
 755                   kDeviceSecurityToken,
 756                   GServicesSettings::CalculateDigest(settings),
 757                   settings);
 758 }
 759
 760 TEST_F(GCMClientImplCheckinTest, LoadGSettingsFromStore) {
 761   std::map<std::string, std::string> settings;
 762   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
 763   settings["checkin_url"] = "http://alternative.url/checkin";
 764   settings["gcm_hostname"] = "alternative.gcm.host";
 765   settings["gcm_secure_port"] = "7777";
 766   settings["gcm_registration_url"] = "http://alternative.url/registration";
 767   CompleteCheckin(kDeviceAndroidId,
 768                   kDeviceSecurityToken,
 769                   GServicesSettings::CalculateDigest(settings),
 770                   settings);
 771
 772   BuildGCMClient(base::TimeDelta());
 773   InitializeGCMClient();
 774   StartGCMClient();
 775
 776   EXPECT_EQ(base::TimeDelta::FromSeconds(kSettingsCheckinInterval),
 777             gservices_settings().GetCheckinInterval());
 778   EXPECT_EQ(GURL("http://alternative.url/checkin"),
 779             gservices_settings().GetCheckinURL());
 780   EXPECT_EQ(GURL("http://alternative.url/registration"),
 781             gservices_settings().GetRegistrationURL());
 782   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
 783             gservices_settings().GetMCSMainEndpoint());
 784   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
 785             gservices_settings().GetMCSFallbackEndpoint());
 786 }
 787
 788 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
 789 public:
 790   GCMClientImplStartAndStopTest();
 791   virtual ~GCMClientImplStartAndStopTest();
 792
 793   virtual void SetUp() OVERRIDE;
 794 };
 795
 796 GCMClientImplStartAndStopTest::GCMClientImplStartAndStopTest() {
 797 }
 798
 799 GCMClientImplStartAndStopTest::~GCMClientImplStartAndStopTest() {
 800 }
 801
 802 void GCMClientImplStartAndStopTest::SetUp() {
 803   testing::Test::SetUp();
 804   ASSERT_TRUE(CreateUniqueTempDir());
 805   InitializeLoop();
 806   BuildGCMClient(base::TimeDelta());
 807   InitializeGCMClient();
 808 }
 809
 810 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestart) {
 811   // Start the GCM and wait until it is ready.
 812   gcm_client()->Start();
 813   PumpLoopUntilIdle();
 814
 815   // Stop the GCM.
 816   gcm_client()->Stop();
 817   PumpLoopUntilIdle();
 818
 819   // Restart the GCM.
 820   gcm_client()->Start();
 821   PumpLoopUntilIdle();
 822 }
 823
 824 TEST_F(GCMClientImplStartAndStopTest, StartAndStopImmediately) {
 825   // Start the GCM and then stop it immediately.
 826   gcm_client()->Start();
 827   gcm_client()->Stop();
 828
 829   PumpLoopUntilIdle();
 830 }
 831
 832 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestartImmediately) {
 833   // Start the GCM and then stop and restart it immediately.
 834   gcm_client()->Start();
 835   gcm_client()->Stop();
 836   gcm_client()->Start();
 837
 838   PumpLoopUntilIdle();
 839 }
 840
 841 }  // namespace gcm