gcm_account_mapper_unittest.cc 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955
  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. #include "components/gcm_driver/gcm_account_mapper.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/test/simple_test_clock.h"
  9. #include "base/time/time.h"
  10. #include "components/gcm_driver/fake_gcm_driver.h"
  11. #include "google_apis/gcm/engine/account_mapping.h"
  12. #include "google_apis/gcm/engine/gcm_store.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. namespace gcm {
  15. namespace {
  16. const char kGCMAccountMapperSenderId[] = "745476177629";
  17. const char kGCMAccountMapperSendTo[] = "google.com";
  18. const char kRegistrationId[] = "reg_id";
  19. const char kEmbeddedAppIdKey[] = "gcmb";
  20. const char kTestAppId[] = "test_app_id";
  21. const char kTestDataKey[] = "data_key";
  22. const char kTestDataValue[] = "data_value";
  23. const char kTestCollapseKey[] = "test_collapse_key";
  24. const char kTestSenderId[] = "test_sender_id";
  25. AccountMapping MakeAccountMapping(const CoreAccountId& account_id,
  26. AccountMapping::MappingStatus status,
  27. const base::Time& status_change_timestamp,
  28. const std::string& last_message_id) {
  29. AccountMapping account_mapping;
  30. account_mapping.account_id = account_id;
  31. account_mapping.email = account_id.ToString() + "@gmail.com";
  32. // account_mapping.access_token intentionally left empty.
  33. account_mapping.status = status;
  34. account_mapping.status_change_timestamp = status_change_timestamp;
  35. account_mapping.last_message_id = last_message_id;
  36. return account_mapping;
  37. }
  38. GCMClient::AccountTokenInfo MakeAccountTokenInfo(
  39. const CoreAccountId& account_id) {
  40. GCMClient::AccountTokenInfo account_token;
  41. account_token.account_id = account_id;
  42. account_token.email = account_id.ToString() + "@gmail.com";
  43. account_token.access_token = account_id.ToString() + "_token";
  44. return account_token;
  45. }
  46. void VerifyMappings(const GCMAccountMapper::AccountMappings& expected_mappings,
  47. const GCMAccountMapper::AccountMappings& actual_mappings,
  48. const std::string& verification_info) {
  49. EXPECT_EQ(expected_mappings.size(), actual_mappings.size())
  50. << "Verification Info: " << verification_info;
  51. auto expected_iter = expected_mappings.begin();
  52. auto actual_iter = actual_mappings.begin();
  53. for (; expected_iter != expected_mappings.end() &&
  54. actual_iter != actual_mappings.end();
  55. ++expected_iter, ++actual_iter) {
  56. EXPECT_EQ(expected_iter->email, actual_iter->email)
  57. << "Verification Info: " << verification_info
  58. << "; Account ID of expected: " << expected_iter->account_id;
  59. EXPECT_EQ(expected_iter->account_id, actual_iter->account_id)
  60. << "Verification Info: " << verification_info;
  61. EXPECT_EQ(expected_iter->status, actual_iter->status)
  62. << "Verification Info: " << verification_info
  63. << "; Account ID of expected: " << expected_iter->account_id;
  64. EXPECT_EQ(expected_iter->status_change_timestamp,
  65. actual_iter->status_change_timestamp)
  66. << "Verification Info: " << verification_info
  67. << "; Account ID of expected: " << expected_iter->account_id;
  68. }
  69. }
  70. class CustomFakeGCMDriver : public FakeGCMDriver {
  71. public:
  72. enum LastMessageAction {
  73. NONE,
  74. SEND_STARTED,
  75. SEND_FINISHED,
  76. SEND_ACKNOWLEDGED
  77. };
  78. CustomFakeGCMDriver();
  79. ~CustomFakeGCMDriver() override;
  80. // GCMDriver implementation:
  81. void UpdateAccountMapping(const AccountMapping& account_mapping) override;
  82. void RemoveAccountMapping(const CoreAccountId& account_id) override;
  83. void RegisterImpl(const std::string& app_id,
  84. const std::vector<std::string>& sender_ids) override;
  85. void CompleteRegister(const std::string& registration_id,
  86. GCMClient::Result result);
  87. void CompleteSend(const std::string& message_id, GCMClient::Result result);
  88. void AcknowledgeSend(const std::string& message_id);
  89. void MessageSendError(const std::string& message_id);
  90. void CompleteSendAllMessages();
  91. void AcknowledgeSendAllMessages();
  92. void SetLastMessageAction(const std::string& message_id,
  93. LastMessageAction action);
  94. void Clear();
  95. const AccountMapping& last_account_mapping() const {
  96. return account_mapping_;
  97. }
  98. const std::string& last_message_id() const { return last_message_id_; }
  99. const CoreAccountId& last_removed_account_id() const {
  100. return last_removed_account_id_;
  101. }
  102. LastMessageAction last_action() const { return last_action_; }
  103. bool registration_id_requested() const { return registration_id_requested_; }
  104. protected:
  105. void SendImpl(const std::string& app_id,
  106. const std::string& receiver_id,
  107. const OutgoingMessage& message) override;
  108. private:
  109. AccountMapping account_mapping_;
  110. std::string last_message_id_;
  111. CoreAccountId last_removed_account_id_;
  112. LastMessageAction last_action_;
  113. std::map<std::string, LastMessageAction> all_messages_;
  114. bool registration_id_requested_;
  115. };
  116. CustomFakeGCMDriver::CustomFakeGCMDriver()
  117. : last_action_(NONE), registration_id_requested_(false) {
  118. }
  119. CustomFakeGCMDriver::~CustomFakeGCMDriver() {
  120. }
  121. void CustomFakeGCMDriver::UpdateAccountMapping(
  122. const AccountMapping& account_mapping) {
  123. account_mapping_.email = account_mapping.email;
  124. account_mapping_.account_id = account_mapping.account_id;
  125. account_mapping_.access_token = account_mapping.access_token;
  126. account_mapping_.status = account_mapping.status;
  127. account_mapping_.status_change_timestamp =
  128. account_mapping.status_change_timestamp;
  129. account_mapping_.last_message_id = account_mapping.last_message_id;
  130. }
  131. void CustomFakeGCMDriver::RemoveAccountMapping(
  132. const CoreAccountId& account_id) {
  133. last_removed_account_id_ = account_id;
  134. }
  135. void CustomFakeGCMDriver::RegisterImpl(
  136. const std::string& app_id,
  137. const std::vector<std::string>& sender_ids) {
  138. DCHECK_EQ(kGCMAccountMapperAppId, app_id);
  139. DCHECK_EQ(1u, sender_ids.size());
  140. DCHECK_EQ(kGCMAccountMapperSenderId, sender_ids[0]);
  141. registration_id_requested_ = true;
  142. }
  143. void CustomFakeGCMDriver::CompleteRegister(const std::string& registration_id,
  144. GCMClient::Result result) {
  145. RegisterFinished(kGCMAccountMapperAppId, registration_id, result);
  146. }
  147. void CustomFakeGCMDriver::CompleteSend(const std::string& message_id,
  148. GCMClient::Result result) {
  149. SendFinished(kGCMAccountMapperAppId, message_id, result);
  150. SetLastMessageAction(message_id, SEND_FINISHED);
  151. }
  152. void CustomFakeGCMDriver::AcknowledgeSend(const std::string& message_id) {
  153. GCMAppHandler* handler = GetAppHandler(kGCMAccountMapperAppId);
  154. if (handler)
  155. handler->OnSendAcknowledged(kGCMAccountMapperAppId, message_id);
  156. SetLastMessageAction(message_id, SEND_ACKNOWLEDGED);
  157. }
  158. void CustomFakeGCMDriver::MessageSendError(const std::string& message_id) {
  159. GCMAppHandler* handler = GetAppHandler(kGCMAccountMapperAppId);
  160. if (!handler)
  161. return;
  162. GCMClient::SendErrorDetails send_error;
  163. send_error.message_id = message_id;
  164. send_error.result = GCMClient::TTL_EXCEEDED;
  165. handler->OnSendError(kGCMAccountMapperAppId, send_error);
  166. }
  167. void CustomFakeGCMDriver::SendImpl(const std::string& app_id,
  168. const std::string& receiver_id,
  169. const OutgoingMessage& message) {
  170. DCHECK_EQ(kGCMAccountMapperAppId, app_id);
  171. DCHECK_EQ(kGCMAccountMapperSendTo, receiver_id);
  172. SetLastMessageAction(message.id, SEND_STARTED);
  173. }
  174. void CustomFakeGCMDriver::CompleteSendAllMessages() {
  175. for (std::map<std::string, LastMessageAction>::const_iterator iter =
  176. all_messages_.begin();
  177. iter != all_messages_.end();
  178. ++iter) {
  179. if (iter->second == SEND_STARTED)
  180. CompleteSend(iter->first, GCMClient::SUCCESS);
  181. }
  182. }
  183. void CustomFakeGCMDriver::AcknowledgeSendAllMessages() {
  184. for (std::map<std::string, LastMessageAction>::const_iterator iter =
  185. all_messages_.begin();
  186. iter != all_messages_.end();
  187. ++iter) {
  188. if (iter->second == SEND_FINISHED)
  189. AcknowledgeSend(iter->first);
  190. }
  191. }
  192. void CustomFakeGCMDriver::Clear() {
  193. account_mapping_ = AccountMapping();
  194. last_message_id_.clear();
  195. last_removed_account_id_ = CoreAccountId();
  196. last_action_ = NONE;
  197. registration_id_requested_ = false;
  198. }
  199. void CustomFakeGCMDriver::SetLastMessageAction(const std::string& message_id,
  200. LastMessageAction action) {
  201. last_action_ = action;
  202. last_message_id_ = message_id;
  203. all_messages_[message_id] = action;
  204. }
  205. } // namespace
  206. class GCMAccountMapperTest : public testing::Test {
  207. public:
  208. const CoreAccountId kAccountId;
  209. const CoreAccountId kAccountId1;
  210. const CoreAccountId kAccountId2;
  211. const CoreAccountId kAccountId3;
  212. const CoreAccountId kAccountId4;
  213. GCMAccountMapperTest();
  214. ~GCMAccountMapperTest() override;
  215. void Restart();
  216. void Initialize(const GCMAccountMapper::AccountMappings mappings);
  217. const GCMAccountMapper::AccountMappings& GetAccounts() const {
  218. return account_mapper_->accounts_;
  219. }
  220. void MessageReceived(const std::string& app_id,
  221. const IncomingMessage& message);
  222. GCMAccountMapper* mapper() { return account_mapper_.get(); }
  223. CustomFakeGCMDriver& gcm_driver() { return gcm_driver_; }
  224. base::SimpleTestClock* clock() { return &clock_; }
  225. const std::string& last_received_app_id() const {
  226. return last_received_app_id_;
  227. }
  228. const IncomingMessage& last_received_message() const {
  229. return last_received_message_;
  230. }
  231. private:
  232. CustomFakeGCMDriver gcm_driver_;
  233. std::unique_ptr<GCMAccountMapper> account_mapper_;
  234. base::SimpleTestClock clock_;
  235. std::string last_received_app_id_;
  236. IncomingMessage last_received_message_;
  237. };
  238. GCMAccountMapperTest::GCMAccountMapperTest()
  239. : kAccountId("acc_id"),
  240. kAccountId1("acc_id1"),
  241. kAccountId2("acc_id2"),
  242. kAccountId3("acc_id3"),
  243. kAccountId4("acc_id4") {
  244. Restart();
  245. }
  246. GCMAccountMapperTest::~GCMAccountMapperTest() {
  247. }
  248. void GCMAccountMapperTest::Restart() {
  249. if (account_mapper_)
  250. account_mapper_->ShutdownHandler();
  251. gcm_driver_.RemoveAppHandler(kGCMAccountMapperAppId);
  252. account_mapper_ = std::make_unique<GCMAccountMapper>(&gcm_driver_);
  253. account_mapper_->SetClockForTesting(&clock_);
  254. }
  255. void GCMAccountMapperTest::Initialize(
  256. const GCMAccountMapper::AccountMappings mappings) {
  257. mapper()->Initialize(
  258. mappings, base::BindRepeating(&GCMAccountMapperTest::MessageReceived,
  259. base::Unretained(this)));
  260. }
  261. void GCMAccountMapperTest::MessageReceived(const std::string& app_id,
  262. const IncomingMessage& message) {
  263. last_received_app_id_ = app_id;
  264. last_received_message_ = message;
  265. }
  266. // Tests the initialization of account mappings (from the store) when empty.
  267. // It also checks that initialization triggers registration ID request.
  268. TEST_F(GCMAccountMapperTest, InitializeAccountMappingsEmpty) {
  269. EXPECT_FALSE(gcm_driver().registration_id_requested());
  270. Initialize(GCMAccountMapper::AccountMappings());
  271. EXPECT_TRUE(GetAccounts().empty());
  272. EXPECT_TRUE(gcm_driver().registration_id_requested());
  273. }
  274. // Tests that registration is retried, when new tokens are delivered and in no
  275. // other circumstances.
  276. TEST_F(GCMAccountMapperTest, RegistrationRetryUponFailure) {
  277. Initialize(GCMAccountMapper::AccountMappings());
  278. EXPECT_TRUE(gcm_driver().registration_id_requested());
  279. gcm_driver().Clear();
  280. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::UNKNOWN_ERROR);
  281. EXPECT_FALSE(gcm_driver().registration_id_requested());
  282. gcm_driver().Clear();
  283. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  284. account_tokens.push_back(MakeAccountTokenInfo(kAccountId2));
  285. mapper()->SetAccountTokens(account_tokens);
  286. EXPECT_TRUE(gcm_driver().registration_id_requested());
  287. gcm_driver().Clear();
  288. gcm_driver().CompleteRegister(kRegistrationId,
  289. GCMClient::ASYNC_OPERATION_PENDING);
  290. EXPECT_FALSE(gcm_driver().registration_id_requested());
  291. }
  292. // Tests the initialization of account mappings (from the store).
  293. TEST_F(GCMAccountMapperTest, InitializeAccountMappings) {
  294. GCMAccountMapper::AccountMappings account_mappings;
  295. AccountMapping account_mapping1 = MakeAccountMapping(
  296. kAccountId1, AccountMapping::MAPPED, base::Time::Now(), std::string());
  297. AccountMapping account_mapping2 = MakeAccountMapping(
  298. kAccountId2, AccountMapping::ADDING, base::Time::Now(), "add_message_1");
  299. account_mappings.push_back(account_mapping1);
  300. account_mappings.push_back(account_mapping2);
  301. Initialize(account_mappings);
  302. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  303. EXPECT_EQ(2UL, mappings.size());
  304. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  305. EXPECT_EQ(account_mapping1.account_id, iter->account_id);
  306. EXPECT_EQ(account_mapping1.email, iter->email);
  307. EXPECT_TRUE(account_mapping1.access_token.empty());
  308. EXPECT_EQ(account_mapping1.status, iter->status);
  309. EXPECT_EQ(account_mapping1.status_change_timestamp,
  310. iter->status_change_timestamp);
  311. EXPECT_TRUE(account_mapping1.last_message_id.empty());
  312. ++iter;
  313. EXPECT_EQ(account_mapping2.account_id, iter->account_id);
  314. EXPECT_EQ(account_mapping2.email, iter->email);
  315. EXPECT_TRUE(account_mapping2.access_token.empty());
  316. EXPECT_EQ(account_mapping2.status, iter->status);
  317. EXPECT_EQ(account_mapping2.status_change_timestamp,
  318. iter->status_change_timestamp);
  319. EXPECT_EQ(account_mapping2.last_message_id, iter->last_message_id);
  320. }
  321. // Tests that account tokens are not processed until registration ID is
  322. // available.
  323. TEST_F(GCMAccountMapperTest, SetAccountTokensOnlyWorksWithRegisterationId) {
  324. // Start with empty list.
  325. Initialize(GCMAccountMapper::AccountMappings());
  326. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  327. account_tokens.push_back(MakeAccountTokenInfo(kAccountId));
  328. mapper()->SetAccountTokens(account_tokens);
  329. EXPECT_TRUE(GetAccounts().empty());
  330. account_tokens.clear();
  331. account_tokens.push_back(MakeAccountTokenInfo(kAccountId1));
  332. account_tokens.push_back(MakeAccountTokenInfo(kAccountId2));
  333. mapper()->SetAccountTokens(account_tokens);
  334. EXPECT_TRUE(GetAccounts().empty());
  335. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  336. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  337. EXPECT_EQ(2UL, mappings.size());
  338. EXPECT_EQ(kAccountId1, mappings[0].account_id);
  339. EXPECT_EQ(kAccountId2, mappings[1].account_id);
  340. }
  341. // Tests the part where a new account is added with a token, to the point when
  342. // GCM message is sent.
  343. TEST_F(GCMAccountMapperTest, AddMappingToMessageSent) {
  344. Initialize(GCMAccountMapper::AccountMappings());
  345. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  346. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  347. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  348. account_tokens.push_back(account_token);
  349. mapper()->SetAccountTokens(account_tokens);
  350. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  351. EXPECT_EQ(1UL, mappings.size());
  352. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  353. EXPECT_EQ(kAccountId, iter->account_id);
  354. EXPECT_EQ("acc_id@gmail.com", iter->email);
  355. EXPECT_EQ("acc_id_token", iter->access_token);
  356. EXPECT_EQ(AccountMapping::NEW, iter->status);
  357. EXPECT_EQ(base::Time(), iter->status_change_timestamp);
  358. EXPECT_TRUE(!gcm_driver().last_message_id().empty());
  359. }
  360. // Tests the part where GCM message is successfully queued.
  361. TEST_F(GCMAccountMapperTest, AddMappingMessageQueued) {
  362. Initialize(GCMAccountMapper::AccountMappings());
  363. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  364. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  365. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  366. account_tokens.push_back(account_token);
  367. mapper()->SetAccountTokens(account_tokens);
  368. clock()->SetNow(base::Time::Now());
  369. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  370. EXPECT_EQ(account_token.email, gcm_driver().last_account_mapping().email);
  371. EXPECT_EQ(account_token.account_id,
  372. gcm_driver().last_account_mapping().account_id);
  373. EXPECT_EQ(account_token.access_token,
  374. gcm_driver().last_account_mapping().access_token);
  375. EXPECT_EQ(AccountMapping::ADDING, gcm_driver().last_account_mapping().status);
  376. EXPECT_EQ(clock()->Now(),
  377. gcm_driver().last_account_mapping().status_change_timestamp);
  378. EXPECT_EQ(gcm_driver().last_message_id(),
  379. gcm_driver().last_account_mapping().last_message_id);
  380. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  381. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  382. EXPECT_EQ(account_token.email, iter->email);
  383. EXPECT_EQ(account_token.account_id, iter->account_id);
  384. EXPECT_EQ(account_token.access_token, iter->access_token);
  385. EXPECT_EQ(AccountMapping::ADDING, iter->status);
  386. EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
  387. EXPECT_EQ(gcm_driver().last_message_id(), iter->last_message_id);
  388. }
  389. // Tests status change from ADDING to MAPPED (Message is acknowledged).
  390. TEST_F(GCMAccountMapperTest, AddMappingMessageAcknowledged) {
  391. Initialize(GCMAccountMapper::AccountMappings());
  392. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  393. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  394. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  395. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  396. account_tokens.push_back(account_token);
  397. mapper()->SetAccountTokens(account_tokens);
  398. clock()->SetNow(base::Time::Now());
  399. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  400. clock()->SetNow(base::Time::Now());
  401. gcm_driver().AcknowledgeSend(gcm_driver().last_message_id());
  402. EXPECT_EQ(account_token.email, gcm_driver().last_account_mapping().email);
  403. EXPECT_EQ(account_token.account_id,
  404. gcm_driver().last_account_mapping().account_id);
  405. EXPECT_EQ(account_token.access_token,
  406. gcm_driver().last_account_mapping().access_token);
  407. EXPECT_EQ(AccountMapping::MAPPED, gcm_driver().last_account_mapping().status);
  408. EXPECT_EQ(clock()->Now(),
  409. gcm_driver().last_account_mapping().status_change_timestamp);
  410. EXPECT_TRUE(gcm_driver().last_account_mapping().last_message_id.empty());
  411. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  412. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  413. EXPECT_EQ(account_token.email, iter->email);
  414. EXPECT_EQ(account_token.account_id, iter->account_id);
  415. EXPECT_EQ(account_token.access_token, iter->access_token);
  416. EXPECT_EQ(AccountMapping::MAPPED, iter->status);
  417. EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
  418. EXPECT_TRUE(iter->last_message_id.empty());
  419. }
  420. // Tests status change form ADDING to MAPPED (When message was acknowledged,
  421. // after Chrome was restarted).
  422. TEST_F(GCMAccountMapperTest, AddMappingMessageAckedAfterRestart) {
  423. Initialize(GCMAccountMapper::AccountMappings());
  424. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  425. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  426. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  427. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  428. account_tokens.push_back(account_token);
  429. mapper()->SetAccountTokens(account_tokens);
  430. clock()->SetNow(base::Time::Now());
  431. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  432. Restart();
  433. GCMAccountMapper::AccountMappings stored_mappings;
  434. stored_mappings.push_back(gcm_driver().last_account_mapping());
  435. Initialize(stored_mappings);
  436. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  437. clock()->SetNow(base::Time::Now());
  438. gcm_driver().AcknowledgeSend(gcm_driver().last_message_id());
  439. EXPECT_EQ(account_token.email, gcm_driver().last_account_mapping().email);
  440. EXPECT_EQ(account_token.account_id,
  441. gcm_driver().last_account_mapping().account_id);
  442. EXPECT_EQ(account_token.access_token,
  443. gcm_driver().last_account_mapping().access_token);
  444. EXPECT_EQ(AccountMapping::MAPPED, gcm_driver().last_account_mapping().status);
  445. EXPECT_EQ(clock()->Now(),
  446. gcm_driver().last_account_mapping().status_change_timestamp);
  447. EXPECT_TRUE(gcm_driver().last_account_mapping().last_message_id.empty());
  448. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  449. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  450. EXPECT_EQ(account_token.email, iter->email);
  451. EXPECT_EQ(account_token.account_id, iter->account_id);
  452. EXPECT_EQ(account_token.access_token, iter->access_token);
  453. EXPECT_EQ(AccountMapping::MAPPED, iter->status);
  454. EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
  455. EXPECT_TRUE(iter->last_message_id.empty());
  456. }
  457. // Tests a case when ADD message times out for a new account.
  458. TEST_F(GCMAccountMapperTest, AddMappingMessageSendErrorForNewAccount) {
  459. Initialize(GCMAccountMapper::AccountMappings());
  460. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  461. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  462. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  463. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  464. account_tokens.push_back(account_token);
  465. mapper()->SetAccountTokens(account_tokens);
  466. clock()->SetNow(base::Time::Now());
  467. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  468. clock()->SetNow(base::Time::Now());
  469. std::string old_message_id = gcm_driver().last_message_id();
  470. gcm_driver().MessageSendError(old_message_id);
  471. // No new message is sent because of the send error, as the token is stale.
  472. // Because the account was new, the entry should be deleted.
  473. EXPECT_EQ(old_message_id, gcm_driver().last_message_id());
  474. EXPECT_EQ(account_token.account_id, gcm_driver().last_removed_account_id());
  475. EXPECT_TRUE(GetAccounts().empty());
  476. }
  477. /// Tests a case when ADD message times out for a MAPPED account.
  478. TEST_F(GCMAccountMapperTest, AddMappingMessageSendErrorForMappedAccount) {
  479. // Start with one account that is mapped.
  480. base::Time status_change_timestamp = base::Time::Now();
  481. AccountMapping mapping =
  482. MakeAccountMapping(kAccountId, AccountMapping::MAPPED,
  483. status_change_timestamp, "add_message_id");
  484. GCMAccountMapper::AccountMappings stored_mappings;
  485. stored_mappings.push_back(mapping);
  486. Initialize(stored_mappings);
  487. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  488. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  489. clock()->SetNow(base::Time::Now());
  490. gcm_driver().MessageSendError("add_message_id");
  491. // No new message is sent because of the send error, as the token is stale.
  492. // Because the account was new, the entry should be deleted.
  493. EXPECT_TRUE(gcm_driver().last_message_id().empty());
  494. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  495. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  496. EXPECT_EQ(mapping.email, iter->email);
  497. EXPECT_EQ(mapping.account_id, iter->account_id);
  498. EXPECT_EQ(mapping.access_token, iter->access_token);
  499. EXPECT_EQ(AccountMapping::MAPPED, iter->status);
  500. EXPECT_EQ(status_change_timestamp, iter->status_change_timestamp);
  501. EXPECT_TRUE(iter->last_message_id.empty());
  502. }
  503. // Tests that a missing token for an account will trigger removing of that
  504. // account. This test goes only until the message is passed to GCM.
  505. TEST_F(GCMAccountMapperTest, RemoveMappingToMessageSent) {
  506. // Start with one account that is mapped.
  507. AccountMapping mapping = MakeAccountMapping(
  508. kAccountId, AccountMapping::MAPPED, base::Time::Now(), std::string());
  509. GCMAccountMapper::AccountMappings stored_mappings;
  510. stored_mappings.push_back(mapping);
  511. Initialize(stored_mappings);
  512. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  513. clock()->SetNow(base::Time::Now());
  514. mapper()->SetAccountTokens(std::vector<GCMClient::AccountTokenInfo>());
  515. EXPECT_EQ(mapping.account_id, gcm_driver().last_account_mapping().account_id);
  516. EXPECT_EQ(mapping.email, gcm_driver().last_account_mapping().email);
  517. EXPECT_EQ(AccountMapping::REMOVING,
  518. gcm_driver().last_account_mapping().status);
  519. EXPECT_EQ(clock()->Now(),
  520. gcm_driver().last_account_mapping().status_change_timestamp);
  521. EXPECT_TRUE(gcm_driver().last_account_mapping().last_message_id.empty());
  522. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  523. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  524. EXPECT_EQ(mapping.email, iter->email);
  525. EXPECT_EQ(mapping.account_id, iter->account_id);
  526. EXPECT_EQ(mapping.access_token, iter->access_token);
  527. EXPECT_EQ(AccountMapping::REMOVING, iter->status);
  528. EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
  529. EXPECT_TRUE(iter->last_message_id.empty());
  530. }
  531. // Tests that a missing token for an account will trigger removing of that
  532. // account. This test goes until the message is queued by GCM.
  533. TEST_F(GCMAccountMapperTest, RemoveMappingMessageQueued) {
  534. // Start with one account that is mapped.
  535. AccountMapping mapping = MakeAccountMapping(
  536. kAccountId, AccountMapping::MAPPED, base::Time::Now(), std::string());
  537. GCMAccountMapper::AccountMappings stored_mappings;
  538. stored_mappings.push_back(mapping);
  539. Initialize(stored_mappings);
  540. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  541. clock()->SetNow(base::Time::Now());
  542. base::Time status_change_timestamp = clock()->Now();
  543. mapper()->SetAccountTokens(std::vector<GCMClient::AccountTokenInfo>());
  544. clock()->SetNow(base::Time::Now());
  545. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  546. EXPECT_EQ(mapping.account_id, gcm_driver().last_account_mapping().account_id);
  547. EXPECT_EQ(mapping.email, gcm_driver().last_account_mapping().email);
  548. EXPECT_EQ(AccountMapping::REMOVING,
  549. gcm_driver().last_account_mapping().status);
  550. EXPECT_EQ(status_change_timestamp,
  551. gcm_driver().last_account_mapping().status_change_timestamp);
  552. EXPECT_TRUE(!gcm_driver().last_account_mapping().last_message_id.empty());
  553. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  554. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  555. EXPECT_EQ(mapping.email, iter->email);
  556. EXPECT_EQ(mapping.account_id, iter->account_id);
  557. EXPECT_EQ(mapping.access_token, iter->access_token);
  558. EXPECT_EQ(AccountMapping::REMOVING, iter->status);
  559. EXPECT_EQ(status_change_timestamp, iter->status_change_timestamp);
  560. EXPECT_EQ(gcm_driver().last_account_mapping().last_message_id,
  561. iter->last_message_id);
  562. }
  563. // Tests that a missing token for an account will trigger removing of that
  564. // account. This test goes until the message is acknowledged by GCM.
  565. // This is a complete success scenario for account removal, and it end with
  566. // account mapping being completely gone.
  567. TEST_F(GCMAccountMapperTest, RemoveMappingMessageAcknowledged) {
  568. // Start with one account that is mapped.
  569. AccountMapping mapping = MakeAccountMapping(
  570. kAccountId, AccountMapping::MAPPED, base::Time::Now(), std::string());
  571. GCMAccountMapper::AccountMappings stored_mappings;
  572. stored_mappings.push_back(mapping);
  573. Initialize(stored_mappings);
  574. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  575. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  576. clock()->SetNow(base::Time::Now());
  577. mapper()->SetAccountTokens(std::vector<GCMClient::AccountTokenInfo>());
  578. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  579. gcm_driver().AcknowledgeSend(gcm_driver().last_message_id());
  580. EXPECT_EQ(mapping.account_id, gcm_driver().last_removed_account_id());
  581. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  582. EXPECT_TRUE(mappings.empty());
  583. }
  584. // Tests that account removing proceeds, when a removing message is acked after
  585. // Chrome was restarted.
  586. TEST_F(GCMAccountMapperTest, RemoveMappingMessageAckedAfterRestart) {
  587. // Start with one account that is mapped.
  588. AccountMapping mapping =
  589. MakeAccountMapping(kAccountId, AccountMapping::REMOVING,
  590. base::Time::Now(), "remove_message_id");
  591. GCMAccountMapper::AccountMappings stored_mappings;
  592. stored_mappings.push_back(mapping);
  593. Initialize(stored_mappings);
  594. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  595. gcm_driver().AcknowledgeSend("remove_message_id");
  596. EXPECT_EQ(mapping.account_id, gcm_driver().last_removed_account_id());
  597. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  598. EXPECT_TRUE(mappings.empty());
  599. }
  600. // Tests that account removing proceeds, when a removing message is acked after
  601. // Chrome was restarted.
  602. TEST_F(GCMAccountMapperTest, RemoveMappingMessageSendError) {
  603. // Start with one account that is mapped.
  604. base::Time status_change_timestamp = base::Time::Now();
  605. AccountMapping mapping =
  606. MakeAccountMapping(kAccountId, AccountMapping::REMOVING,
  607. status_change_timestamp, "remove_message_id");
  608. GCMAccountMapper::AccountMappings stored_mappings;
  609. stored_mappings.push_back(mapping);
  610. Initialize(stored_mappings);
  611. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  612. clock()->SetNow(base::Time::Now());
  613. gcm_driver().MessageSendError("remove_message_id");
  614. EXPECT_TRUE(gcm_driver().last_removed_account_id().empty());
  615. EXPECT_EQ(mapping.account_id, gcm_driver().last_account_mapping().account_id);
  616. EXPECT_EQ(mapping.email, gcm_driver().last_account_mapping().email);
  617. EXPECT_EQ(AccountMapping::REMOVING,
  618. gcm_driver().last_account_mapping().status);
  619. EXPECT_EQ(status_change_timestamp,
  620. gcm_driver().last_account_mapping().status_change_timestamp);
  621. // Message is not persisted, until send is completed.
  622. EXPECT_TRUE(gcm_driver().last_account_mapping().last_message_id.empty());
  623. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  624. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  625. EXPECT_EQ(mapping.email, iter->email);
  626. EXPECT_EQ(mapping.account_id, iter->account_id);
  627. EXPECT_TRUE(iter->access_token.empty());
  628. EXPECT_EQ(AccountMapping::REMOVING, iter->status);
  629. EXPECT_EQ(status_change_timestamp, iter->status_change_timestamp);
  630. EXPECT_TRUE(iter->last_message_id.empty());
  631. }
  632. // Tests that, if a new token arrives when the adding message is in progress
  633. // no new message is sent and account mapper still waits for the first one to
  634. // complete.
  635. TEST_F(GCMAccountMapperTest, TokenIsRefreshedWhenAdding) {
  636. Initialize(GCMAccountMapper::AccountMappings());
  637. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  638. clock()->SetNow(base::Time::Now());
  639. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  640. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  641. account_tokens.push_back(account_token);
  642. mapper()->SetAccountTokens(account_tokens);
  643. DCHECK_EQ(CustomFakeGCMDriver::SEND_STARTED, gcm_driver().last_action());
  644. clock()->SetNow(base::Time::Now());
  645. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  646. DCHECK_EQ(CustomFakeGCMDriver::SEND_FINISHED, gcm_driver().last_action());
  647. // Providing another token and clearing status.
  648. gcm_driver().Clear();
  649. mapper()->SetAccountTokens(account_tokens);
  650. DCHECK_EQ(CustomFakeGCMDriver::NONE, gcm_driver().last_action());
  651. }
  652. // Tests that, if a new token arrives when a removing message is in progress
  653. // a new adding message is sent and while account mapping status is changed to
  654. // mapped. If the original Removing message arrives it is discarded.
  655. TEST_F(GCMAccountMapperTest, TokenIsRefreshedWhenRemoving) {
  656. // Start with one account that is mapped.
  657. AccountMapping mapping = MakeAccountMapping(
  658. kAccountId, AccountMapping::MAPPED, base::Time::Now(), std::string());
  659. GCMAccountMapper::AccountMappings stored_mappings;
  660. stored_mappings.push_back(mapping);
  661. Initialize(stored_mappings);
  662. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  663. clock()->SetNow(base::Time::Now());
  664. // Remove the token to trigger a remove message to be sent
  665. mapper()->SetAccountTokens(std::vector<GCMClient::AccountTokenInfo>());
  666. EXPECT_EQ(CustomFakeGCMDriver::SEND_STARTED, gcm_driver().last_action());
  667. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  668. EXPECT_EQ(CustomFakeGCMDriver::SEND_FINISHED, gcm_driver().last_action());
  669. std::string remove_message_id = gcm_driver().last_message_id();
  670. gcm_driver().Clear();
  671. // The account mapping for acc_id is now in status REMOVING.
  672. // Adding the token for that account.
  673. clock()->SetNow(base::Time::Now());
  674. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  675. GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo(kAccountId);
  676. account_tokens.push_back(account_token);
  677. mapper()->SetAccountTokens(account_tokens);
  678. DCHECK_EQ(CustomFakeGCMDriver::SEND_STARTED, gcm_driver().last_action());
  679. gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
  680. EXPECT_EQ(CustomFakeGCMDriver::SEND_FINISHED, gcm_driver().last_action());
  681. std::string add_message_id = gcm_driver().last_message_id();
  682. // A remove message confirmation arrives now, but should be ignored.
  683. gcm_driver().AcknowledgeSend(remove_message_id);
  684. GCMAccountMapper::AccountMappings mappings = GetAccounts();
  685. GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
  686. EXPECT_EQ(mapping.email, iter->email);
  687. EXPECT_EQ(mapping.account_id, iter->account_id);
  688. EXPECT_FALSE(iter->access_token.empty());
  689. EXPECT_EQ(AccountMapping::MAPPED, iter->status);
  690. // Status change timestamp is set to very long time ago, to make sure the next
  691. // round of mapping picks it up.
  692. EXPECT_EQ(base::Time(), iter->status_change_timestamp);
  693. EXPECT_EQ(add_message_id, iter->last_message_id);
  694. }
  695. // Tests adding/removing works for multiple accounts, after a restart and when
  696. // tokens are periodically delierverd.
  697. TEST_F(GCMAccountMapperTest, MultipleAccountMappings) {
  698. clock()->SetNow(base::Time::Now());
  699. base::Time half_hour_ago = clock()->Now() - base::Minutes(30);
  700. GCMAccountMapper::AccountMappings stored_mappings;
  701. stored_mappings.push_back(MakeAccountMapping(
  702. kAccountId, AccountMapping::ADDING, half_hour_ago, "acc_id_msg"));
  703. stored_mappings.push_back(MakeAccountMapping(
  704. kAccountId1, AccountMapping::MAPPED, half_hour_ago, "acc_id_1_msg"));
  705. stored_mappings.push_back(MakeAccountMapping(
  706. kAccountId2, AccountMapping::REMOVING, half_hour_ago, "acc_id_2_msg"));
  707. Initialize(stored_mappings);
  708. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  709. gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
  710. GCMAccountMapper::AccountMappings expected_mappings(stored_mappings);
  711. // Finish messages after a restart.
  712. clock()->SetNow(base::Time::Now());
  713. gcm_driver().AcknowledgeSend(expected_mappings[0].last_message_id);
  714. expected_mappings[0].status_change_timestamp = clock()->Now();
  715. expected_mappings[0].status = AccountMapping::MAPPED;
  716. expected_mappings[0].last_message_id.clear();
  717. clock()->SetNow(base::Time::Now());
  718. gcm_driver().AcknowledgeSend(expected_mappings[1].last_message_id);
  719. expected_mappings[1].status_change_timestamp = clock()->Now();
  720. expected_mappings[1].status = AccountMapping::MAPPED;
  721. expected_mappings[1].last_message_id.clear();
  722. // Upon success last element is removed.
  723. clock()->SetNow(base::Time::Now());
  724. gcm_driver().AcknowledgeSend(expected_mappings[2].last_message_id);
  725. expected_mappings.pop_back();
  726. VerifyMappings(expected_mappings, GetAccounts(), "Step 1, After restart");
  727. // One of accounts gets removed.
  728. std::vector<GCMClient::AccountTokenInfo> account_tokens;
  729. account_tokens.push_back(MakeAccountTokenInfo(kAccountId));
  730. // Advance a day to make sure existing mappings will be reported.
  731. clock()->SetNow(clock()->Now() + base::Days(1));
  732. mapper()->SetAccountTokens(account_tokens);
  733. expected_mappings[0].status = AccountMapping::MAPPED;
  734. expected_mappings[1].status = AccountMapping::REMOVING;
  735. expected_mappings[1].status_change_timestamp = clock()->Now();
  736. gcm_driver().CompleteSendAllMessages();
  737. VerifyMappings(
  738. expected_mappings, GetAccounts(), "Step 2, One account is being removed");
  739. clock()->SetNow(clock()->Now() + base::Seconds(5));
  740. gcm_driver().AcknowledgeSendAllMessages();
  741. expected_mappings[0].status_change_timestamp = clock()->Now();
  742. expected_mappings.pop_back();
  743. VerifyMappings(
  744. expected_mappings, GetAccounts(), "Step 3, Removing completed");
  745. account_tokens.clear();
  746. account_tokens.push_back(MakeAccountTokenInfo(kAccountId));
  747. account_tokens.push_back(MakeAccountTokenInfo(kAccountId3));
  748. account_tokens.push_back(MakeAccountTokenInfo(kAccountId4));
  749. // Advance a day to make sure existing mappings will be reported.
  750. clock()->SetNow(clock()->Now() + base::Days(1));
  751. mapper()->SetAccountTokens(account_tokens);
  752. // Mapping from acc_id_0 still in position 0
  753. expected_mappings.push_back(MakeAccountMapping(
  754. kAccountId3, AccountMapping::NEW, base::Time(), std::string()));
  755. expected_mappings.push_back(MakeAccountMapping(
  756. kAccountId4, AccountMapping::NEW, base::Time(), std::string()));
  757. VerifyMappings(expected_mappings, GetAccounts(), "Step 4, Two new accounts");
  758. clock()->SetNow(clock()->Now() + base::Seconds(1));
  759. gcm_driver().CompleteSendAllMessages();
  760. expected_mappings[1].status = AccountMapping::ADDING;
  761. expected_mappings[1].status_change_timestamp = clock()->Now();
  762. expected_mappings[2].status = AccountMapping::ADDING;
  763. expected_mappings[2].status_change_timestamp = clock()->Now();
  764. VerifyMappings(
  765. expected_mappings, GetAccounts(), "Step 5, Two accounts being added");
  766. clock()->SetNow(clock()->Now() + base::Seconds(5));
  767. gcm_driver().AcknowledgeSendAllMessages();
  768. expected_mappings[0].status_change_timestamp = clock()->Now();
  769. expected_mappings[1].status_change_timestamp = clock()->Now();
  770. expected_mappings[1].status = AccountMapping::MAPPED;
  771. expected_mappings[2].status_change_timestamp = clock()->Now();
  772. expected_mappings[2].status = AccountMapping::MAPPED;
  773. VerifyMappings(
  774. expected_mappings, GetAccounts(), "Step 6, Three mapped accounts");
  775. }
  776. TEST_F(GCMAccountMapperTest, DispatchMessageSentToGaiaID) {
  777. Initialize(GCMAccountMapper::AccountMappings());
  778. gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
  779. IncomingMessage message;
  780. message.data[kEmbeddedAppIdKey] = kTestAppId;
  781. message.data[kTestDataKey] = kTestDataValue;
  782. message.collapse_key = kTestCollapseKey;
  783. message.sender_id = kTestSenderId;
  784. mapper()->OnMessage(kGCMAccountMapperAppId, message);
  785. EXPECT_EQ(kTestAppId, last_received_app_id());
  786. EXPECT_EQ(1UL, last_received_message().data.size());
  787. auto it = last_received_message().data.find(kTestDataKey);
  788. EXPECT_TRUE(it != last_received_message().data.end());
  789. EXPECT_EQ(kTestDataValue, it->second);
  790. EXPECT_EQ(kTestCollapseKey, last_received_message().collapse_key);
  791. EXPECT_EQ(kTestSenderId, last_received_message().sender_id);
  792. }
  793. } // namespace gcm