gcm_driver_desktop_unittest.cc revision 116680a4aac90f2aa7413d9095a592090648e557
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_driver_desktop.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/message_loop/message_loop_proxy.h" 13#include "base/metrics/field_trial.h" 14#include "base/run_loop.h" 15#include "base/strings/string_util.h" 16#include "base/test/test_simple_task_runner.h" 17#include "base/threading/thread.h" 18#include "components/gcm_driver/fake_gcm_app_handler.h" 19#include "components/gcm_driver/fake_gcm_client.h" 20#include "components/gcm_driver/fake_gcm_client_factory.h" 21#include "components/gcm_driver/gcm_app_handler.h" 22#include "components/gcm_driver/gcm_client_factory.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 27namespace gcm { 28 29namespace { 30 31const char kTestAccountID1[] = "user1@example.com"; 32const char kTestAccountID2[] = "user2@example.com"; 33const char kTestAppID1[] = "TestApp1"; 34const char kTestAppID2[] = "TestApp2"; 35const char kUserID1[] = "user1"; 36 37void PumpCurrentLoop() { 38 base::MessageLoop::ScopedNestableTaskAllower 39 nestable_task_allower(base::MessageLoop::current()); 40 base::RunLoop().RunUntilIdle(); 41} 42 43void PumpUILoop() { 44 PumpCurrentLoop(); 45} 46 47std::vector<std::string> ToSenderList(const std::string& sender_ids) { 48 std::vector<std::string> senders; 49 Tokenize(sender_ids, ",", &senders); 50 return senders; 51} 52 53} // namespace 54 55class GCMDriverTest : public testing::Test { 56 public: 57 enum WaitToFinish { 58 DO_NOT_WAIT, 59 WAIT 60 }; 61 62 GCMDriverTest(); 63 virtual ~GCMDriverTest(); 64 65 // testing::Test: 66 virtual void SetUp() OVERRIDE; 67 virtual void TearDown() OVERRIDE; 68 69 GCMDriver* driver() { return driver_.get(); } 70 FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); } 71 const std::string& registration_id() const { return registration_id_; } 72 GCMClient::Result registration_result() const { return registration_result_; } 73 const std::string& send_message_id() const { return send_message_id_; } 74 GCMClient::Result send_result() const { return send_result_; } 75 GCMClient::Result unregistration_result() const { 76 return unregistration_result_; 77 } 78 79 void PumpIOLoop(); 80 81 void ClearResults(); 82 83 bool HasAppHandlers() const; 84 FakeGCMClient* GetGCMClient(); 85 86 void CreateDriver(FakeGCMClient::StartMode gcm_client_start_mode); 87 void AddAppHandlers(); 88 void RemoveAppHandlers(); 89 90 void SignIn(const std::string& account_id); 91 void SignOut(); 92 93 void Register(const std::string& app_id, 94 const std::vector<std::string>& sender_ids, 95 WaitToFinish wait_to_finish); 96 void Send(const std::string& app_id, 97 const std::string& receiver_id, 98 const GCMClient::OutgoingMessage& message, 99 WaitToFinish wait_to_finish); 100 void Unregister(const std::string& app_id, WaitToFinish wait_to_finish); 101 102 void WaitForAsyncOperation(); 103 104 private: 105 void RegisterCompleted(const std::string& registration_id, 106 GCMClient::Result result); 107 void SendCompleted(const std::string& message_id, GCMClient::Result result); 108 void UnregisterCompleted(GCMClient::Result result); 109 110 base::ScopedTempDir temp_dir_; 111 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; 112 base::MessageLoopForUI message_loop_; 113 base::Thread io_thread_; 114 base::FieldTrialList field_trial_list_; 115 scoped_ptr<GCMDriver> driver_; 116 scoped_ptr<FakeGCMAppHandler> gcm_app_handler_; 117 118 base::Closure async_operation_completed_callback_; 119 120 std::string registration_id_; 121 GCMClient::Result registration_result_; 122 std::string send_message_id_; 123 GCMClient::Result send_result_; 124 GCMClient::Result unregistration_result_; 125 126 DISALLOW_COPY_AND_ASSIGN(GCMDriverTest); 127}; 128 129GCMDriverTest::GCMDriverTest() 130 : task_runner_(new base::TestSimpleTaskRunner()), 131 io_thread_("IOThread"), 132 field_trial_list_(NULL), 133 registration_result_(GCMClient::UNKNOWN_ERROR), 134 send_result_(GCMClient::UNKNOWN_ERROR), 135 unregistration_result_(GCMClient::UNKNOWN_ERROR) { 136} 137 138GCMDriverTest::~GCMDriverTest() { 139} 140 141void GCMDriverTest::SetUp() { 142 io_thread_.Start(); 143 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 144} 145 146void GCMDriverTest::TearDown() { 147 if (!driver_) 148 return; 149 150 driver_->Shutdown(); 151 driver_.reset(); 152 PumpIOLoop(); 153 154 io_thread_.Stop(); 155} 156 157void GCMDriverTest::PumpIOLoop() { 158 base::RunLoop run_loop; 159 io_thread_.message_loop_proxy()->PostTaskAndReply( 160 FROM_HERE, 161 base::Bind(&PumpCurrentLoop), 162 run_loop.QuitClosure()); 163 run_loop.Run(); 164} 165 166void GCMDriverTest::ClearResults() { 167 registration_id_.clear(); 168 registration_result_ = GCMClient::UNKNOWN_ERROR; 169 170 send_message_id_.clear(); 171 send_result_ = GCMClient::UNKNOWN_ERROR; 172 173 unregistration_result_ = GCMClient::UNKNOWN_ERROR; 174} 175 176bool GCMDriverTest::HasAppHandlers() const { 177 return !driver_->app_handlers().empty(); 178} 179 180FakeGCMClient* GCMDriverTest::GetGCMClient() { 181 return static_cast<FakeGCMClient*>(driver_->GetGCMClientForTesting()); 182} 183 184void GCMDriverTest::CreateDriver( 185 FakeGCMClient::StartMode gcm_client_start_mode) { 186 scoped_refptr<net::URLRequestContextGetter> request_context = 187 new net::TestURLRequestContextGetter(io_thread_.message_loop_proxy()); 188 // TODO(johnme): Need equivalent test coverage of GCMDriverAndroid. 189 driver_.reset(new GCMDriverDesktop( 190 scoped_ptr<GCMClientFactory>(new FakeGCMClientFactory( 191 gcm_client_start_mode, 192 base::MessageLoopProxy::current(), 193 io_thread_.message_loop_proxy())).Pass(), 194 GCMClient::ChromeBuildInfo(), 195 temp_dir_.path(), 196 request_context, 197 base::MessageLoopProxy::current(), 198 io_thread_.message_loop_proxy(), 199 task_runner_)); 200 201 gcm_app_handler_.reset(new FakeGCMAppHandler); 202} 203 204void GCMDriverTest::AddAppHandlers() { 205 driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get()); 206 driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get()); 207} 208 209void GCMDriverTest::RemoveAppHandlers() { 210 driver_->RemoveAppHandler(kTestAppID1); 211 driver_->RemoveAppHandler(kTestAppID2); 212} 213 214void GCMDriverTest::SignIn(const std::string& account_id) { 215 driver_->OnSignedIn(); 216 PumpIOLoop(); 217 PumpUILoop(); 218} 219 220void GCMDriverTest::SignOut() { 221 driver_->Purge(); 222 PumpIOLoop(); 223 PumpUILoop(); 224} 225 226void GCMDriverTest::Register(const std::string& app_id, 227 const std::vector<std::string>& sender_ids, 228 WaitToFinish wait_to_finish) { 229 base::RunLoop run_loop; 230 async_operation_completed_callback_ = run_loop.QuitClosure(); 231 driver_->Register(app_id, 232 sender_ids, 233 base::Bind(&GCMDriverTest::RegisterCompleted, 234 base::Unretained(this))); 235 if (wait_to_finish == WAIT) 236 run_loop.Run(); 237} 238 239void GCMDriverTest::Send(const std::string& app_id, 240 const std::string& receiver_id, 241 const GCMClient::OutgoingMessage& message, 242 WaitToFinish wait_to_finish) { 243 base::RunLoop run_loop; 244 async_operation_completed_callback_ = run_loop.QuitClosure(); 245 driver_->Send(app_id, 246 receiver_id, 247 message, 248 base::Bind(&GCMDriverTest::SendCompleted, 249 base::Unretained(this))); 250 if (wait_to_finish == WAIT) 251 run_loop.Run(); 252} 253 254void GCMDriverTest::Unregister(const std::string& app_id, 255 WaitToFinish wait_to_finish) { 256 base::RunLoop run_loop; 257 async_operation_completed_callback_ = run_loop.QuitClosure(); 258 driver_->Unregister(app_id, 259 base::Bind(&GCMDriverTest::UnregisterCompleted, 260 base::Unretained(this))); 261 if (wait_to_finish == WAIT) 262 run_loop.Run(); 263} 264 265void GCMDriverTest::WaitForAsyncOperation() { 266 base::RunLoop run_loop; 267 async_operation_completed_callback_ = run_loop.QuitClosure(); 268 run_loop.Run(); 269} 270 271void GCMDriverTest::RegisterCompleted(const std::string& registration_id, 272 GCMClient::Result result) { 273 registration_id_ = registration_id; 274 registration_result_ = result; 275 if (!async_operation_completed_callback_.is_null()) 276 async_operation_completed_callback_.Run(); 277} 278 279void GCMDriverTest::SendCompleted(const std::string& message_id, 280 GCMClient::Result result) { 281 send_message_id_ = message_id; 282 send_result_ = result; 283 if (!async_operation_completed_callback_.is_null()) 284 async_operation_completed_callback_.Run(); 285} 286 287void GCMDriverTest::UnregisterCompleted(GCMClient::Result result) { 288 unregistration_result_ = result; 289 if (!async_operation_completed_callback_.is_null()) 290 async_operation_completed_callback_.Run(); 291} 292 293TEST_F(GCMDriverTest, Create) { 294 // Create GCMDriver first. GCM is not started. 295 CreateDriver(FakeGCMClient::NO_DELAY_START); 296 EXPECT_FALSE(driver()->IsStarted()); 297 298 // Sign in. GCM is still not started. 299 SignIn(kTestAccountID1); 300 EXPECT_FALSE(driver()->IsStarted()); 301 EXPECT_FALSE(driver()->IsConnected()); 302 EXPECT_FALSE(gcm_app_handler()->connected()); 303 304 // GCM will be started only after both sign-in and app handler being added. 305 AddAppHandlers(); 306 EXPECT_TRUE(driver()->IsStarted()); 307 PumpIOLoop(); 308 EXPECT_TRUE(driver()->IsConnected()); 309 EXPECT_TRUE(gcm_app_handler()->connected()); 310} 311 312TEST_F(GCMDriverTest, CreateByFieldTrial) { 313 ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("GCM", "Enabled")); 314 315 // Create GCMDriver first. GCM is not started. 316 CreateDriver(FakeGCMClient::NO_DELAY_START); 317 EXPECT_FALSE(driver()->IsStarted()); 318 EXPECT_FALSE(driver()->IsConnected()); 319 EXPECT_FALSE(gcm_app_handler()->connected()); 320 321 // GCM will be started after app handler is added. 322 AddAppHandlers(); 323 EXPECT_TRUE(driver()->IsStarted()); 324 PumpIOLoop(); 325 EXPECT_TRUE(driver()->IsConnected()); 326 EXPECT_TRUE(gcm_app_handler()->connected()); 327} 328 329TEST_F(GCMDriverTest, Shutdown) { 330 CreateDriver(FakeGCMClient::NO_DELAY_START); 331 EXPECT_FALSE(HasAppHandlers()); 332 333 AddAppHandlers(); 334 EXPECT_TRUE(HasAppHandlers()); 335 336 driver()->Shutdown(); 337 EXPECT_FALSE(HasAppHandlers()); 338 EXPECT_FALSE(driver()->IsConnected()); 339 EXPECT_FALSE(gcm_app_handler()->connected()); 340} 341 342TEST_F(GCMDriverTest, SignInAndSignOutOnGCMEnabled) { 343 // By default, GCM is enabled. 344 CreateDriver(FakeGCMClient::NO_DELAY_START); 345 AddAppHandlers(); 346 347 // GCMClient should be started after sign-in. 348 SignIn(kTestAccountID1); 349 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 350 351 // GCMClient should be checked out after sign-out. 352 SignOut(); 353 EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status()); 354} 355 356TEST_F(GCMDriverTest, SignInAndSignOutOnGCMDisabled) { 357 // By default, GCM is enabled. 358 CreateDriver(FakeGCMClient::NO_DELAY_START); 359 AddAppHandlers(); 360 361 // Disable GCM. 362 driver()->Disable(); 363 364 // GCMClient should not be started after sign-in. 365 SignIn(kTestAccountID1); 366 EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status()); 367 368 // Check-out should still be performed after sign-out. 369 SignOut(); 370 EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status()); 371} 372 373TEST_F(GCMDriverTest, SignOutAndThenSignIn) { 374 CreateDriver(FakeGCMClient::NO_DELAY_START); 375 AddAppHandlers(); 376 377 // GCMClient should be started after sign-in. 378 SignIn(kTestAccountID1); 379 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 380 381 // GCMClient should be checked out after sign-out. 382 SignOut(); 383 EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status()); 384 385 // Sign-in with a different account. 386 SignIn(kTestAccountID2); 387 388 // GCMClient should be started again. 389 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 390} 391 392TEST_F(GCMDriverTest, DisableAndReenableGCM) { 393 CreateDriver(FakeGCMClient::NO_DELAY_START); 394 AddAppHandlers(); 395 SignIn(kTestAccountID1); 396 397 // GCMClient should be started. 398 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 399 400 // Disables the GCM. 401 driver()->Disable(); 402 PumpIOLoop(); 403 PumpUILoop(); 404 405 // GCMClient should be stopped. 406 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 407 408 // Enables the GCM. 409 driver()->Enable(); 410 PumpIOLoop(); 411 PumpUILoop(); 412 413 // GCMClient should be started. 414 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 415 416 // Disables the GCM. 417 driver()->Disable(); 418 PumpIOLoop(); 419 PumpUILoop(); 420 421 // GCMClient should be stopped. 422 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 423 424 // Sign out. 425 SignOut(); 426 427 // GCMClient should be checked out. 428 EXPECT_EQ(FakeGCMClient::CHECKED_OUT, GetGCMClient()->status()); 429} 430 431TEST_F(GCMDriverTest, StartOrStopGCMOnDemand) { 432 CreateDriver(FakeGCMClient::NO_DELAY_START); 433 SignIn(kTestAccountID1); 434 435 // GCMClient is not started. 436 EXPECT_EQ(FakeGCMClient::UNINITIALIZED, GetGCMClient()->status()); 437 438 // GCMClient is started after an app handler has been added. 439 driver()->AddAppHandler(kTestAppID1, gcm_app_handler()); 440 PumpIOLoop(); 441 PumpUILoop(); 442 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 443 444 // Add another app handler. 445 driver()->AddAppHandler(kTestAppID2, gcm_app_handler()); 446 PumpIOLoop(); 447 PumpUILoop(); 448 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 449 450 // GCMClient remains active after one app handler is gone. 451 driver()->RemoveAppHandler(kTestAppID1); 452 PumpIOLoop(); 453 PumpUILoop(); 454 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 455 456 // GCMClient should be stopped after the last app handler is gone. 457 driver()->RemoveAppHandler(kTestAppID2); 458 PumpIOLoop(); 459 PumpUILoop(); 460 EXPECT_EQ(FakeGCMClient::STOPPED, GetGCMClient()->status()); 461 462 // GCMClient is restarted after an app handler has been added. 463 driver()->AddAppHandler(kTestAppID2, gcm_app_handler()); 464 PumpIOLoop(); 465 PumpUILoop(); 466 EXPECT_EQ(FakeGCMClient::STARTED, GetGCMClient()->status()); 467} 468 469TEST_F(GCMDriverTest, RegisterFailed) { 470 std::vector<std::string> sender_ids; 471 sender_ids.push_back("sender1"); 472 473 CreateDriver(FakeGCMClient::NO_DELAY_START); 474 475 // Registration fails when GCM is disabled. 476 driver()->Disable(); 477 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 478 EXPECT_TRUE(registration_id().empty()); 479 EXPECT_EQ(GCMClient::GCM_DISABLED, registration_result()); 480 481 ClearResults(); 482 483 // Registration fails when the sign-in does not occur. 484 driver()->Enable(); 485 AddAppHandlers(); 486 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 487 EXPECT_TRUE(registration_id().empty()); 488 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result()); 489 490 ClearResults(); 491 492 // Registration fails when the no app handler is added. 493 RemoveAppHandlers(); 494 SignIn(kTestAccountID1); 495 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 496 EXPECT_TRUE(registration_id().empty()); 497 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, registration_result()); 498} 499 500TEST_F(GCMDriverTest, UnregisterFailed) { 501 CreateDriver(FakeGCMClient::NO_DELAY_START); 502 503 // Unregistration fails when GCM is disabled. 504 driver()->Disable(); 505 Unregister(kTestAppID1, GCMDriverTest::WAIT); 506 EXPECT_EQ(GCMClient::GCM_DISABLED, unregistration_result()); 507 508 ClearResults(); 509 510 // Unregistration fails when the sign-in does not occur. 511 driver()->Enable(); 512 AddAppHandlers(); 513 Unregister(kTestAppID1, GCMDriverTest::WAIT); 514 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, unregistration_result()); 515 516 ClearResults(); 517 518 // Unregistration fails when the no app handler is added. 519 RemoveAppHandlers(); 520 SignIn(kTestAccountID1); 521 Unregister(kTestAppID1, GCMDriverTest::WAIT); 522 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, unregistration_result()); 523} 524 525TEST_F(GCMDriverTest, SendFailed) { 526 GCMClient::OutgoingMessage message; 527 message.id = "1"; 528 message.data["key1"] = "value1"; 529 530 CreateDriver(FakeGCMClient::NO_DELAY_START); 531 532 // Sending fails when GCM is disabled. 533 driver()->Disable(); 534 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 535 EXPECT_TRUE(send_message_id().empty()); 536 EXPECT_EQ(GCMClient::GCM_DISABLED, send_result()); 537 538 ClearResults(); 539 540 // Sending fails when the sign-in does not occur. 541 driver()->Enable(); 542 AddAppHandlers(); 543 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 544 EXPECT_TRUE(send_message_id().empty()); 545 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result()); 546 547 ClearResults(); 548 549 // Sending fails when the no app handler is added. 550 RemoveAppHandlers(); 551 SignIn(kTestAccountID1); 552 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 553 EXPECT_TRUE(send_message_id().empty()); 554 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, send_result()); 555} 556 557TEST_F(GCMDriverTest, GCMClientNotReadyBeforeRegistration) { 558 // Make GCMClient not ready initially. 559 CreateDriver(FakeGCMClient::DELAY_START); 560 SignIn(kTestAccountID1); 561 AddAppHandlers(); 562 563 // The registration is on hold until GCMClient is ready. 564 std::vector<std::string> sender_ids; 565 sender_ids.push_back("sender1"); 566 Register(kTestAppID1, 567 sender_ids, 568 GCMDriverTest::DO_NOT_WAIT); 569 PumpIOLoop(); 570 PumpUILoop(); 571 EXPECT_TRUE(registration_id().empty()); 572 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, registration_result()); 573 574 // Register operation will be invoked after GCMClient becomes ready. 575 GetGCMClient()->PerformDelayedLoading(); 576 WaitForAsyncOperation(); 577 EXPECT_FALSE(registration_id().empty()); 578 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 579} 580 581TEST_F(GCMDriverTest, GCMClientNotReadyBeforeSending) { 582 // Make GCMClient not ready initially. 583 CreateDriver(FakeGCMClient::DELAY_START); 584 SignIn(kTestAccountID1); 585 AddAppHandlers(); 586 587 // The sending is on hold until GCMClient is ready. 588 GCMClient::OutgoingMessage message; 589 message.id = "1"; 590 message.data["key1"] = "value1"; 591 message.data["key2"] = "value2"; 592 Send(kTestAppID1, kUserID1, message, GCMDriverTest::DO_NOT_WAIT); 593 PumpIOLoop(); 594 PumpUILoop(); 595 596 EXPECT_TRUE(send_message_id().empty()); 597 EXPECT_EQ(GCMClient::UNKNOWN_ERROR, send_result()); 598 599 // Send operation will be invoked after GCMClient becomes ready. 600 GetGCMClient()->PerformDelayedLoading(); 601 WaitForAsyncOperation(); 602 EXPECT_EQ(message.id, send_message_id()); 603 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 604} 605 606// Tests a single instance of GCMDriver. 607class GCMDriverFunctionalTest : public GCMDriverTest { 608 public: 609 GCMDriverFunctionalTest(); 610 virtual ~GCMDriverFunctionalTest(); 611 612 // GCMDriverTest: 613 virtual void SetUp() OVERRIDE; 614 615 private: 616 DISALLOW_COPY_AND_ASSIGN(GCMDriverFunctionalTest); 617}; 618 619GCMDriverFunctionalTest::GCMDriverFunctionalTest() { 620} 621 622GCMDriverFunctionalTest::~GCMDriverFunctionalTest() { 623} 624 625void GCMDriverFunctionalTest::SetUp() { 626 GCMDriverTest::SetUp(); 627 628 CreateDriver(FakeGCMClient::NO_DELAY_START); 629 AddAppHandlers(); 630 SignIn(kTestAccountID1); 631} 632 633TEST_F(GCMDriverFunctionalTest, Register) { 634 std::vector<std::string> sender_ids; 635 sender_ids.push_back("sender1"); 636 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 637 const std::string expected_registration_id = 638 FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids); 639 640 EXPECT_EQ(expected_registration_id, registration_id()); 641 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 642} 643 644TEST_F(GCMDriverFunctionalTest, RegisterError) { 645 std::vector<std::string> sender_ids; 646 sender_ids.push_back("sender1@error"); 647 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 648 649 EXPECT_TRUE(registration_id().empty()); 650 EXPECT_NE(GCMClient::SUCCESS, registration_result()); 651} 652 653TEST_F(GCMDriverFunctionalTest, RegisterAgainWithSameSenderIDs) { 654 std::vector<std::string> sender_ids; 655 sender_ids.push_back("sender1"); 656 sender_ids.push_back("sender2"); 657 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 658 const std::string expected_registration_id = 659 FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids); 660 661 EXPECT_EQ(expected_registration_id, registration_id()); 662 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 663 664 // Clears the results the would be set by the Register callback in preparation 665 // to call register 2nd time. 666 ClearResults(); 667 668 // Calling register 2nd time with the same set of sender IDs but different 669 // ordering will get back the same registration ID. 670 std::vector<std::string> another_sender_ids; 671 another_sender_ids.push_back("sender2"); 672 another_sender_ids.push_back("sender1"); 673 Register(kTestAppID1, another_sender_ids, GCMDriverTest::WAIT); 674 675 EXPECT_EQ(expected_registration_id, registration_id()); 676 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 677} 678 679TEST_F(GCMDriverFunctionalTest, RegisterAgainWithDifferentSenderIDs) { 680 std::vector<std::string> sender_ids; 681 sender_ids.push_back("sender1"); 682 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 683 const std::string expected_registration_id = 684 FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids); 685 686 EXPECT_EQ(expected_registration_id, registration_id()); 687 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 688 689 // Make sender IDs different. 690 sender_ids.push_back("sender2"); 691 const std::string expected_registration_id2 = 692 FakeGCMClient::GetRegistrationIdFromSenderIds(sender_ids); 693 694 // Calling register 2nd time with the different sender IDs will get back a new 695 // registration ID. 696 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 697 EXPECT_EQ(expected_registration_id2, registration_id()); 698 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 699} 700 701TEST_F(GCMDriverFunctionalTest, RegisterAfterSignOut) { 702 // This will trigger check-out. 703 SignOut(); 704 705 std::vector<std::string> sender_ids; 706 sender_ids.push_back("sender1"); 707 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 708 709 EXPECT_TRUE(registration_id().empty()); 710 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, registration_result()); 711} 712 713TEST_F(GCMDriverFunctionalTest, UnregisterExplicitly) { 714 std::vector<std::string> sender_ids; 715 sender_ids.push_back("sender1"); 716 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 717 718 EXPECT_FALSE(registration_id().empty()); 719 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 720 721 Unregister(kTestAppID1, GCMDriverTest::WAIT); 722 723 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 724} 725 726TEST_F(GCMDriverFunctionalTest, UnregisterWhenAsyncOperationPending) { 727 std::vector<std::string> sender_ids; 728 sender_ids.push_back("sender1"); 729 // First start registration without waiting for it to complete. 730 Register(kTestAppID1, 731 sender_ids, 732 GCMDriverTest::DO_NOT_WAIT); 733 734 // Test that unregistration fails with async operation pending when there is a 735 // registration already in progress. 736 Unregister(kTestAppID1, GCMDriverTest::WAIT); 737 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 738 unregistration_result()); 739 740 // Complete the unregistration. 741 WaitForAsyncOperation(); 742 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 743 744 // Start unregistration without waiting for it to complete. This time no async 745 // operation is pending. 746 Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT); 747 748 // Test that unregistration fails with async operation pending when there is 749 // an unregistration already in progress. 750 Unregister(kTestAppID1, GCMDriverTest::WAIT); 751 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 752 unregistration_result()); 753 ClearResults(); 754 755 // Complete unregistration. 756 WaitForAsyncOperation(); 757 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 758} 759 760TEST_F(GCMDriverFunctionalTest, RegisterWhenAsyncOperationPending) { 761 std::vector<std::string> sender_ids; 762 sender_ids.push_back("sender1"); 763 // First start registration without waiting for it to complete. 764 Register(kTestAppID1, 765 sender_ids, 766 GCMDriverTest::DO_NOT_WAIT); 767 768 // Test that registration fails with async operation pending when there is a 769 // registration already in progress. 770 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 771 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 772 registration_result()); 773 ClearResults(); 774 775 // Complete the registration. 776 WaitForAsyncOperation(); 777 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 778 779 // Start unregistration without waiting for it to complete. This time no async 780 // operation is pending. 781 Unregister(kTestAppID1, GCMDriverTest::DO_NOT_WAIT); 782 783 // Test that registration fails with async operation pending when there is an 784 // unregistration already in progress. 785 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 786 EXPECT_EQ(GCMClient::ASYNC_OPERATION_PENDING, 787 registration_result()); 788 789 // Complete the first unregistration expecting success. 790 WaitForAsyncOperation(); 791 EXPECT_EQ(GCMClient::SUCCESS, unregistration_result()); 792 793 // Test that it is ok to register again after unregistration. 794 Register(kTestAppID1, sender_ids, GCMDriverTest::WAIT); 795 EXPECT_EQ(GCMClient::SUCCESS, registration_result()); 796} 797 798TEST_F(GCMDriverFunctionalTest, Send) { 799 GCMClient::OutgoingMessage message; 800 message.id = "1"; 801 message.data["key1"] = "value1"; 802 message.data["key2"] = "value2"; 803 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 804 805 EXPECT_EQ(message.id, send_message_id()); 806 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 807} 808 809TEST_F(GCMDriverFunctionalTest, SendAfterSignOut) { 810 // This will trigger check-out. 811 SignOut(); 812 813 GCMClient::OutgoingMessage message; 814 message.id = "1"; 815 message.data["key1"] = "value1"; 816 message.data["key2"] = "value2"; 817 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 818 819 EXPECT_TRUE(send_message_id().empty()); 820 EXPECT_EQ(GCMClient::NOT_SIGNED_IN, send_result()); 821} 822 823TEST_F(GCMDriverFunctionalTest, SendError) { 824 GCMClient::OutgoingMessage message; 825 // Embedding error in id will tell the mock to simulate the send error. 826 message.id = "1@error"; 827 message.data["key1"] = "value1"; 828 message.data["key2"] = "value2"; 829 Send(kTestAppID1, kUserID1, message, GCMDriverTest::WAIT); 830 831 EXPECT_EQ(message.id, send_message_id()); 832 EXPECT_EQ(GCMClient::SUCCESS, send_result()); 833 834 // Wait for the send error. 835 gcm_app_handler()->WaitForNotification(); 836 EXPECT_EQ(FakeGCMAppHandler::SEND_ERROR_EVENT, 837 gcm_app_handler()->received_event()); 838 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 839 EXPECT_EQ(message.id, 840 gcm_app_handler()->send_error_details().message_id); 841 EXPECT_NE(GCMClient::SUCCESS, 842 gcm_app_handler()->send_error_details().result); 843 EXPECT_EQ(message.data, 844 gcm_app_handler()->send_error_details().additional_data); 845} 846 847TEST_F(GCMDriverFunctionalTest, MessageReceived) { 848 Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT); 849 GCMClient::IncomingMessage message; 850 message.data["key1"] = "value1"; 851 message.data["key2"] = "value2"; 852 message.sender_id = "sender"; 853 GetGCMClient()->ReceiveMessage(kTestAppID1, message); 854 gcm_app_handler()->WaitForNotification(); 855 EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT, 856 gcm_app_handler()->received_event()); 857 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 858 EXPECT_EQ(message.data, gcm_app_handler()->message().data); 859 EXPECT_TRUE(gcm_app_handler()->message().collapse_key.empty()); 860 EXPECT_EQ(message.sender_id, gcm_app_handler()->message().sender_id); 861} 862 863TEST_F(GCMDriverFunctionalTest, MessageWithCollapseKeyReceived) { 864 Register(kTestAppID1, ToSenderList("sender"), GCMDriverTest::WAIT); 865 GCMClient::IncomingMessage message; 866 message.data["key1"] = "value1"; 867 message.collapse_key = "collapse_key_value"; 868 message.sender_id = "sender"; 869 GetGCMClient()->ReceiveMessage(kTestAppID1, message); 870 gcm_app_handler()->WaitForNotification(); 871 EXPECT_EQ(FakeGCMAppHandler::MESSAGE_EVENT, 872 gcm_app_handler()->received_event()); 873 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 874 EXPECT_EQ(message.data, gcm_app_handler()->message().data); 875 EXPECT_EQ(message.collapse_key, 876 gcm_app_handler()->message().collapse_key); 877} 878 879TEST_F(GCMDriverFunctionalTest, MessagesDeleted) { 880 GetGCMClient()->DeleteMessages(kTestAppID1); 881 gcm_app_handler()->WaitForNotification(); 882 EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT, 883 gcm_app_handler()->received_event()); 884 EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id()); 885} 886 887} // namespace gcm 888