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/fake_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::FakeGCMStatsRecorder 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_EQ("X", sent_message_id());
 367   EXPECT_FALSE(GetFakeHandler()->AllOutgoingMessagesReceived());
 368   GetFakeHandler()->set_fail_send(false);
 369   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue - 1));
 370   connection_factory()->Connect();
 371   WaitForMCSEvent();  // Wait for the login to finish.
 372   PumpLoop();         // Wait for the send to happen.
 373
 374   // Receive the ack.
 375   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
 376   ack->set_last_stream_id_received(2);
 377   GetFakeHandler()->ReceiveMessage(
 378       MCSMessage(kIqStanzaTag,
 379                  ack.PassAs<const google::protobuf::MessageLite>()));
 380   WaitForMCSEvent();
 381
 382   EXPECT_EQ(MCSClient::SENT, message_send_status());
 383   EXPECT_EQ("X", sent_message_id());
 384   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 385 }
 386
 387 // Send a message with RMQ support without receiving an acknowledgement. On
 388 // restart the message should be resent.
 389 TEST_F(MCSClientTest, SendMessageRMQOnRestart) {
 390   BuildMCSClient();
 391   InitializeClient();
 392   LoginClient(std::vector<std::string>());
 393   GetFakeHandler()->set_fail_send(true);
 394   MCSMessage message(BuildDataMessage(
 395       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 396
 397   // The initial (failed) send.
 398   GetFakeHandler()->ExpectOutgoingMessage(message);
 399   GetFakeHandler()->set_fail_send(false);
 400   mcs_client()->SendMessage(message);
 401   PumpLoop();
 402   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 403
 404   // Rebuild the client, which should resend the old message.
 405   StoreCredentials();
 406   BuildMCSClient();
 407   InitializeClient();
 408
 409   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue - 1));
 410   MCSMessage message2(BuildDataMessage(
 411       "from", "category", "X", 1, "1", kTTLValue, 1, kTTLValue - 1, "", 0));
 412   LoginClient(std::vector<std::string>());
 413   GetFakeHandler()->ExpectOutgoingMessage(message2);
 414   PumpLoop();
 415   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 416 }
 417
 418 // Send messages with RMQ support, followed by receiving a stream ack. On
 419 // restart nothing should be recent.
 420 TEST_F(MCSClientTest, SendMessageRMQWithStreamAck) {
 421   BuildMCSClient();
 422   InitializeClient();
 423   LoginClient(std::vector<std::string>());
 424
 425   // Send some messages.
 426   for (int i = 1; i <= kMessageBatchSize; ++i) {
 427     MCSMessage message(BuildDataMessage("from",
 428                                         "category",
 429                                         "X",
 430                                         1,
 431                                         base::IntToString(i),
 432                                         kTTLValue,
 433                                         1,
 434                                         0,
 435                                         "",
 436                                         0));
 437     GetFakeHandler()->ExpectOutgoingMessage(message);
 438     mcs_client()->SendMessage(message);
 439     PumpLoop();
 440   }
 441   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 442
 443   // Receive the ack.
 444   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
 445   ack->set_last_stream_id_received(kMessageBatchSize + 1);
 446   GetFakeHandler()->ReceiveMessage(
 447       MCSMessage(kIqStanzaTag,
 448                  ack.PassAs<const google::protobuf::MessageLite>()));
 449   WaitForMCSEvent();
 450
 451   // Reconnect and ensure no messages are resent.
 452   StoreCredentials();
 453   BuildMCSClient();
 454   InitializeClient();
 455   LoginClient(std::vector<std::string>());
 456   PumpLoop();
 457 }
 458
 459 // Send messages with RMQ support. On restart, receive a SelectiveAck with
 460 // the login response. No messages should be resent.
 461 TEST_F(MCSClientTest, SendMessageRMQAckOnReconnect) {
 462   BuildMCSClient();
 463   InitializeClient();
 464   LoginClient(std::vector<std::string>());
 465
 466   // Send some messages.
 467   std::vector<std::string> id_list;
 468   for (int i = 1; i <= kMessageBatchSize; ++i) {
 469     id_list.push_back(base::IntToString(i));
 470     MCSMessage message(BuildDataMessage("from",
 471                                         "category",
 472                                         id_list.back(),
 473                                         1,
 474                                         id_list.back(),
 475                                         kTTLValue,
 476                                         1,
 477                                         0,
 478                                         "",
 479                                         0));
 480     GetFakeHandler()->ExpectOutgoingMessage(message);
 481     mcs_client()->SendMessage(message);
 482     PumpLoop();
 483   }
 484   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 485
 486   // Rebuild the client, and receive an acknowledgment for the messages as
 487   // part of the login response.
 488   StoreCredentials();
 489   BuildMCSClient();
 490   InitializeClient();
 491   LoginClient(std::vector<std::string>());
 492   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(id_list));
 493   GetFakeHandler()->ReceiveMessage(
 494       MCSMessage(kIqStanzaTag,
 495                  ack.PassAs<const google::protobuf::MessageLite>()));
 496   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 497 }
 498
 499 // Send messages with RMQ support. On restart, receive a SelectiveAck with
 500 // the login response that only acks some messages. The unacked messages should
 501 // be resent.
 502 TEST_F(MCSClientTest, SendMessageRMQPartialAckOnReconnect) {
 503   BuildMCSClient();
 504   InitializeClient();
 505   LoginClient(std::vector<std::string>());
 506
 507   // Send some messages.
 508   std::vector<std::string> id_list;
 509   for (int i = 1; i <= kMessageBatchSize; ++i) {
 510     id_list.push_back(base::IntToString(i));
 511     MCSMessage message(BuildDataMessage("from",
 512                                         "category",
 513                                         id_list.back(),
 514                                         1,
 515                                         id_list.back(),
 516                                         kTTLValue,
 517                                         1,
 518                                         0,
 519                                         "",
 520                                         0));
 521     GetFakeHandler()->ExpectOutgoingMessage(message);
 522     mcs_client()->SendMessage(message);
 523     PumpLoop();
 524   }
 525   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 526
 527   // Rebuild the client, and receive an acknowledgment for the messages as
 528   // part of the login response.
 529   StoreCredentials();
 530   BuildMCSClient();
 531   InitializeClient();
 532   LoginClient(std::vector<std::string>());
 533
 534   std::vector<std::string> acked_ids, remaining_ids;
 535   acked_ids.insert(acked_ids.end(),
 536                    id_list.begin(),
 537                    id_list.begin() + kMessageBatchSize / 2);
 538   remaining_ids.insert(remaining_ids.end(),
 539                        id_list.begin() + kMessageBatchSize / 2,
 540                        id_list.end());
 541   for (int i = 1; i <= kMessageBatchSize / 2; ++i) {
 542     MCSMessage message(BuildDataMessage("from",
 543                                         "category",
 544                                         remaining_ids[i - 1],
 545                                         2,
 546                                         remaining_ids[i - 1],
 547                                         kTTLValue,
 548                                         1,
 549                                         0,
 550                                         "",
 551                                         0));
 552     GetFakeHandler()->ExpectOutgoingMessage(message);
 553   }
 554   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
 555   GetFakeHandler()->ReceiveMessage(
 556       MCSMessage(kIqStanzaTag,
 557                  ack.PassAs<const google::protobuf::MessageLite>()));
 558   WaitForMCSEvent();
 559   PumpLoop();
 560   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 561 }
 562
 563 // Handle a selective ack that only acks some messages. The remaining unacked
 564 // messages should be resent. On restart, those same unacked messages should be
 565 // resent, and any pending acks for incoming messages should also be resent.
 566 TEST_F(MCSClientTest, SelectiveAckMidStream) {
 567   BuildMCSClient();
 568   InitializeClient();
 569   LoginClient(std::vector<std::string>());
 570
 571   // Server stream id 2 ("s1").
 572   // Acks client stream id 0 (login).
 573   MCSMessage sMessage1(BuildDataMessage(
 574       "from", "category", "X", 0, "s1", kTTLValue, 1, 0, "", 0));
 575   GetFakeHandler()->ReceiveMessage(sMessage1);
 576   WaitForMCSEvent();
 577   PumpLoop();
 578
 579   // Client stream id 1 ("1").
 580   // Acks server stream id 2 ("s1").
 581   MCSMessage cMessage1(BuildDataMessage(
 582       "from", "category", "Y", 2, "1", kTTLValue, 1, 0, "", 0));
 583   GetFakeHandler()->ExpectOutgoingMessage(cMessage1);
 584   mcs_client()->SendMessage(cMessage1);
 585   PumpLoop();
 586   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 587
 588   // Server stream id 3 ("s2").
 589   // Acks client stream id 1 ("1").
 590   // Confirms ack of server stream id 2 ("s1").
 591   MCSMessage sMessage2(BuildDataMessage(
 592       "from", "category", "X", 1, "s2", kTTLValue, 1, 0, "", 0));
 593   GetFakeHandler()->ReceiveMessage(sMessage2);
 594   WaitForMCSEvent();
 595   PumpLoop();
 596
 597   // Client Stream id 2 ("2").
 598   // Acks server stream id 3 ("s2").
 599   MCSMessage cMessage2(BuildDataMessage(
 600       "from", "category", "Y", 3, "2", kTTLValue, 1, 0, "", 0));
 601   GetFakeHandler()->ExpectOutgoingMessage(cMessage2);
 602   mcs_client()->SendMessage(cMessage2);
 603   PumpLoop();
 604   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 605
 606   // Simulate the last message being dropped by having the server selectively
 607   // ack client message "1".
 608   // Client message "2" should be resent, acking server stream id 4 (selective
 609   // ack).
 610   MCSMessage cMessage3(BuildDataMessage(
 611       "from", "category", "Y", 4, "2", kTTLValue, 1, 0, "", 0));
 612   GetFakeHandler()->ExpectOutgoingMessage(cMessage3);
 613   std::vector<std::string> acked_ids(1, "1");
 614   scoped_ptr<mcs_proto::IqStanza> ack(BuildSelectiveAck(acked_ids));
 615   GetFakeHandler()->ReceiveMessage(
 616       MCSMessage(kIqStanzaTag,
 617                  ack.PassAs<const google::protobuf::MessageLite>()));
 618   WaitForMCSEvent();
 619   PumpLoop();
 620   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 621
 622   // Rebuild the client without any further acks from server. Note that this
 623   // resets the stream ids.
 624   // Sever message "s2" should be acked as part of login.
 625   // Client message "2" should be resent.
 626   StoreCredentials();
 627   BuildMCSClient();
 628   InitializeClient();
 629
 630   acked_ids[0] = "s2";
 631   LoginClient(acked_ids);
 632
 633   MCSMessage cMessage4(BuildDataMessage(
 634       "from", "category", "Y", 1, "2", kTTLValue, 1, 0, "", 0));
 635   GetFakeHandler()->ExpectOutgoingMessage(cMessage4);
 636   PumpLoop();
 637   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 638 }
 639
 640 // Receive some messages. On restart, the login request should contain the
 641 // appropriate acknowledged ids.
 642 TEST_F(MCSClientTest, AckOnLogin) {
 643   BuildMCSClient();
 644   InitializeClient();
 645   LoginClient(std::vector<std::string>());
 646
 647   // Receive some messages.
 648   std::vector<std::string> id_list;
 649   for (int i = 1; i <= kMessageBatchSize; ++i) {
 650     id_list.push_back(base::IntToString(i));
 651     MCSMessage message(BuildDataMessage(
 652         "from", "category", "X", 1, id_list.back(), kTTLValue, 1, 0, "", 0));
 653     GetFakeHandler()->ReceiveMessage(message);
 654     WaitForMCSEvent();
 655     PumpLoop();
 656   }
 657
 658   // Restart the client.
 659   StoreCredentials();
 660   BuildMCSClient();
 661   InitializeClient();
 662   LoginClient(id_list);
 663 }
 664
 665 // Receive some messages. On the next send, the outgoing message should contain
 666 // the appropriate last stream id received field to ack the received messages.
 667 TEST_F(MCSClientTest, AckOnSend) {
 668   BuildMCSClient();
 669   InitializeClient();
 670   LoginClient(std::vector<std::string>());
 671
 672   // Receive some messages.
 673   std::vector<std::string> id_list;
 674   for (int i = 1; i <= kMessageBatchSize; ++i) {
 675     id_list.push_back(base::IntToString(i));
 676     MCSMessage message(BuildDataMessage("from",
 677                                         "category",
 678                                         id_list.back(),
 679                                         1,
 680                                         id_list.back(),
 681                                         kTTLValue,
 682                                         1,
 683                                         0,
 684                                         "",
 685                                         0));
 686     GetFakeHandler()->ReceiveMessage(message);
 687     PumpLoop();
 688   }
 689
 690   // Trigger a message send, which should acknowledge via stream ack.
 691   MCSMessage message(BuildDataMessage("from",
 692                                       "category",
 693                                       "X",
 694                                       kMessageBatchSize + 1,
 695                                       "1",
 696                                       kTTLValue,
 697                                       1,
 698                                       0,
 699                                       "",
 700                                       0));
 701   GetFakeHandler()->ExpectOutgoingMessage(message);
 702   mcs_client()->SendMessage(message);
 703   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 704 }
 705
 706 // Receive the ack limit in messages, which should trigger an automatic
 707 // stream ack. Receive a heartbeat to confirm the ack.
 708 TEST_F(MCSClientTest, AckWhenLimitReachedWithHeartbeat) {
 709   BuildMCSClient();
 710   InitializeClient();
 711   LoginClient(std::vector<std::string>());
 712
 713   // The stream ack.
 714   scoped_ptr<mcs_proto::IqStanza> ack = BuildStreamAck();
 715   ack->set_last_stream_id_received(kAckLimitSize + 1);
 716   GetFakeHandler()->ExpectOutgoingMessage(
 717       MCSMessage(kIqStanzaTag,
 718                  ack.PassAs<const google::protobuf::MessageLite>()));
 719
 720   // Receive some messages.
 721   std::vector<std::string> id_list;
 722   for (int i = 1; i <= kAckLimitSize; ++i) {
 723     id_list.push_back(base::IntToString(i));
 724     MCSMessage message(BuildDataMessage("from",
 725                                         "category",
 726                                         id_list.back(),
 727                                         1,
 728                                         id_list.back(),
 729                                         kTTLValue,
 730                                         1,
 731                                         0,
 732                                         "",
 733                                         0));
 734     GetFakeHandler()->ReceiveMessage(message);
 735     WaitForMCSEvent();
 736     PumpLoop();
 737   }
 738   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 739
 740   // Receive a heartbeat confirming the ack (and receive the heartbeat ack).
 741   scoped_ptr<mcs_proto::HeartbeatPing> heartbeat(
 742       new mcs_proto::HeartbeatPing());
 743   heartbeat->set_last_stream_id_received(2);
 744
 745   scoped_ptr<mcs_proto::HeartbeatAck> heartbeat_ack(
 746       new mcs_proto::HeartbeatAck());
 747   heartbeat_ack->set_last_stream_id_received(kAckLimitSize + 2);
 748   GetFakeHandler()->ExpectOutgoingMessage(
 749       MCSMessage(kHeartbeatAckTag,
 750                  heartbeat_ack.PassAs<const google::protobuf::MessageLite>()));
 751
 752   GetFakeHandler()->ReceiveMessage(
 753       MCSMessage(kHeartbeatPingTag,
 754                  heartbeat.PassAs<const google::protobuf::MessageLite>()));
 755   PumpLoop();
 756   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 757
 758   // Rebuild the client. Nothing should be sent on login.
 759   StoreCredentials();
 760   BuildMCSClient();
 761   InitializeClient();
 762   LoginClient(std::vector<std::string>());
 763   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 764 }
 765
 766 // If a message's TTL has expired by the time it reaches the front of the send
 767 // queue, it should be dropped.
 768 TEST_F(MCSClientTest, ExpiredTTLOnSend) {
 769   BuildMCSClient();
 770   InitializeClient();
 771   LoginClient(std::vector<std::string>());
 772   MCSMessage message(BuildDataMessage(
 773       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 774
 775   // Advance time to after the TTL.
 776   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue + 2));
 777   EXPECT_TRUE(sent_message_id().empty());
 778   mcs_client()->SendMessage(message);
 779
 780   // No messages should be sent, but the callback should still be invoked.
 781   EXPECT_EQ("X", sent_message_id());
 782   EXPECT_EQ(MCSClient::TTL_EXCEEDED, message_send_status());
 783   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 784 }
 785
 786 TEST_F(MCSClientTest, ExpiredTTLOnRestart) {
 787   BuildMCSClient();
 788   InitializeClient();
 789   LoginClient(std::vector<std::string>());
 790   GetFakeHandler()->set_fail_send(true);
 791   MCSMessage message(BuildDataMessage(
 792       "from", "category", "X", 1, "1", kTTLValue, 1, 0, "", 0));
 793
 794   // The initial (failed) send.
 795   GetFakeHandler()->ExpectOutgoingMessage(message);
 796   GetFakeHandler()->set_fail_send(false);
 797   mcs_client()->SendMessage(message);
 798   PumpLoop();
 799   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 800
 801   // Move the clock forward and rebuild the client, which should fail the
 802   // message send on restart.
 803   clock()->Advance(base::TimeDelta::FromSeconds(kTTLValue + 2));
 804   StoreCredentials();
 805   BuildMCSClient();
 806   InitializeClient();
 807   LoginClient(std::vector<std::string>());
 808   PumpLoop();
 809   EXPECT_EQ("X", sent_message_id());
 810   EXPECT_EQ(MCSClient::TTL_EXCEEDED, message_send_status());
 811   EXPECT_TRUE(GetFakeHandler()->AllOutgoingMessagesReceived());
 812 }
 813
 814 // Sending two messages with the same collapse key and same app id while
 815 // disconnected should only send the latter of the two on reconnection.
 816 TEST_F(MCSClientTest, CollapseKeysSameApp) {
 817   BuildMCSClient();
 818   InitializeClient();
 819   MCSMessage message(BuildDataMessage(
 820       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 821   mcs_client()->SendMessage(message);
 822
 823   MCSMessage message2(BuildDataMessage(
 824       "from", "app", "message id 2", 1, "1", kTTLValue, 1, 0, "token", 0));
 825   mcs_client()->SendMessage(message2);
 826
 827   LoginClient(std::vector<std::string>());
 828   GetFakeHandler()->ExpectOutgoingMessage(message2);
 829   PumpLoop();
 830 }
 831
 832 // Sending two messages with the same collapse key and different app id while
 833 // disconnected should not perform any collapsing.
 834 TEST_F(MCSClientTest, CollapseKeysDifferentApp) {
 835   BuildMCSClient();
 836   InitializeClient();
 837   MCSMessage message(BuildDataMessage(
 838       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 839   mcs_client()->SendMessage(message);
 840
 841   MCSMessage message2(BuildDataMessage("from",
 842                                        "app 2",
 843                                        "message id 2",
 844                                        1,
 845                                        "2",
 846                                        kTTLValue,
 847                                        1,
 848                                        0,
 849                                        "token",
 850                                        0));
 851   mcs_client()->SendMessage(message2);
 852
 853   LoginClient(std::vector<std::string>());
 854   GetFakeHandler()->ExpectOutgoingMessage(message);
 855   GetFakeHandler()->ExpectOutgoingMessage(message2);
 856   PumpLoop();
 857 }
 858
 859 // Sending two messages with the same collapse key and app id, but different
 860 // user, while disconnected, should not perform any collapsing.
 861 TEST_F(MCSClientTest, CollapseKeysDifferentUser) {
 862   BuildMCSClient();
 863   InitializeClient();
 864   MCSMessage message(BuildDataMessage(
 865       "from", "app", "message id 1", 1, "1", kTTLValue, 1, 0, "token", 0));
 866   mcs_client()->SendMessage(message);
 867
 868   MCSMessage message2(BuildDataMessage("from",
 869                                        "app",
 870                                        "message id 2",
 871                                        1,
 872                                        "2",
 873                                        kTTLValue,
 874                                        1,
 875                                        0,
 876                                        "token",
 877                                        1));
 878   mcs_client()->SendMessage(message2);
 879
 880   LoginClient(std::vector<std::string>());
 881   GetFakeHandler()->ExpectOutgoingMessage(message);
 882   GetFakeHandler()->ExpectOutgoingMessage(message2);
 883   PumpLoop();
 884 }
 885
 886 } // namespace
 887
 888 }  // namespace gcm