google_apis/gcm/engine/mcs_client_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "google_apis/gcm/engine/mcs_client.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/test/simple_test_clock.h"
  13 #include "google_apis/gcm/base/fake_encryptor.h"
  14 #include "google_apis/gcm/base/mcs_util.h"
  15 #include "google_apis/gcm/engine/fake_connection_factory.h"
  16 #include "google_apis/gcm/engine/fake_connection_handler.h"
  17 #include "google_apis/gcm/engine/gcm_store_impl.h"
  18 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace gcm {
  22
  23 namespace {
  24
  25 const uint64 kAndroidId = 54321;
  26 const uint64 kSecurityToken = 12345;
  27
  28 // Number of messages to send when testing batching.
  29 // Note: must be even for tests that split batches in half.
  30 const int kMessageBatchSize = 6;
  31
  32 // The number of unacked messages the client will receive before sending a
  33 // stream ack.
  34 // TODO(zea): get this (and other constants) directly from the mcs client.
  35 const int kAckLimitSize = 10;
  36
  37 // TTL value for reliable messages.
  38 const int kTTLValue = 5 * 60;  // 5 minutes.
  39
  40 // Helper for building arbitrary data messages.
  41 MCSMessage BuildDataMessage(const std::string& from,
  42                             const std::string& category,
  43                             const std::string& message_id,
  44                             int last_stream_id_received,
  45                             const std::string& persistent_id,
  46                             int ttl,
  47                             uint64 sent,
  48                             int queued,
  49                             const std::string& token,
  50                             const uint64& user_id) {
  51   mcs_proto::DataMessageStanza data_message;
  52   data_message.set_id(message_id);
  53   data_message.set_from(from);
  54   data_message.set_category(category);
  55   data_message.set_last_stream_id_received(last_stream_id_received);
  56   if (!persistent_id.empty())
  57     data_message.set_persistent_id(persistent_id);
  58   data_message.set_ttl(ttl);
  59   data_message.set_sent(sent);
  60   data_message.set_queued(queued);
  61   data_message.set_token(token);
  62   data_message.set_device_user_id(user_id);
  63   return MCSMessage(kDataMessageStanzaTag, data_message);
  64 }
  65
  66 // MCSClient with overriden exposed persistent id logic.
  67 class TestMCSClient : public MCSClient {
  68  public:
  69   TestMCSClient(base::Clock* clock,
  70                 ConnectionFactory* connection_factory,
  71                 GCMStore* gcm_store,
  72                 gcm::GCMStatsRecorder* recorder)
  73     : MCSClient("", clock, connection_factory, gcm_store, recorder),
  74       next_id_(0) {
  75   }
  76
  77   virtual std::string GetNextPersistentId() OVERRIDE {
  78     return base::UintToString(++next_id_);
  79   }
  80
  81  private:
  82   uint32 next_id_;
  83 };
  84
  85 class MCSClientTest : public testing::Test {
  86  public:
  87   MCSClientTest();
  88   virtual ~MCSClientTest();
  89
  90   virtual void SetUp() OVERRIDE;
  91
  92   void BuildMCSClient();
  93   void InitializeClient();
  94   void StoreCredentials();
  95   void LoginClient(const std::vector<std::string>& acknowledged_ids);
  96
  97   base::SimpleTestClock* clock() { return &clock_; }
  98   TestMCSClient* mcs_client() const { return mcs_client_.get(); }
  99   FakeConnectionFactory* connection_factory() {
 100     return &connection_factory_;
 101   }
 102   bool init_success() const { return init_success_; }
 103   uint64 restored_android_id() const { return restored_android_id_; }
 104   uint64 restored_security_token() const { return restored_security_token_; }
 105   MCSMessage* received_message() const { return received_message_.get(); }
 106   std::string sent_message_id() const { return sent_message_id_;}
 107   MCSClient::MessageSendStatus message_send_status() const {
 108     return message_send_status_;
 109   }
 110
 111   void SetDeviceCredentialsCallback(bool success);
 112
 113   FakeConnectionHandler* GetFakeHandler() const;
 114
 115   void WaitForMCSEvent();
 116   void PumpLoop();
 117
 118  private:
 119   void ErrorCallback();
 120   void MessageReceivedCallback(const MCSMessage& message);
 121   void MessageSentCallback(int64 user_serial_number,
 122                            const std::string& app_id,
 123                            const std::string& message_id,
 124                            MCSClient::MessageSendStatus status);
 125
 126   base::SimpleTestClock clock_;
 127
 128   base::ScopedTempDir temp_directory_;
 129   base::MessageLoop message_loop_;
 130   scoped_ptr<base::RunLoop> run_loop_;
 131   scoped_ptr<GCMStore> gcm_store_;
 132
 133   FakeConnectionFactory connection_factory_;
 134   scoped_ptr<TestMCSClient> mcs_client_;
 135   bool init_success_;
 136   uint64 restored_android_id_;
 137   uint64 restored_security_token_;
 138   scoped_ptr<MCSMessage> received_message_;
 139   std::string sent_message_id_;
 140   MCSClient::MessageSendStatus message_send_status_;
 141
 142   gcm::GCMStatsRecorder recorder_;
 143 };
 144
 145 MCSClientTest::MCSClientTest()
 146     : run_loop_(new base::RunLoop()),
 147       init_success_(true),
 148       restored_android_id_(0),
 149       restored_security_token_(0),
 150       message_send_status_(MCSClient::SENT) {
 151   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 152   run_loop_.reset(new base::RunLoop());
 153
 154   // Advance the clock to a non-zero time.
 155   clock_.Advance(base::TimeDelta::FromSeconds(1));
 156 }
 157
 158 MCSClientTest::~MCSClientTest() {}
 159
 160 void MCSClientTest::SetUp() {
 161   testing::Test::SetUp();
 162 }
 163
 164 void MCSClientTest::BuildMCSClient() {
 165   gcm_store_.reset(new GCMStoreImpl(
 166       temp_directory_.path(),
 167       message_loop_.message_loop_proxy(),
 168       make_scoped_ptr<Encryptor>(new FakeEncryptor)));
 169   mcs_client_.reset(new TestMCSClient(&clock_,
 170                                       &connection_factory_,
 171                                       gcm_store_.get(),
 172                                       &recorder_));
 173 }
 174
 175 void MCSClientTest::InitializeClient() {
 176   gcm_store_->Load(base::Bind(
 177       &MCSClient::Initialize,
 178       base::Unretained(mcs_client_.get()),
 179       base::Bind(&MCSClientTest::ErrorCallback,
 180                  base::Unretained(this)),
 181       base::Bind(&MCSClientTest::MessageReceivedCallback,
 182                  base::Unretained(this)),
 183       base::Bind(&MCSClientTest::MessageSentCallback, base::Unretained(this))));
 184   run_loop_->RunUntilIdle();
 185   run_loop_.reset(new base::RunLoop());
 186 }
 187
 188 void MCSClientTest::LoginClient(
 189     const std::vector<std::string>& acknowledged_ids) {
 190   scoped_ptr<mcs_proto::LoginRequest> login_request =
 191       BuildLoginRequest(kAndroidId, kSecurityToken, "");
 192   for (size_t i = 0; i < acknowledged_ids.size(); ++i)
 193     login_request->add_received_persistent_id(acknowledged_ids[i]);
 194   GetFakeHandler()->ExpectOutgoingMessage(
 195       MCSMessage(kLoginRequestTag,
 196                  login_request.PassAs<const google::protobuf::MessageLite>()));
 197   mcs_client_->Login(kAndroidId, kSecurityToken);
 198   run_loop_->Run();
 199   run_loop_.reset(new base::RunLoop());
 200 }
 201
 202 void MCSClientTest::StoreCredentials() {
 203   gcm_store_->SetDeviceCredentials(
 204       kAndroidId, kSecurityToken,
 205       base::Bind(&MCSClientTest::SetDeviceCredentialsCallback,
 206                  base::Unretained(this)));
 207   run_loop_->Run();
 208   run_loop_.reset(new base::RunLoop());
 209 }
 210
 211 FakeConnectionHandler* MCSClientTest::GetFakeHandler() const {
 212   return reinterpret_cast<FakeConnectionHandler*>(
 213       connection_factory_.GetConnectionHandler());
 214 }
 215
 216 void MCSClientTest::WaitForMCSEvent() {
 217   run_loop_->Run();
 218   run_loop_.reset(new base::RunLoop());
 219 }
 220
 221 void MCSClientTest::PumpLoop() {
 222   run_loop_->RunUntilIdle();
 223   run_loop_.reset(new base::RunLoop());
 224 }
 225
 226 void MCSClientTest::ErrorCallback() {
 227   init_success_ = false;
 228   DVLOG(1) << "Error callback invoked, killing loop.";
 229   run_loop_->Quit();
 230 }
 231
 232 void MCSClientTest::MessageReceivedCallback(const MCSMessage& message) {
 233   received_message_.reset(new MCSMessage(message));
 234   DVLOG(1) << "Message received callback invoked, killing loop.";
 235   run_loop_->Quit();
 236 }
 237
 238 void MCSClientTest::MessageSentCallback(int64 user_serial_number,
 239                                         const std::string& app_id,
 240                                         const std::string& message_id,
 241                                         MCSClient::MessageSendStatus status) {
 242   DVLOG(1) << "Message sent callback invoked, killing loop.";
 243   sent_message_id_ = message_id;
 244   message_send_status_ = status;
 245   run_loop_->Quit();
 246 }
 247
 248 void MCSClientTest::SetDeviceCredentialsCallback(bool success) {
 249   ASSERT_TRUE(success);
 250   run_loop_->Quit();
 251 }
 252
 253 // Initialize a new client.
 254 TEST_F(MCSClientTest, InitializeNew) {
 255   BuildMCSClient();
 256   InitializeClient();
 257   EXPECT_TRUE(init_success());
 258 }
 259
 260 // Initialize a new client, shut it down, then restart the client. Should
 261 // reload the existing device credentials.
 262 TEST_F(MCSClientTest, InitializeExisting) {
 263   BuildMCSClient();
 264   InitializeClient();
 265   LoginClient(std::vector<std::string>());
 266
 267   // Rebuild the client, to reload from the GCM store.
 268   StoreCredentials();
 269   BuildMCSClient();
 270   InitializeClient();
 271   EXPECT_TRUE(init_success());
 272 }
 273
 274 // Log in successfully to the MCS endpoint.
 275 TEST_F(MCSClientTest, LoginSuccess) {
 276   BuildMCSClient();
 277   InitializeClient();
 278   LoginClient(std::vector<std::string>());
 279   EXPECT_TRUE(connection_factory()->IsEndpointReachable());
 280   EXPECT_TRUE(init_success());
 281   ASSERT_TRUE(received_message());
 282   EXPECT_EQ(kLoginResponseTag, received_message()->tag());
 283 }
 284
 285 // Encounter a server error during the login attempt. Should trigger a
 286 // reconnect.
 287 TEST_F(MCSClientTest, FailLogin) {
 288   BuildMCSClient();
 289   InitializeClient();
 290   GetFakeHandler()->set_fail_login(true);
 291   connection_factory()->set_delay_reconnect(true);
 292   LoginClient(std::vector<std::string>());
 293   EXPECT_FALSE(connection_factory()->IsEndpointReachable());
 294   EXPECT_FALSE(init_success());
 295   EXPECT_FALSE(received_message());
 296   EXPECT_TRUE(connection_factory()->reconnect_pending());
 297 }
 298
 299 // Send a message without RMQ support.
 300 TEST_F(MCSClientTest, SendMessageNoRMQ) {
 301   BuildMCSClient();
 302   InitializeClient();
 303   LoginClient(std::vector<std::string>());
 304   MCSMessage message(
 305       BuildDataMessage("from", "category", "X", 1, "", 0, 1, 0, "", 0));
 306   GetFakeHandler()->ExpectOutgoingMessage(message);
 307   mcs_client()->SendMessage(message);
 308   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 309 }
 310
 311 // Send a message without RMQ support while disconnected. Message send should
 312 // fail immediately, invoking callback.
 313 TEST_F(MCSClientTest, SendMessageNoRMQWhileDisconnected) {
 314   BuildMCSClient();
 315   InitializeClient();
 316
 317   EXPECT_TRUE(sent_message_id().empty());
 318   MCSMessage message(
 319       BuildDataMessage("from", "category", "X", 1, "", 0, 1, 0, "", 0));
 320   mcs_client()->SendMessage(message);
 321
 322   // Message sent callback should be invoked, but no message should actually
 323   // be sent.
 324   EXPECT_EQ("X", sent_message_id());
 325   EXPECT_EQ(MCSClient::NO_CONNECTION_ON_ZERO_TTL, message_send_status());
 326   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 327 }
 328
 329 // Send a message with RMQ support.
 330 TEST_F(MCSClientTest, SendMessageRMQ) {
 331   BuildMCSClient();
 332   InitializeClient();
 333   LoginClient(std::vector<std::string>());
 334   MCSMessage message(BuildDataMessage(
 335       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 336   GetFakeHandler()->ExpectOutgoingMessage(message);
 337   mcs_client()->SendMessage(message);
 338   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 339 }
 340
 341 // Send a message with RMQ support while disconnected. On reconnect, the message
 342 // should be resent.
 343 TEST_F(MCSClientTest, SendMessageRMQWhileDisconnected) {
 344   BuildMCSClient();
 345   InitializeClient();
 346   LoginClient(std::vector<std::string>());
 347   GetFakeHandler()->set_fail_send(true);
 348   MCSMessage message(BuildDataMessage(
 349       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 350
 351   // The initial (failed) send.
 352   GetFakeHandler()->ExpectOutgoingMessage(message);
 353   // The login request.
 354   GetFakeHandler()->ExpectOutgoingMessage(
 355       MCSMessage(
 356           kLoginRequestTag,
 357           BuildLoginRequest(kAndroidId, kSecurityToken, "").
 358               PassAs<const google::protobuf::MessageLite>()));
 359   // The second (re)send.
 360   MCSMessage message2(BuildDataMessage(
 361       "from", "category", "X", 1, "1", kTTLValue, 1, kTTLValue - 1, "", 0));
 362   GetFakeHandler()->ExpectOutgoingMessage(message2);
 363   mcs_client()->SendMessage(message);
 364   PumpLoop();         // Wait for the queuing to happen.
 365   EXPECT_EQ(MCSClient::QUEUED, message_send_status());
 366   EXPECT_FALSE(GetFakeHandler()->AllOutgoingMessagesReceived());
 367   GetFakeHandler()->set_fail_send(false);
 368   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue - 1));
 369   connection_factory()->Connect();
 370   WaitForMCSEvent();  // Wait for the login to finish.
 371   PumpLoop();         // Wait for the send to happen.
 372   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 373 }
 374
 375 // Send a message with RMQ support without receiving an acknowledgement. On
 376 // restart the message should be resent.
 377 TEST_F(MCSClientTest, SendMessageRMQOnRestart) {
 378   BuildMCSClient();
 379   InitializeClient();
 380   LoginClient(std::vector<std::string>());
 381   GetFakeHandler()->set_fail_send(true);
 382   MCSMessage message(BuildDataMessage(
 383       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 384
 385   // The initial (failed) send.
 386   GetFakeHandler()->ExpectOutgoingMessage(message);
 387   GetFakeHandler()->set_fail_send(false);
 388   mcs_client()->SendMessage(message);
 389   PumpLoop();
 390   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 391
 392   // Rebuild the client, which should resend the old message.
 393   StoreCredentials();
 394   BuildMCSClient();
 395   InitializeClient();
 396
 397   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue - 1));
 398   MCSMessage message2(BuildDataMessage(
 399       "from", "category", "X", 1, "1", kTTLValue, 1, kTTLValue - 1, "", 0));
 400   LoginClient(std::vector<std::string>());
 401   GetFakeHandler()->ExpectOutgoingMessage(message2);
 402   PumpLoop();
 403   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 404 }
 405
 406 // Send messages with RMQ support, followed by receiving a stream ack. On
 407 // restart nothing should be recent.
 408 TEST_F(MCSClientTest, SendMessageRMQWithStreamAck) {
 409   BuildMCSClient();
 410   InitializeClient();
 411   LoginClient(std::vector<std::string>());
 412
 413   // Send some messages.
 414   for (int i = 1; i <= kMessageBatchSize; ++i) {
 415     MCSMessage message(BuildDataMessage("from",
 416                                         "category",
 417                                         "X",
 418                                         1,
 419                                         base::IntToString(i),
 420                                         kTTLValue,
 421                                         1,
 422                                         0,
 423                                         "",
 424                                         0));
 425     GetFakeHandler()->ExpectOutgoingMessage(message);
 426     mcs_client()->SendMessage(message);
 427     PumpLoop();
 428   }
 429   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 430
 431   // Receive the ack.
 432   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
 433   ack->set_last_stream_id_received(kMessageBatchSize + 1);
 434   GetFakeHandler()->ReceiveMessage(
 435       MCSMessage(kIqStanzaTag,
 436                  ack.PassAs<const google::protobuf::MessageLite>()));
 437   WaitForMCSEvent();
 438
 439   // Reconnect and ensure no messages are resent.
 440   StoreCredentials();
 441   BuildMCSClient();
 442   InitializeClient();
 443   LoginClient(std::vector<std::string>());
 444   PumpLoop();
 445 }
 446
 447 // Send messages with RMQ support. On restart, receive a SelectiveAck with
 448 // the login response. No messages should be resent.
 449 TEST_F(MCSClientTest, SendMessageRMQAckOnReconnect) {
 450   BuildMCSClient();
 451   InitializeClient();
 452   LoginClient(std::vector<std::string>());
 453
 454   // Send some messages.
 455   std::vector<std::string> id_list;
 456   for (int i = 1; i <= kMessageBatchSize; ++i) {
 457     id_list.push_back(base::IntToString(i));
 458     MCSMessage message(BuildDataMessage("from",
 459                                         "category",
 460                                         id_list.back(),
 461                                         1,
 462                                         id_list.back(),
 463                                         kTTLValue,
 464                                         1,
 465                                         0,
 466                                         "",
 467                                         0));
 468     GetFakeHandler()->ExpectOutgoingMessage(message);
 469     mcs_client()->SendMessage(message);
 470     PumpLoop();
 471   }
 472   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 473
 474   // Rebuild the client, and receive an acknowledgment for the messages as
 475   // part of the login response.
 476   StoreCredentials();
 477   BuildMCSClient();
 478   InitializeClient();
 479   LoginClient(std::vector<std::string>());
 480   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(id_list));
 481   GetFakeHandler()->ReceiveMessage(
 482       MCSMessage(kIqStanzaTag,
 483                  ack.PassAs<const google::protobuf::MessageLite>()));
 484   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 485 }
 486
 487 // Send messages with RMQ support. On restart, receive a SelectiveAck with
 488 // the login response that only acks some messages. The unacked messages should
 489 // be resent.
 490 TEST_F(MCSClientTest, SendMessageRMQPartialAckOnReconnect) {
 491   BuildMCSClient();
 492   InitializeClient();
 493   LoginClient(std::vector<std::string>());
 494
 495   // Send some messages.
 496   std::vector<std::string> id_list;
 497   for (int i = 1; i <= kMessageBatchSize; ++i) {
 498     id_list.push_back(base::IntToString(i));
 499     MCSMessage message(BuildDataMessage("from",
 500                                         "category",
 501                                         id_list.back(),
 502                                         1,
 503                                         id_list.back(),
 504                                         kTTLValue,
 505                                         1,
 506                                         0,
 507                                         "",
 508                                         0));
 509     GetFakeHandler()->ExpectOutgoingMessage(message);
 510     mcs_client()->SendMessage(message);
 511     PumpLoop();
 512   }
 513   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 514
 515   // Rebuild the client, and receive an acknowledgment for the messages as
 516   // part of the login response.
 517   StoreCredentials();
 518   BuildMCSClient();
 519   InitializeClient();
 520   LoginClient(std::vector<std::string>());
 521
 522   std::vector<std::string> acked_ids, remaining_ids;
 523   acked_ids.insert(acked_ids.end(),
 524                    id_list.begin(),
 525                    id_list.begin() + kMessageBatchSize / 2);
 526   remaining_ids.insert(remaining_ids.end(),
 527                        id_list.begin() + kMessageBatchSize / 2,
 528                        id_list.end());
 529   for (int i = 1; i <= kMessageBatchSize / 2; ++i) {
 530     MCSMessage message(BuildDataMessage("from",
 531                                         "category",
 532                                         remaining_ids[i - 1],
 533                                         2,
 534                                         remaining_ids[i - 1],
 535                                         kTTLValue,
 536                                         1,
 537                                         0,
 538                                         "",
 539                                         0));
 540     GetFakeHandler()->ExpectOutgoingMessage(message);
 541   }
 542   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
 543   GetFakeHandler()->ReceiveMessage(
 544       MCSMessage(kIqStanzaTag,
 545                  ack.PassAs<const google::protobuf::MessageLite>()));
 546   WaitForMCSEvent();
 547   PumpLoop();
 548   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 549 }
 550
 551 // Receive some messages. On restart, the login request should contain the
 552 // appropriate acknowledged ids.
 553 TEST_F(MCSClientTest, AckOnLogin) {
 554   BuildMCSClient();
 555   InitializeClient();
 556   LoginClient(std::vector<std::string>());
 557
 558   // Receive some messages.
 559   std::vector<std::string> id_list;
 560   for (int i = 1; i <= kMessageBatchSize; ++i) {
 561     id_list.push_back(base::IntToString(i));
 562     MCSMessage message(BuildDataMessage(
 563         "from", "category", "X", 1, id_list.back(), kTTLValue, 1, 0, "", 0));
 564     GetFakeHandler()->ReceiveMessage(message);
 565     WaitForMCSEvent();
 566     PumpLoop();
 567   }
 568
 569   // Restart the client.
 570   StoreCredentials();
 571   BuildMCSClient();
 572   InitializeClient();
 573   LoginClient(id_list);
 574 }
 575
 576 // Receive some messages. On the next send, the outgoing message should contain
 577 // the appropriate last stream id received field to ack the received messages.
 578 TEST_F(MCSClientTest, AckOnSend) {
 579   BuildMCSClient();
 580   InitializeClient();
 581   LoginClient(std::vector<std::string>());
 582
 583   // Receive some messages.
 584   std::vector<std::string> id_list;
 585   for (int i = 1; i <= kMessageBatchSize; ++i) {
 586     id_list.push_back(base::IntToString(i));
 587     MCSMessage message(BuildDataMessage("from",
 588                                         "category",
 589                                         id_list.back(),
 590                                         1,
 591                                         id_list.back(),
 592                                         kTTLValue,
 593                                         1,
 594                                         0,
 595                                         "",
 596                                         0));
 597     GetFakeHandler()->ReceiveMessage(message);
 598     PumpLoop();
 599   }
 600
 601   // Trigger a message send, which should acknowledge via stream ack.
 602   MCSMessage message(BuildDataMessage("from",
 603                                       "category",
 604                                       "X",
 605                                       kMessageBatchSize + 1,
 606                                       "1",
 607                                       kTTLValue,
 608                                       1,
 609                                       0,
 610                                       "",
 611                                       0));
 612   GetFakeHandler()->ExpectOutgoingMessage(message);
 613   mcs_client()->SendMessage(message);
 614   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 615 }
 616
 617 // Receive the ack limit in messages, which should trigger an automatic
 618 // stream ack. Receive a heartbeat to confirm the ack.
 619 TEST_F(MCSClientTest, AckWhenLimitReachedWithHeartbeat) {
 620   BuildMCSClient();
 621   InitializeClient();
 622   LoginClient(std::vector<std::string>());
 623
 624   // The stream ack.
 625   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
 626   ack->set_last_stream_id_received(kAckLimitSize + 1);
 627   GetFakeHandler()->ExpectOutgoingMessage(
 628       MCSMessage(kIqStanzaTag,
 629                  ack.PassAs<const google::protobuf::MessageLite>()));
 630
 631   // Receive some messages.
 632   std::vector<std::string> id_list;
 633   for (int i = 1; i <= kAckLimitSize; ++i) {
 634     id_list.push_back(base::IntToString(i));
 635     MCSMessage message(BuildDataMessage("from",
 636                                         "category",
 637                                         id_list.back(),
 638                                         1,
 639                                         id_list.back(),
 640                                         kTTLValue,
 641                                         1,
 642                                         0,
 643                                         "",
 644                                         0));
 645     GetFakeHandler()->ReceiveMessage(message);
 646     WaitForMCSEvent();
 647     PumpLoop();
 648   }
 649   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 650
 651   // Receive a heartbeat confirming the ack (and receive the heartbeat ack).
 652   scoped_ptr<mcs_proto::HeartbeatPing> heartbeat(
 653       new mcs_proto::HeartbeatPing());
 654   heartbeat->set_last_stream_id_received(2);
 655
 656   scoped_ptr<mcs_proto::HeartbeatAck> heartbeat_ack(
 657       new mcs_proto::HeartbeatAck());
 658   heartbeat_ack->set_last_stream_id_received(kAckLimitSize + 2);
 659   GetFakeHandler()->ExpectOutgoingMessage(
 660       MCSMessage(kHeartbeatAckTag,
 661                  heartbeat_ack.PassAs<const google::protobuf::MessageLite>()));
 662
 663   GetFakeHandler()->ReceiveMessage(
 664       MCSMessage(kHeartbeatPingTag,
 665                  heartbeat.PassAs<const google::protobuf::MessageLite>()));
 666   PumpLoop();
 667   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 668
 669   // Rebuild the client. Nothing should be sent on login.
 670   StoreCredentials();
 671   BuildMCSClient();
 672   InitializeClient();
 673   LoginClient(std::vector<std::string>());
 674   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 675 }
 676
 677 // If a message's TTL has expired by the time it reaches the front of the send
 678 // queue, it should be dropped.
 679 TEST_F(MCSClientTest, ExpiredTTLOnSend) {
 680   BuildMCSClient();
 681   InitializeClient();
 682   LoginClient(std::vector<std::string>());
 683   MCSMessage message(BuildDataMessage(
 684       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 685
 686   // Advance time to after the TTL.
 687   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue + 2));
 688   EXPECT_TRUE(sent_message_id().empty());
 689   mcs_client()->SendMessage(message);
 690
 691   // No messages should be sent, but the callback should still be invoked.
 692   EXPECT_EQ("X", sent_message_id());
 693   EXPECT_EQ(MCSClient::TTL_EXCEEDED, message_send_status());
 694   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 695 }
 696
 697 TEST_F(MCSClientTest, ExpiredTTLOnRestart) {
 698   BuildMCSClient();
 699   InitializeClient();
 700   LoginClient(std::vector<std::string>());
 701   GetFakeHandler()->set_fail_send(true);
 702   MCSMessage message(BuildDataMessage(
 703       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 704
 705   // The initial (failed) send.
 706   GetFakeHandler()->ExpectOutgoingMessage(message);
 707   GetFakeHandler()->set_fail_send(false);
 708   mcs_client()->SendMessage(message);
 709   PumpLoop();
 710   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 711
 712   // Move the clock forward and rebuild the client, which should fail the
 713   // message send on restart.
 714   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue + 2));
 715   StoreCredentials();
 716   BuildMCSClient();
 717   InitializeClient();
 718   LoginClient(std::vector<std::string>());
 719   PumpLoop();
 720   EXPECT_EQ("X", sent_message_id());
 721   EXPECT_EQ(MCSClient::TTL_EXCEEDED, message_send_status());
 722   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 723 }
 724
 725 // Sending two messages with the same collapse key and same app id while
 726 // disconnected should only send the latter of the two on reconnection.
 727 TEST_F(MCSClientTest, CollapseKeysSameApp) {
 728   BuildMCSClient();
 729   InitializeClient();
 730   MCSMessage message(BuildDataMessage(
 731       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 732   mcs_client()->SendMessage(message);
 733
 734   MCSMessage message2(BuildDataMessage(
 735       "from", "app", "message id 2", 1, "1", kTTLValue, 1, 0, "token", 0));
 736   mcs_client()->SendMessage(message2);
 737
 738   LoginClient(std::vector<std::string>());
 739   GetFakeHandler()->ExpectOutgoingMessage(message2);
 740   PumpLoop();
 741 }
 742
 743 // Sending two messages with the same collapse key and different app id while
 744 // disconnected should not perform any collapsing.
 745 TEST_F(MCSClientTest, CollapseKeysDifferentApp) {
 746   BuildMCSClient();
 747   InitializeClient();
 748   MCSMessage message(BuildDataMessage(
 749       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 750   mcs_client()->SendMessage(message);
 751
 752   MCSMessage message2(BuildDataMessage("from",
 753                                        "app 2",
 754                                        "message id 2",
 755                                        1,
 756                                        "2",
 757                                        kTTLValue,
 758                                        1,
 759                                        0,
 760                                        "token",
 761                                        0));
 762   mcs_client()->SendMessage(message2);
 763
 764   LoginClient(std::vector<std::string>());
 765   GetFakeHandler()->ExpectOutgoingMessage(message);
 766   GetFakeHandler()->ExpectOutgoingMessage(message2);
 767   PumpLoop();
 768 }
 769
 770 // Sending two messages with the same collapse key and app id, but different
 771 // user, while disconnected, should not perform any collapsing.
 772 TEST_F(MCSClientTest, CollapseKeysDifferentUser) {
 773   BuildMCSClient();
 774   InitializeClient();
 775   MCSMessage message(BuildDataMessage(
 776       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 777   mcs_client()->SendMessage(message);
 778
 779   MCSMessage message2(BuildDataMessage("from",
 780                                        "app",
 781                                        "message id 2",
 782                                        1,
 783                                        "2",
 784                                        kTTLValue,
 785                                        1,
 786                                        0,
 787                                        "token",
 788                                        1));
 789   mcs_client()->SendMessage(message2);
 790
 791   LoginClient(std::vector<std::string>());
 792   GetFakeHandler()->ExpectOutgoingMessage(message);
 793   GetFakeHandler()->ExpectOutgoingMessage(message2);
 794   PumpLoop();
 795 }
 796
 797 } // namespace
 798
 799 }  // namespace gcm