chrome/browser/services/gcm/gcm_service_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 "chrome/browser/services/gcm/gcm_service.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/location.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/run_loop.h"
  13 #include "base/strings/string_util.h"
  14 #include "chrome/browser/services/gcm/fake_gcm_client_factory.h"
  15 #include "chrome/browser/services/gcm/gcm_client_mock.h"
  16 #include "components/gcm_driver/gcm_app_handler.h"
  17 #include "components/gcm_driver/gcm_client_factory.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/test/test_browser_thread_bundle.h"
  20 #include "google_apis/gaia/fake_identity_provider.h"
  21 #include "google_apis/gaia/fake_oauth2_token_service.h"
  22 #include "google_apis/gcm/base/fake_encryptor.h"
  23 #include "net/url_request/url_request_context_getter.h"
  24 #include "net/url_request/url_request_test_util.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 namespace gcm {
  28
  29 namespace {
  30
  31 const char kTestAccountID1[] = "user1@example.com";
  32 const char kTestAccountID2[] = "user2@example.com";
  33 const char kTestAccountID3[] = "user3@example.com";
  34 const char kTestAppID1[] = "TestApp1";
  35 const char kTestAppID2[] = "TestApp2";
  36 const char kUserID1[] = "user1";
  37 const char kUserID2[] = "user2";
  38
  39 void PumpCurrentLoop() {
  40   base::MessageLoop::ScopedNestableTaskAllower
  41       nestable_task_allower(base::MessageLoop::current());
  42   base::RunLoop().RunUntilIdle();
  43 }
  44
  45 void PumpUILoop() {
  46   PumpCurrentLoop();
  47 }
  48
  49 void PumpIOLoop() {
  50   base::RunLoop run_loop;
  51   content::BrowserThread::PostTaskAndReply(content::BrowserThread::IO,
  52                                            FROM_HERE,
  53                                            base::Bind(&PumpCurrentLoop),
  54                                            run_loop.QuitClosure());
  55   run_loop.Run();
  56 }
  57
  58 std::vector<std::string> ToSenderList(const std::string& sender_ids) {
  59   std::vector<std::string> senders;
  60   Tokenize(sender_ids, ",", &senders);
  61   return senders;
  62 }
  63
  64 class FakeGCMAppHandler : public GCMAppHandler {
  65  public:
  66   enum Event {
  67     NO_EVENT,
  68     MESSAGE_EVENT,
  69     MESSAGES_DELETED_EVENT,
  70     SEND_ERROR_EVENT
  71   };
  72
  73   FakeGCMAppHandler();
  74   virtual ~FakeGCMAppHandler();
  75
  76   const Event& received_event() const { return received_event_; }
  77   const std::string& app_id() const { return app_id_; }
  78   const GCMClient::IncomingMessage& message() const { return message_; }
  79   const GCMClient::SendErrorDetails& send_error_details() const {
  80     return send_error_details_;
  81   }
  82
  83   void WaitForNotification();
  84
  85   // GCMAppHandler:
  86   virtual void ShutdownHandler() OVERRIDE;
  87   virtual void OnMessage(const std::string& app_id,
  88                          const GCMClient::IncomingMessage& message) OVERRIDE;
  89   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
  90   virtual void OnSendError(
  91       const std::string& app_id,
  92       const GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
  93
  94  private:
  95   void ClearResults();
  96
  97   scoped_ptr<base::RunLoop> run_loop_;
  98
  99   Event received_event_;
 100   std::string app_id_;
 101   GCMClient::IncomingMessage message_;
 102   GCMClient::SendErrorDetails send_error_details_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(FakeGCMAppHandler);
 105 };
 106
 107 class TestGCMService : public GCMService {
 108  public:
 109   TestGCMService(
 110       bool start_automatically,
 111       scoped_ptr<IdentityProvider> identity_provider,
 112       const scoped_refptr<net::URLRequestContextGetter>& request_context);
 113   virtual ~TestGCMService();
 114
 115  protected:
 116   // GCMService:
 117   virtual bool ShouldStartAutomatically() const OVERRIDE;
 118   virtual base::FilePath GetStorePath() const OVERRIDE;
 119   virtual scoped_refptr<net::URLRequestContextGetter>
 120       GetURLRequestContextGetter() const OVERRIDE;
 121
 122  private:
 123   base::ScopedTempDir temp_dir_;
 124   scoped_refptr<net::URLRequestContextGetter> request_context_;
 125   const bool start_automatically_;
 126
 127   DISALLOW_COPY_AND_ASSIGN(TestGCMService);
 128 };
 129
 130 FakeGCMAppHandler::FakeGCMAppHandler() : received_event_(NO_EVENT) {
 131 }
 132
 133 FakeGCMAppHandler::~FakeGCMAppHandler() {
 134 }
 135
 136 void FakeGCMAppHandler::WaitForNotification() {
 137   run_loop_.reset(new base::RunLoop);
 138   run_loop_->Run();
 139   run_loop_.reset();
 140 }
 141
 142 void FakeGCMAppHandler::ShutdownHandler() {
 143 }
 144
 145 void FakeGCMAppHandler::OnMessage(const std::string& app_id,
 146                                   const GCMClient::IncomingMessage& message) {
 147   ClearResults();
 148   received_event_ = MESSAGE_EVENT;
 149   app_id_ = app_id;
 150   message_ = message;
 151   if (run_loop_)
 152     run_loop_->Quit();
 153 }
 154
 155 void FakeGCMAppHandler::OnMessagesDeleted(const std::string& app_id) {
 156   ClearResults();
 157   received_event_ = MESSAGES_DELETED_EVENT;
 158   app_id_ = app_id;
 159   if (run_loop_)
 160     run_loop_->Quit();
 161 }
 162
 163 void FakeGCMAppHandler::OnSendError(
 164     const std::string& app_id,
 165     const GCMClient::SendErrorDetails& send_error_details) {
 166   ClearResults();
 167   received_event_ = SEND_ERROR_EVENT;
 168   app_id_ = app_id;
 169   send_error_details_ = send_error_details;
 170   if (run_loop_)
 171     run_loop_->Quit();
 172 }
 173
 174 void FakeGCMAppHandler::ClearResults() {
 175   received_event_ = NO_EVENT;
 176   app_id_.clear();
 177   message_ = GCMClient::IncomingMessage();
 178   send_error_details_ = GCMClient::SendErrorDetails();
 179 }
 180
 181 TestGCMService::TestGCMService(
 182     bool start_automatically,
 183     scoped_ptr<IdentityProvider> identity_provider,
 184     const scoped_refptr<net::URLRequestContextGetter>& request_context)
 185     : GCMService(identity_provider.Pass()),
 186       request_context_(request_context),
 187       start_automatically_(start_automatically) {
 188   if (!temp_dir_.CreateUniqueTempDir())
 189     ADD_FAILURE();
 190 }
 191
 192 TestGCMService::~TestGCMService() {
 193 }
 194
 195 bool TestGCMService::ShouldStartAutomatically() const {
 196   return start_automatically_;
 197 }
 198
 199 base::FilePath TestGCMService::GetStorePath() const {
 200   return temp_dir_.path();
 201 }
 202
 203 scoped_refptr<net::URLRequestContextGetter>
 204 TestGCMService::GetURLRequestContextGetter() const {
 205   return request_context_;
 206 }
 207
 208 }  // namespace
 209
 210 class TestGCMServiceWrapper {
 211  public:
 212   enum WaitToFinish {
 213     DO_NOT_WAIT,
 214     WAIT
 215   };
 216
 217   explicit TestGCMServiceWrapper(
 218       const scoped_refptr<net::URLRequestContextGetter>& request_context);
 219   ~TestGCMServiceWrapper();
 220
 221   TestGCMService* service() { return service_.get(); }
 222   FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); }
 223   const std::string& registration_id() const { return registration_id_; }
 224   GCMClient::Result registration_result() const { return registration_result_; }
 225   const std::string& send_message_id() const { return send_message_id_; }
 226   GCMClient::Result send_result() const { return send_result_; }
 227   GCMClient::Result unregistration_result() const {
 228     return unregistration_result_;
 229   }
 230
 231   void ClearRegistrationResult();
 232   void ClearUnregistrationResult();
 233
 234   bool ServiceHasAppHandlers() const;
 235   GCMClientMock* GetGCMClient();
 236
 237   void CreateService(bool start_automatically,
 238                      GCMClientMock::StartMode gcm_client_start_mode);
 239
 240   void SignIn(const std::string& account_id);
 241   void SignOut();
 242
 243   void Register(const std::string& app_id,
 244                 const std::vector<std::string>& sender_ids,
 245                 WaitToFinish wait_to_finish);
 246   void Send(const std::string& app_id,
 247             const std::string& receiver_id,
 248             const GCMClient::OutgoingMessage& message,
 249             WaitToFinish wait_to_finish);
 250   void Unregister(const std::string& app_id, WaitToFinish wait_to_finish);
 251
 252   void WaitForAsyncOperation();
 253
 254  private:
 255   void RegisterCompleted(const std::string& registration_id,
 256                          GCMClient::Result result);
 257   void SendCompleted(const std::string& message_id, GCMClient::Result result);
 258   void UnregisterCompleted(GCMClient::Result result);
 259
 260   scoped_refptr<net::URLRequestContextGetter> request_context_;
 261   FakeOAuth2TokenService token_service_;
 262   scoped_ptr<FakeIdentityProvider> identity_provider_owner_;
 263   FakeIdentityProvider* identity_provider_;
 264   scoped_ptr<TestGCMService> service_;
 265   scoped_ptr<FakeGCMAppHandler> gcm_app_handler_;
 266
 267   base::Closure async_operation_completed_callback_;
 268
 269   std::string registration_id_;
 270   GCMClient::Result registration_result_;
 271   std::string send_message_id_;
 272   GCMClient::Result send_result_;
 273   GCMClient::Result unregistration_result_;
 274
 275   DISALLOW_COPY_AND_ASSIGN(TestGCMServiceWrapper);
 276 };
 277
 278 TestGCMServiceWrapper::TestGCMServiceWrapper(
 279     const scoped_refptr<net::URLRequestContextGetter>& request_context)
 280     : request_context_(request_context),
 281       identity_provider_(NULL),
 282       registration_result_(GCMClient::UNKNOWN_ERROR),
 283       send_result_(GCMClient::UNKNOWN_ERROR),
 284       unregistration_result_(GCMClient::UNKNOWN_ERROR) {
 285   identity_provider_owner_.reset(new FakeIdentityProvider(&token_service_));
 286   identity_provider_ = identity_provider_owner_.get();
 287 }
 288
 289 TestGCMServiceWrapper::~TestGCMServiceWrapper() {
 290   if (!service_)
 291     return;
 292
 293   service_->ShutdownService();
 294   service_.reset();
 295   PumpIOLoop();
 296 }
 297
 298 void TestGCMServiceWrapper::ClearRegistrationResult() {
 299   registration_id_.clear();
 300   registration_result_ = GCMClient::UNKNOWN_ERROR;
 301 }
 302
 303 void TestGCMServiceWrapper::ClearUnregistrationResult() {
 304   unregistration_result_ = GCMClient::UNKNOWN_ERROR;
 305 }
 306
 307 bool TestGCMServiceWrapper::ServiceHasAppHandlers() const {
 308   return !service_->app_handlers_.empty();
 309 }
 310
 311 GCMClientMock* TestGCMServiceWrapper::GetGCMClient() {
 312   return static_cast<GCMClientMock*>(service_->GetGCMClientForTesting());
 313 }
 314
 315 void TestGCMServiceWrapper::CreateService(
 316     bool start_automatically,
 317     GCMClientMock::StartMode gcm_client_start_mode) {
 318   service_.reset(new TestGCMService(
 319       start_automatically,
 320       identity_provider_owner_.PassAs<IdentityProvider>(),
 321       request_context_));
 322   service_->Initialize(scoped_ptr<GCMClientFactory>(
 323       new FakeGCMClientFactory(gcm_client_start_mode)));
 324
 325   gcm_app_handler_.reset(new FakeGCMAppHandler);
 326   service_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
 327   service_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 328 }
 329
 330 void TestGCMServiceWrapper::SignIn(const std::string& account_id) {
 331   token_service_.AddAccount(account_id);
 332   identity_provider_->LogIn(account_id);
 333   PumpIOLoop();
 334   PumpUILoop();
 335 }
 336
 337 void TestGCMServiceWrapper::SignOut() {
 338   identity_provider_->LogOut();
 339   PumpIOLoop();
 340   PumpUILoop();
 341 }
 342
 343 void TestGCMServiceWrapper::Register(const std::string& app_id,
 344                                      const std::vector<std::string>& sender_ids,
 345                                      WaitToFinish wait_to_finish) {
 346   base::RunLoop run_loop;
 347   async_operation_completed_callback_ = run_loop.QuitClosure();
 348   service_->Register(app_id,
 349                      sender_ids,
 350                      base::Bind(&TestGCMServiceWrapper::RegisterCompleted,
 351                                 base::Unretained(this)));
 352   if (wait_to_finish == WAIT)
 353     run_loop.Run();
 354 }
 355
 356 void TestGCMServiceWrapper::Send(const std::string& app_id,
 357                                  const std::string& receiver_id,
 358                                  const GCMClient::OutgoingMessage& message,
 359                                  WaitToFinish wait_to_finish) {
 360   base::RunLoop run_loop;
 361   async_operation_completed_callback_ = run_loop.QuitClosure();
 362   service_->Send(app_id,
 363                  receiver_id,
 364                  message,
 365                  base::Bind(&TestGCMServiceWrapper::SendCompleted,
 366                             base::Unretained(this)));
 367   if (wait_to_finish == WAIT)
 368     run_loop.Run();
 369 }
 370
 371 void TestGCMServiceWrapper::Unregister(const std::string& app_id,
 372                                        WaitToFinish wait_to_finish) {
 373   base::RunLoop run_loop;
 374   async_operation_completed_callback_ = run_loop.QuitClosure();
 375   service_->Unregister(app_id,
 376                        base::Bind(&TestGCMServiceWrapper::UnregisterCompleted,
 377                                   base::Unretained(this)));
 378   if (wait_to_finish == WAIT)
 379     run_loop.Run();
 380 }
 381
 382 void TestGCMServiceWrapper::WaitForAsyncOperation() {
 383   base::RunLoop run_loop;
 384   async_operation_completed_callback_ = run_loop.QuitClosure();
 385   run_loop.Run();
 386 }
 387
 388 void TestGCMServiceWrapper::RegisterCompleted(
 389     const std::string& registration_id,
 390     GCMClient::Result result) {
 391   registration_id_ = registration_id;
 392   registration_result_ = result;
 393   if (!async_operation_completed_callback_.is_null())
 394     async_operation_completed_callback_.Run();
 395 }
 396
 397 void TestGCMServiceWrapper::SendCompleted(const std::string& message_id,
 398                                           GCMClient::Result result) {
 399   send_message_id_ = message_id;
 400   send_result_ = result;
 401   if (!async_operation_completed_callback_.is_null())
 402     async_operation_completed_callback_.Run();
 403 }
 404
 405 void TestGCMServiceWrapper::UnregisterCompleted(GCMClient::Result result) {
 406   unregistration_result_ = result;
 407   if (!async_operation_completed_callback_.is_null())
 408     async_operation_completed_callback_.Run();
 409 }
 410
 411 class GCMServiceTest : public testing::Test {
 412  protected:
 413   GCMServiceTest();
 414   virtual ~GCMServiceTest();
 415
 416   // testing::Test:
 417   virtual void SetUp() OVERRIDE;
 418   virtual void TearDown() OVERRIDE;
 419
 420   scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_;
 421   scoped_refptr<net::URLRequestContextGetter> request_context_;
 422   scoped_ptr<TestGCMServiceWrapper> wrapper_;
 423
 424  private:
 425   DISALLOW_COPY_AND_ASSIGN(GCMServiceTest);
 426 };
 427
 428 GCMServiceTest::GCMServiceTest() {
 429 }
 430
 431 GCMServiceTest::~GCMServiceTest() {
 432 }
 433
 434 void GCMServiceTest::SetUp() {
 435   thread_bundle_.reset(new content::TestBrowserThreadBundle(
 436       content::TestBrowserThreadBundle::REAL_IO_THREAD));
 437   request_context_ = new net::TestURLRequestContextGetter(
 438       content::BrowserThread::GetMessageLoopProxyForThread(
 439           content::BrowserThread::IO));
 440   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
 441 }
 442
 443 void GCMServiceTest::TearDown() {
 444   wrapper_.reset();
 445 }
 446
 447 TEST_F(GCMServiceTest, CreateGCMServiceBeforeSignIn) {
 448   // Create CreateGMCService first.
 449   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 450   EXPECT_FALSE(wrapper_->service()->IsStarted());
 451
 452   // Sign in. This will kick off the check-in.
 453   wrapper_->SignIn(kTestAccountID1);
 454   EXPECT_TRUE(wrapper_->service()->IsStarted());
 455 }
 456
 457 TEST_F(GCMServiceTest, CreateGCMServiceAfterSignIn) {
 458   // Sign in. This will not initiate the check-in.
 459   wrapper_->SignIn(kTestAccountID1);
 460
 461   // Create GCMeService after sign-in.
 462   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 463   EXPECT_TRUE(wrapper_->service()->IsStarted());
 464 }
 465
 466 TEST_F(GCMServiceTest, Shutdown) {
 467   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 468   EXPECT_TRUE(wrapper_->ServiceHasAppHandlers());
 469
 470   wrapper_->service()->ShutdownService();
 471   EXPECT_FALSE(wrapper_->ServiceHasAppHandlers());
 472 }
 473
 474 TEST_F(GCMServiceTest, SignInAndSignOutUnderPositiveChannelSignal) {
 475   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 476   wrapper_->SignIn(kTestAccountID1);
 477
 478   // GCMClient should be loaded.
 479   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 480   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 481
 482   wrapper_->SignOut();
 483
 484   // GCMClient should be checked out.
 485   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 486   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 487 }
 488
 489 TEST_F(GCMServiceTest, SignInAndSignOutUnderNonPositiveChannelSignal) {
 490   // Non-positive channel signal will prevent GCMClient from checking in during
 491   // sign-in.
 492   wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
 493   wrapper_->SignIn(kTestAccountID1);
 494
 495   // GCMClient should not be loaded.
 496   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 497   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 498
 499   wrapper_->SignOut();
 500
 501   // Check-out should still be performed.
 502   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 503   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 504 }
 505
 506 TEST_F(GCMServiceTest, SignOutAndThenSignIn) {
 507   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 508   wrapper_->SignIn(kTestAccountID1);
 509
 510   // GCMClient should be loaded.
 511   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 512   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 513
 514   wrapper_->SignOut();
 515
 516   // GCMClient should be checked out.
 517   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 518   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 519
 520   // Sign-in with a different account.
 521   wrapper_->SignIn(kTestAccountID2);
 522
 523   // GCMClient should be loaded again.
 524   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 525   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 526 }
 527
 528 TEST_F(GCMServiceTest, StopAndRestartGCM) {
 529   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 530   wrapper_->SignIn(kTestAccountID1);
 531
 532   // GCMClient should be loaded.
 533   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 534   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 535
 536   // Stops the GCM.
 537   wrapper_->service()->Stop();
 538   PumpIOLoop();
 539   PumpUILoop();
 540
 541   // GCMClient should be stopped.
 542   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 543   EXPECT_EQ(GCMClientMock::STOPPED, wrapper_->GetGCMClient()->status());
 544
 545   // Restarts the GCM.
 546   wrapper_->service()->Start();
 547   PumpIOLoop();
 548   PumpUILoop();
 549
 550   // GCMClient should be loaded.
 551   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 552   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 553
 554   // Stops the GCM.
 555   wrapper_->service()->Stop();
 556   PumpIOLoop();
 557   PumpUILoop();
 558
 559   // GCMClient should be stopped.
 560   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 561   EXPECT_EQ(GCMClientMock::STOPPED, wrapper_->GetGCMClient()->status());
 562
 563   // Sign out.
 564   wrapper_->SignOut();
 565
 566   // GCMClient should be checked out.
 567   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 568   EXPECT_EQ(GCMClientMock::CHECKED_OUT, wrapper_->GetGCMClient()->status());
 569 }
 570
 571 TEST_F(GCMServiceTest, RegisterWhenNotSignedIn) {
 572   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 573
 574   std::vector<std::string> sender_ids;
 575   sender_ids.push_back("sender1");
 576   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 577
 578   EXPECT_TRUE(wrapper_->registration_id().empty());
 579   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->registration_result());
 580 }
 581
 582 TEST_F(GCMServiceTest, RegisterUnderNonPositiveChannelSignal) {
 583   // Non-positive channel signal will prevent GCMClient from checking in during
 584   // sign-in.
 585   wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
 586   wrapper_->SignIn(kTestAccountID1);
 587
 588   // GCMClient should not be checked in.
 589   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 590   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 591
 592   // Invoking register will make GCMClient checked in.
 593   std::vector<std::string> sender_ids;
 594   sender_ids.push_back("sender1");
 595   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 596
 597   // GCMClient should be checked in.
 598   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 599   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 600
 601   // Registration should succeed.
 602   const std::string expected_registration_id =
 603       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 604   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
 605   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 606 }
 607
 608 TEST_F(GCMServiceTest, SendWhenNotSignedIn) {
 609   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 610
 611   GCMClient::OutgoingMessage message;
 612   message.id = "1";
 613   message.data["key1"] = "value1";
 614   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 615
 616   EXPECT_TRUE(wrapper_->send_message_id().empty());
 617   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
 618 }
 619
 620 TEST_F(GCMServiceTest, SendUnderNonPositiveChannelSignal) {
 621   // Non-positive channel signal will prevent GCMClient from checking in during
 622   // sign-in.
 623   wrapper_->CreateService(false, GCMClientMock::NO_DELAY_START);
 624   wrapper_->SignIn(kTestAccountID1);
 625
 626   // GCMClient should not be checked in.
 627   EXPECT_FALSE(wrapper_->service()->IsGCMClientReady());
 628   EXPECT_EQ(GCMClientMock::UNINITIALIZED, wrapper_->GetGCMClient()->status());
 629
 630   // Invoking send will make GCMClient checked in.
 631   GCMClient::OutgoingMessage message;
 632   message.id = "1";
 633   message.data["key1"] = "value1";
 634   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 635
 636   // GCMClient should be checked in.
 637   EXPECT_TRUE(wrapper_->service()->IsGCMClientReady());
 638   EXPECT_EQ(GCMClientMock::STARTED, wrapper_->GetGCMClient()->status());
 639
 640   // Sending should succeed.
 641   EXPECT_EQ(message.id, wrapper_->send_message_id());
 642   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 643 }
 644
 645 // Tests a single instance of GCMService.
 646 class GCMServiceSingleInstanceTest : public GCMServiceTest {
 647  public:
 648   GCMServiceSingleInstanceTest();
 649   virtual ~GCMServiceSingleInstanceTest();
 650
 651   // GCMServiceTest:
 652   virtual void SetUp() OVERRIDE;
 653
 654  private:
 655   DISALLOW_COPY_AND_ASSIGN(GCMServiceSingleInstanceTest);
 656 };
 657
 658 GCMServiceSingleInstanceTest::GCMServiceSingleInstanceTest() {
 659 }
 660
 661 GCMServiceSingleInstanceTest::~GCMServiceSingleInstanceTest() {
 662 }
 663
 664 void GCMServiceSingleInstanceTest::SetUp() {
 665   GCMServiceTest::SetUp();
 666
 667   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
 668   wrapper_->SignIn(kTestAccountID1);
 669 }
 670
 671 TEST_F(GCMServiceSingleInstanceTest, Register) {
 672   std::vector<std::string> sender_ids;
 673   sender_ids.push_back("sender1");
 674   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 675   const std::string expected_registration_id =
 676       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 677
 678   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
 679   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 680 }
 681
 682 TEST_F(GCMServiceSingleInstanceTest, RegisterError) {
 683   std::vector<std::string> sender_ids;
 684   sender_ids.push_back("sender1@error");
 685   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 686
 687   EXPECT_TRUE(wrapper_->registration_id().empty());
 688   EXPECT_NE(GCMClient::SUCCESS, wrapper_->registration_result());
 689 }
 690
 691 TEST_F(GCMServiceSingleInstanceTest, RegisterAgainWithSameSenderIDs) {
 692   std::vector<std::string> sender_ids;
 693   sender_ids.push_back("sender1");
 694   sender_ids.push_back("sender2");
 695   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 696   const std::string expected_registration_id =
 697       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 698
 699   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
 700   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 701
 702   // Clears the results the would be set by the Register callback in preparation
 703   // to call register 2nd time.
 704   wrapper_->ClearRegistrationResult();
 705
 706   // Calling register 2nd time with the same set of sender IDs but different
 707   // ordering will get back the same registration ID.
 708   std::vector<std::string> another_sender_ids;
 709   another_sender_ids.push_back("sender2");
 710   another_sender_ids.push_back("sender1");
 711   wrapper_->Register(kTestAppID1,
 712                      another_sender_ids,
 713                      TestGCMServiceWrapper::WAIT);
 714
 715   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
 716   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 717 }
 718
 719 TEST_F(GCMServiceSingleInstanceTest, RegisterAgainWithDifferentSenderIDs) {
 720   std::vector<std::string> sender_ids;
 721   sender_ids.push_back("sender1");
 722   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 723   const std::string expected_registration_id =
 724       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 725
 726   EXPECT_EQ(expected_registration_id, wrapper_->registration_id());
 727   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 728
 729   // Make sender IDs different.
 730   sender_ids.push_back("sender2");
 731   const std::string expected_registration_id2 =
 732       GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids);
 733
 734   // Calling register 2nd time with the different sender IDs will get back a new
 735   // registration ID.
 736   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 737   EXPECT_EQ(expected_registration_id2, wrapper_->registration_id());
 738   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 739 }
 740
 741 TEST_F(GCMServiceSingleInstanceTest, GCMClientNotReadyBeforeRegistration) {
 742   // Make GCMClient not ready initially.
 743   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
 744   wrapper_->CreateService(true, GCMClientMock::DELAY_START);
 745   wrapper_->SignIn(kTestAccountID1);
 746
 747   // The registration is on hold until GCMClient is ready.
 748   std::vector<std::string> sender_ids;
 749   sender_ids.push_back("sender1");
 750   wrapper_->Register(kTestAppID1,
 751                      sender_ids,
 752                      TestGCMServiceWrapper::DO_NOT_WAIT);
 753   PumpIOLoop();
 754   PumpUILoop();
 755   EXPECT_TRUE(wrapper_->registration_id().empty());
 756   EXPECT_EQ(GCMClient::UNKNOWN_ERROR, wrapper_->registration_result());
 757
 758   // Register operation will be invoked after GCMClient becomes ready.
 759   wrapper_->GetGCMClient()->PerformDelayedLoading();
 760   wrapper_->WaitForAsyncOperation();
 761   EXPECT_FALSE(wrapper_->registration_id().empty());
 762   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 763 }
 764
 765 TEST_F(GCMServiceSingleInstanceTest, RegisterAfterSignOut) {
 766   // This will trigger check-out.
 767   wrapper_->SignOut();
 768
 769   std::vector<std::string> sender_ids;
 770   sender_ids.push_back("sender1");
 771   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 772
 773   EXPECT_TRUE(wrapper_->registration_id().empty());
 774   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->registration_result());
 775 }
 776
 777 TEST_F(GCMServiceSingleInstanceTest, UnregisterExplicitly) {
 778   std::vector<std::string> sender_ids;
 779   sender_ids.push_back("sender1");
 780   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 781
 782   EXPECT_FALSE(wrapper_->registration_id().empty());
 783   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 784
 785   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
 786
 787   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
 788 }
 789
 790 TEST_F(GCMServiceSingleInstanceTest, UnregisterWhenAsyncOperationPending) {
 791   std::vector<std::string> sender_ids;
 792   sender_ids.push_back("sender1");
 793   // First start registration without waiting for it to complete.
 794   wrapper_->Register(kTestAppID1,
 795                      sender_ids,
 796                      TestGCMServiceWrapper::DO_NOT_WAIT);
 797
 798   // Test that unregistration fails with async operation pending when there is a
 799   // registration already in progress.
 800   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
 801   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 802             wrapper_->unregistration_result());
 803
 804   // Complete the unregistration.
 805   wrapper_->WaitForAsyncOperation();
 806   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 807
 808   // Start unregistration without waiting for it to complete. This time no async
 809   // operation is pending.
 810   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::DO_NOT_WAIT);
 811
 812   // Test that unregistration fails with async operation pending when there is
 813   // an unregistration already in progress.
 814   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::WAIT);
 815   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 816             wrapper_->unregistration_result());
 817   wrapper_->ClearUnregistrationResult();
 818
 819   // Complete unregistration.
 820   wrapper_->WaitForAsyncOperation();
 821   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
 822 }
 823
 824 TEST_F(GCMServiceSingleInstanceTest, RegisterWhenAsyncOperationPending) {
 825   std::vector<std::string> sender_ids;
 826   sender_ids.push_back("sender1");
 827   // First start registration without waiting for it to complete.
 828   wrapper_->Register(kTestAppID1,
 829                      sender_ids,
 830                      TestGCMServiceWrapper::DO_NOT_WAIT);
 831
 832   // Test that registration fails with async operation pending when there is a
 833   // registration already in progress.
 834   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 835   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 836             wrapper_->registration_result());
 837   wrapper_->ClearRegistrationResult();
 838
 839   // Complete the registration.
 840   wrapper_->WaitForAsyncOperation();
 841   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 842
 843   // Start unregistration without waiting for it to complete. This time no async
 844   // operation is pending.
 845   wrapper_->Unregister(kTestAppID1, TestGCMServiceWrapper::DO_NOT_WAIT);
 846
 847   // Test that registration fails with async operation pending when there is an
 848   // unregistration already in progress.
 849   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 850   EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING,
 851             wrapper_->registration_result());
 852
 853   // Complete the first unregistration expecting success.
 854   wrapper_->WaitForAsyncOperation();
 855   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->unregistration_result());
 856
 857   // Test that it is ok to register again after unregistration.
 858   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
 859   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
 860 }
 861
 862 TEST_F(GCMServiceSingleInstanceTest, Send) {
 863   GCMClient::OutgoingMessage message;
 864   message.id = "1";
 865   message.data["key1"] = "value1";
 866   message.data["key2"] = "value2";
 867   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 868
 869   EXPECT_EQ(message.id, wrapper_->send_message_id());
 870   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 871 }
 872
 873 TEST_F(GCMServiceSingleInstanceTest, GCMClientNotReadyBeforeSending) {
 874   // Make GCMClient not ready initially.
 875   wrapper_.reset(new TestGCMServiceWrapper(request_context_));
 876   wrapper_->CreateService(true, GCMClientMock::DELAY_START);
 877   wrapper_->SignIn(kTestAccountID1);
 878
 879   // The sending is on hold until GCMClient is ready.
 880   GCMClient::OutgoingMessage message;
 881   message.id = "1";
 882   message.data["key1"] = "value1";
 883   message.data["key2"] = "value2";
 884   wrapper_->Send(kTestAppID1,
 885                  kUserID1,
 886                  message,
 887                  TestGCMServiceWrapper::DO_NOT_WAIT);
 888   PumpIOLoop();
 889   PumpUILoop();
 890
 891   EXPECT_TRUE(wrapper_->send_message_id().empty());
 892   EXPECT_EQ(GCMClient::UNKNOWN_ERROR, wrapper_->send_result());
 893
 894   // Send operation will be invoked after GCMClient becomes ready.
 895   wrapper_->GetGCMClient()->PerformDelayedLoading();
 896   wrapper_->WaitForAsyncOperation();
 897   EXPECT_EQ(message.id, wrapper_->send_message_id());
 898   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 899 }
 900
 901 TEST_F(GCMServiceSingleInstanceTest, SendAfterSignOut) {
 902   // This will trigger check-out.
 903   wrapper_->SignOut();
 904
 905   GCMClient::OutgoingMessage message;
 906   message.id = "1";
 907   message.data["key1"] = "value1";
 908   message.data["key2"] = "value2";
 909   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 910
 911   EXPECT_TRUE(wrapper_->send_message_id().empty());
 912   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
 913 }
 914
 915 TEST_F(GCMServiceSingleInstanceTest, SendError) {
 916   GCMClient::OutgoingMessage message;
 917   // Embedding error in id will tell the mock to simulate the send error.
 918   message.id = "1@error";
 919   message.data["key1"] = "value1";
 920   message.data["key2"] = "value2";
 921   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
 922
 923   EXPECT_EQ(message.id, wrapper_->send_message_id());
 924   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
 925
 926   // Wait for the send error.
 927   wrapper_->gcm_app_handler()->WaitForNotification();
 928   EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT,
 929             wrapper_->gcm_app_handler()->received_event());
 930   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
 931   EXPECT_EQ(message.id,
 932             wrapper_->gcm_app_handler()->send_error_details().message_id);
 933   EXPECT_NE(GCMClient::SUCCESS,
 934             wrapper_->gcm_app_handler()->send_error_details().result);
 935   EXPECT_EQ(message.data,
 936             wrapper_->gcm_app_handler()->send_error_details().additional_data);
 937 }
 938
 939 TEST_F(GCMServiceSingleInstanceTest, MessageReceived) {
 940   wrapper_->Register(kTestAppID1,
 941                      ToSenderList("sender"),
 942                      TestGCMServiceWrapper::WAIT);
 943   GCMClient::IncomingMessage message;
 944   message.data["key1"] = "value1";
 945   message.data["key2"] = "value2";
 946   message.sender_id = "sender";
 947   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
 948   wrapper_->gcm_app_handler()->WaitForNotification();
 949   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
 950             wrapper_->gcm_app_handler()->received_event());
 951   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
 952   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
 953   EXPECT_TRUE(wrapper_->gcm_app_handler()->message().collapse_key.empty());
 954   EXPECT_EQ(message.sender_id,
 955             wrapper_->gcm_app_handler()->message().sender_id);
 956 }
 957
 958 TEST_F(GCMServiceSingleInstanceTest, MessageWithCollapseKeyReceived) {
 959   wrapper_->Register(kTestAppID1,
 960                      ToSenderList("sender"),
 961                      TestGCMServiceWrapper::WAIT);
 962   GCMClient::IncomingMessage message;
 963   message.data["key1"] = "value1";
 964   message.collapse_key = "collapse_key_value";
 965   message.sender_id = "sender";
 966   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
 967   wrapper_->gcm_app_handler()->WaitForNotification();
 968   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
 969             wrapper_->gcm_app_handler()->received_event());
 970   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
 971   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
 972   EXPECT_EQ(message.collapse_key,
 973             wrapper_->gcm_app_handler()->message().collapse_key);
 974 }
 975
 976 TEST_F(GCMServiceSingleInstanceTest, MessagesDeleted) {
 977   wrapper_->GetGCMClient()->DeleteMessages(kTestAppID1);
 978   wrapper_->gcm_app_handler()->WaitForNotification();
 979   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
 980             wrapper_->gcm_app_handler()->received_event());
 981   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
 982 }
 983
 984 // Tests to make sure that concurrent GCMService instances work correctly
 985 // regardless how GCMClient is created.
 986 class GCMServiceMultipleInstanceTest : public GCMServiceTest {
 987  protected:
 988   GCMServiceMultipleInstanceTest();
 989   virtual ~GCMServiceMultipleInstanceTest();
 990
 991   // GCMServiceTest:
 992   virtual void SetUp() OVERRIDE;
 993   virtual void TearDown() OVERRIDE;
 994
 995   scoped_ptr<TestGCMServiceWrapper> wrapper2_;
 996
 997  private:
 998   DISALLOW_COPY_AND_ASSIGN(GCMServiceMultipleInstanceTest);
 999 };
1000
1001 GCMServiceMultipleInstanceTest::GCMServiceMultipleInstanceTest() {
1002 }
1003
1004 GCMServiceMultipleInstanceTest::~GCMServiceMultipleInstanceTest() {
1005 }
1006
1007 void GCMServiceMultipleInstanceTest::SetUp() {
1008   GCMServiceTest::SetUp();
1009
1010   wrapper2_.reset(new TestGCMServiceWrapper(request_context_));
1011
1012   wrapper_->CreateService(true, GCMClientMock::NO_DELAY_START);
1013   wrapper2_->CreateService(true, GCMClientMock::NO_DELAY_START);
1014
1015   // Initiate check-in for each instance.
1016   wrapper_->SignIn(kTestAccountID1);
1017   wrapper2_->SignIn(kTestAccountID2);
1018 }
1019
1020 void GCMServiceMultipleInstanceTest::TearDown() {
1021   wrapper2_.reset();
1022 }
1023
1024 TEST_F(GCMServiceMultipleInstanceTest, Register) {
1025   // Register an app.
1026   std::vector<std::string> sender_ids;
1027   sender_ids.push_back("sender1");
1028   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
1029
1030   // Register the same app in a different instance.
1031   std::vector<std::string> sender_ids2;
1032   sender_ids2.push_back("foo");
1033   sender_ids2.push_back("bar");
1034   wrapper2_->Register(kTestAppID1, sender_ids2, TestGCMServiceWrapper::WAIT);
1035
1036   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids),
1037             wrapper_->registration_id());
1038   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
1039
1040   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids2),
1041             wrapper2_->registration_id());
1042   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
1043
1044   // Register a different app in a different instance.
1045   std::vector<std::string> sender_ids3;
1046   sender_ids3.push_back("sender1");
1047   sender_ids3.push_back("sender2");
1048   sender_ids3.push_back("sender3");
1049   wrapper2_->Register(kTestAppID2, sender_ids3, TestGCMServiceWrapper::WAIT);
1050
1051   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids3),
1052             wrapper2_->registration_id());
1053   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
1054 }
1055
1056 TEST_F(GCMServiceMultipleInstanceTest, Send) {
1057   // Send a message from one app in one instance.
1058   GCMClient::OutgoingMessage message;
1059   message.id = "1";
1060   message.data["key1"] = "value1";
1061   message.data["key2"] = "value2";
1062   wrapper_->Send(kTestAppID1, kUserID1, message, TestGCMServiceWrapper::WAIT);
1063
1064   // Send a message from same app in another instance.
1065   GCMClient::OutgoingMessage message2;
1066   message2.id = "2";
1067   message2.data["foo"] = "bar";
1068   wrapper2_->Send(kTestAppID1, kUserID2, message2, TestGCMServiceWrapper::WAIT);
1069
1070   EXPECT_EQ(message.id, wrapper_->send_message_id());
1071   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
1072
1073   EXPECT_EQ(message2.id, wrapper2_->send_message_id());
1074   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
1075
1076   // Send another message from different app in another instance.
1077   GCMClient::OutgoingMessage message3;
1078   message3.id = "3";
1079   message3.data["hello"] = "world";
1080   wrapper2_->Send(kTestAppID2, kUserID1, message3, TestGCMServiceWrapper::WAIT);
1081
1082   EXPECT_EQ(message3.id, wrapper2_->send_message_id());
1083   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
1084 }
1085
1086 TEST_F(GCMServiceMultipleInstanceTest, MessageReceived) {
1087   wrapper_->Register(kTestAppID1,
1088                      ToSenderList("sender"),
1089                      TestGCMServiceWrapper::WAIT);
1090   wrapper2_->Register(kTestAppID1,
1091                       ToSenderList("sender"),
1092                       TestGCMServiceWrapper::WAIT);
1093   wrapper2_->Register(kTestAppID2,
1094                       ToSenderList("sender2"),
1095                       TestGCMServiceWrapper::WAIT);
1096
1097   // Trigger an incoming message for an app in one instance.
1098   GCMClient::IncomingMessage message;
1099   message.data["key1"] = "value1";
1100   message.data["key2"] = "value2";
1101   message.sender_id = "sender";
1102   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, message);
1103   wrapper_->gcm_app_handler()->WaitForNotification();
1104
1105   // Trigger an incoming message for the same app in another instance.
1106   GCMClient::IncomingMessage message2;
1107   message2.data["foo"] = "bar";
1108   message2.sender_id = "sender";
1109   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID1, message2);
1110   wrapper2_->gcm_app_handler()->WaitForNotification();
1111
1112   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1113             wrapper_->gcm_app_handler()->received_event());
1114   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
1115   EXPECT_EQ(message.data, wrapper_->gcm_app_handler()->message().data);
1116   EXPECT_EQ("sender", wrapper_->gcm_app_handler()->message().sender_id);
1117
1118   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1119             wrapper2_->gcm_app_handler()->received_event());
1120   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
1121   EXPECT_EQ(message2.data, wrapper2_->gcm_app_handler()->message().data);
1122   EXPECT_EQ("sender", wrapper2_->gcm_app_handler()->message().sender_id);
1123
1124   // Trigger another incoming message for a different app in another instance.
1125   GCMClient::IncomingMessage message3;
1126   message3.data["bar1"] = "foo1";
1127   message3.data["bar2"] = "foo2";
1128   message3.sender_id = "sender2";
1129   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID2, message3);
1130   wrapper2_->gcm_app_handler()->WaitForNotification();
1131
1132   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1133             wrapper2_->gcm_app_handler()->received_event());
1134   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
1135   EXPECT_EQ(message3.data, wrapper2_->gcm_app_handler()->message().data);
1136   EXPECT_EQ("sender2", wrapper2_->gcm_app_handler()->message().sender_id);
1137 }
1138
1139 // Test a set of GCM operations on multiple instances.
1140 // 1) Register 1 app in instance 1 and register 2 apps in instance 2;
1141 // 2) Send a message from instance 1;
1142 // 3) Receive a message to an app in instance 1 and receive a message for each
1143 //    of the two apps in instance 2;
1144 // 4) Send a message for each of the two apps in instance 2;
1145 // 5) Sign out of instance 1.
1146 // 6) Register/send stops working for instance 1;
1147 // 7) The app in instance 2 can still receive these events;
1148 // 8) Sign into instance 1 with a different account.
1149 // 9) The message to the newly signed-in account will be routed.
1150 TEST_F(GCMServiceMultipleInstanceTest, Combined) {
1151   // Register an app.
1152   std::vector<std::string> sender_ids;
1153   sender_ids.push_back("sender1");
1154   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
1155
1156   // Register the same app in a different instance.
1157   std::vector<std::string> sender_ids2;
1158   sender_ids2.push_back("foo");
1159   sender_ids2.push_back("bar");
1160   wrapper2_->Register(kTestAppID1, sender_ids2, TestGCMServiceWrapper::WAIT);
1161
1162   // Register a different app in a different instance.
1163   std::vector<std::string> sender_ids3;
1164   sender_ids3.push_back("sender1");
1165   sender_ids3.push_back("sender2");
1166   sender_ids3.push_back("sender3");
1167   wrapper2_->Register(kTestAppID2, sender_ids3, TestGCMServiceWrapper::WAIT);
1168
1169   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids),
1170             wrapper_->registration_id());
1171   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->registration_result());
1172
1173   EXPECT_EQ(GCMClientMock::GetRegistrationIdFromSenderIds(sender_ids3),
1174             wrapper2_->registration_id());
1175   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->registration_result());
1176
1177   // Send a message from one instance.
1178   GCMClient::OutgoingMessage out_message;
1179   out_message.id = "1";
1180   out_message.data["out1"] = "out_data1";
1181   out_message.data["out1_2"] = "out_data1_2";
1182   wrapper_->Send(kTestAppID1,
1183                  kUserID1,
1184                  out_message,
1185                  TestGCMServiceWrapper::WAIT);
1186
1187   EXPECT_EQ(out_message.id, wrapper_->send_message_id());
1188   EXPECT_EQ(GCMClient::SUCCESS, wrapper_->send_result());
1189
1190   // Trigger an incoming message for an app in one instance.
1191   GCMClient::IncomingMessage in_message;
1192   in_message.data["in1"] = "in_data1";
1193   in_message.data["in1_2"] = "in_data1_2";
1194   in_message.sender_id = "sender1";
1195   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message);
1196   wrapper_->gcm_app_handler()->WaitForNotification();
1197
1198   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1199             wrapper_->gcm_app_handler()->received_event());
1200   EXPECT_EQ(kTestAppID1, wrapper_->gcm_app_handler()->app_id());
1201   EXPECT_EQ(in_message.data, wrapper_->gcm_app_handler()->message().data);
1202
1203   // Trigger 2 incoming messages, one for each app respectively, in another
1204   // instance.
1205   GCMClient::IncomingMessage in_message2;
1206   in_message2.data["in2"] = "in_data2";
1207   in_message2.sender_id = "sender3";
1208   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID2, in_message2);
1209
1210   GCMClient::IncomingMessage in_message3;
1211   in_message3.data["in3"] = "in_data3";
1212   in_message3.data["in3_2"] = "in_data3_2";
1213   in_message3.sender_id = "foo";
1214   wrapper2_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message3);
1215
1216   wrapper2_->gcm_app_handler()->WaitForNotification();
1217
1218   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1219             wrapper2_->gcm_app_handler()->received_event());
1220   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
1221   EXPECT_EQ(in_message2.data, wrapper2_->gcm_app_handler()->message().data);
1222
1223   wrapper2_->gcm_app_handler()->WaitForNotification();
1224
1225   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1226             wrapper2_->gcm_app_handler()->received_event());
1227   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
1228   EXPECT_EQ(in_message3.data, wrapper2_->gcm_app_handler()->message().data);
1229
1230   // Send two messages, one for each app respectively, from another instance.
1231   GCMClient::OutgoingMessage out_message2;
1232   out_message2.id = "2";
1233   out_message2.data["out2"] = "out_data2";
1234   wrapper2_->Send(kTestAppID1,
1235                   kUserID2,
1236                   out_message2,
1237                   TestGCMServiceWrapper::WAIT);
1238
1239   GCMClient::OutgoingMessage out_message3;
1240   out_message3.id = "3";
1241   out_message3.data["out3"] = "out_data3";
1242   wrapper2_->Send(kTestAppID2,
1243                   kUserID2,
1244                   out_message3,
1245                   TestGCMServiceWrapper::DO_NOT_WAIT);
1246
1247   EXPECT_EQ(out_message2.id, wrapper2_->send_message_id());
1248   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
1249
1250   wrapper2_->WaitForAsyncOperation();
1251
1252   EXPECT_EQ(out_message3.id, wrapper2_->send_message_id());
1253   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
1254
1255   // Sign out of one instance.
1256   wrapper_->SignOut();
1257
1258   // Register/send stops working for signed-out instance.
1259   wrapper_->Register(kTestAppID1, sender_ids, TestGCMServiceWrapper::WAIT);
1260   EXPECT_TRUE(wrapper_->registration_id().empty());
1261   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->registration_result());
1262
1263   wrapper_->Send(kTestAppID2,
1264                  kUserID2,
1265                  out_message3,
1266                  TestGCMServiceWrapper::WAIT);
1267   EXPECT_TRUE(wrapper_->send_message_id().empty());
1268   EXPECT_EQ(GCMClient::NOT_SIGNED_IN, wrapper_->send_result());
1269
1270   // Deleted messages event will go through for another signed-in instance.
1271   wrapper2_->GetGCMClient()->DeleteMessages(kTestAppID2);
1272   wrapper2_->gcm_app_handler()->WaitForNotification();
1273
1274   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
1275             wrapper2_->gcm_app_handler()->received_event());
1276   EXPECT_EQ(kTestAppID2, wrapper2_->gcm_app_handler()->app_id());
1277
1278   // Send error event will go through for another signed-in instance.
1279   GCMClient::OutgoingMessage out_message4;
1280   out_message4.id = "1@error";
1281   out_message4.data["out4"] = "out_data4";
1282   wrapper2_->Send(kTestAppID1,
1283                   kUserID1,
1284                   out_message4,
1285                   TestGCMServiceWrapper::WAIT);
1286
1287   EXPECT_EQ(out_message4.id, wrapper2_->send_message_id());
1288   EXPECT_EQ(GCMClient::SUCCESS, wrapper2_->send_result());
1289
1290   wrapper2_->gcm_app_handler()->WaitForNotification();
1291   EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT,
1292             wrapper2_->gcm_app_handler()->received_event());
1293   EXPECT_EQ(kTestAppID1, wrapper2_->gcm_app_handler()->app_id());
1294   EXPECT_EQ(out_message4.id,
1295             wrapper2_->gcm_app_handler()->send_error_details().message_id);
1296   EXPECT_NE(GCMClient::SUCCESS,
1297             wrapper2_->gcm_app_handler()->send_error_details().result);
1298   EXPECT_EQ(out_message4.data,
1299             wrapper2_->gcm_app_handler()->send_error_details().additional_data);
1300
1301   // Sign in with a different account.
1302   wrapper_->SignIn(kTestAccountID3);
1303
1304   // Signing out cleared all registrations, so we need to register again.
1305   wrapper_->Register(kTestAppID1,
1306                      ToSenderList("sender1"),
1307                      TestGCMServiceWrapper::WAIT);
1308
1309   // Incoming message will go through for the new signed-in account.
1310   GCMClient::IncomingMessage in_message5;
1311   in_message5.data["in5"] = "in_data5";
1312   in_message5.sender_id = "sender1";
1313   wrapper_->GetGCMClient()->ReceiveMessage(kTestAppID1, in_message5);
1314
1315   wrapper_->gcm_app_handler()->WaitForNotification();
1316
1317   EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT,
1318             wrapper_->gcm_app_handler()->received_event());
1319   EXPECT_EQ(in_message5.data, wrapper_->gcm_app_handler()->message().data);
1320 }
1321
1322 }  // namespace gcm