fcm_network_handler_unittests.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505
  1. // Copyright 2018 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/invalidation/impl/fcm_network_handler.h"
  5. #include <memory>
  6. #include <string>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/files/file_path.h"
  10. #include "base/strings/string_number_conversions.h"
  11. #include "base/test/metrics/histogram_tester.h"
  12. #include "base/test/mock_callback.h"
  13. #include "base/test/scoped_feature_list.h"
  14. #include "base/test/task_environment.h"
  15. #include "base/test/test_mock_time_task_runner.h"
  16. #include "base/time/time.h"
  17. #include "base/timer/timer.h"
  18. #include "build/build_config.h"
  19. #include "components/gcm_driver/gcm_driver.h"
  20. #include "components/gcm_driver/instance_id/instance_id.h"
  21. #include "components/gcm_driver/instance_id/instance_id_driver.h"
  22. #include "components/invalidation/impl/invalidation_switches.h"
  23. #include "components/invalidation/impl/status.h"
  24. #include "google_apis/gcm/engine/account_mapping.h"
  25. #include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
  26. #include "testing/gmock/include/gmock/gmock.h"
  27. using base::TestMockTimeTaskRunner;
  28. using gcm::InstanceIDHandler;
  29. using instance_id::InstanceID;
  30. using instance_id::InstanceIDDriver;
  31. using testing::_;
  32. using testing::Eq;
  33. using testing::Invoke;
  34. using testing::StrictMock;
  35. using testing::WithArg;
  36. namespace invalidation {
  37. namespace {
  38. const char kInvalidationsAppId[] = "com.google.chrome.fcm.invalidations";
  39. base::Time GetDummyNow() {
  40. base::Time out_time;
  41. EXPECT_TRUE(base::Time::FromUTCString("2017-01-02T00:00:01Z", &out_time));
  42. return out_time;
  43. }
  44. gcm::IncomingMessage CreateValidMessage() {
  45. gcm::IncomingMessage message;
  46. message.data["payload"] = "payload";
  47. message.data["version"] = "42";
  48. message.sender_id = "private_topic";
  49. return message;
  50. }
  51. class MockInstanceID : public InstanceID {
  52. public:
  53. MockInstanceID() : InstanceID("app_id", /*gcm_driver=*/nullptr) {}
  54. ~MockInstanceID() override = default;
  55. MOCK_METHOD1(GetID, void(GetIDCallback callback));
  56. MOCK_METHOD1(GetCreationTime, void(GetCreationTimeCallback callback));
  57. MOCK_METHOD5(GetToken,
  58. void(const std::string& authorized_entity,
  59. const std::string& scope,
  60. base::TimeDelta time_to_live,
  61. std::set<Flags> flags,
  62. GetTokenCallback callback));
  63. MOCK_METHOD4(ValidateToken,
  64. void(const std::string& authorized_entity,
  65. const std::string& scope,
  66. const std::string& token,
  67. ValidateTokenCallback callback));
  68. protected:
  69. MOCK_METHOD3(DeleteTokenImpl,
  70. void(const std::string& authorized_entity,
  71. const std::string& scope,
  72. DeleteTokenCallback callback));
  73. MOCK_METHOD1(DeleteIDImpl, void(DeleteIDCallback callback));
  74. };
  75. class MockGCMDriver : public gcm::GCMDriver {
  76. public:
  77. MockGCMDriver()
  78. : GCMDriver(
  79. /*store_path=*/base::FilePath(),
  80. /*blocking_task_runner=*/nullptr) {}
  81. ~MockGCMDriver() override = default;
  82. MOCK_METHOD4(ValidateRegistration,
  83. void(const std::string& app_id,
  84. const std::vector<std::string>& sender_ids,
  85. const std::string& registration_id,
  86. ValidateRegistrationCallback callback));
  87. MOCK_METHOD0(OnSignedIn, void());
  88. MOCK_METHOD0(OnSignedOut, void());
  89. MOCK_METHOD1(AddConnectionObserver,
  90. void(gcm::GCMConnectionObserver* observer));
  91. MOCK_METHOD1(RemoveConnectionObserver,
  92. void(gcm::GCMConnectionObserver* observer));
  93. MOCK_METHOD0(Enable, void());
  94. MOCK_METHOD0(Disable, void());
  95. MOCK_CONST_METHOD0(GetGCMClientForTesting, gcm::GCMClient*());
  96. MOCK_CONST_METHOD0(IsStarted, bool());
  97. MOCK_CONST_METHOD0(IsConnected, bool());
  98. MOCK_METHOD2(GetGCMStatistics,
  99. void(GetGCMStatisticsCallback callback,
  100. ClearActivityLogs clear_logs));
  101. MOCK_METHOD2(SetGCMRecording,
  102. void(const GCMStatisticsRecordingCallback& callback,
  103. bool recording));
  104. MOCK_METHOD1(SetAccountTokens,
  105. void(const std::vector<gcm::GCMClient::AccountTokenInfo>&
  106. account_tokens));
  107. MOCK_METHOD1(UpdateAccountMapping,
  108. void(const gcm::AccountMapping& account_mapping));
  109. MOCK_METHOD1(RemoveAccountMapping, void(const CoreAccountId& account_id));
  110. MOCK_METHOD0(GetLastTokenFetchTime, base::Time());
  111. MOCK_METHOD1(SetLastTokenFetchTime, void(const base::Time& time));
  112. MOCK_METHOD0(GetInstanceIDHandlerInternal, InstanceIDHandler*());
  113. MOCK_METHOD2(AddHeartbeatInterval,
  114. void(const std::string& scope, int interval_ms));
  115. MOCK_METHOD1(RemoveHeartbeatInterval, void(const std::string& scope));
  116. protected:
  117. MOCK_METHOD1(EnsureStarted,
  118. gcm::GCMClient::Result(gcm::GCMClient::StartMode start_mode));
  119. MOCK_METHOD2(RegisterImpl,
  120. void(const std::string& app_id,
  121. const std::vector<std::string>& sender_ids));
  122. MOCK_METHOD1(UnregisterImpl, void(const std::string& app_id));
  123. MOCK_METHOD3(SendImpl,
  124. void(const std::string& app_id,
  125. const std::string& receiver_id,
  126. const gcm::OutgoingMessage& message));
  127. MOCK_METHOD2(RecordDecryptionFailure,
  128. void(const std::string& app_id,
  129. gcm::GCMDecryptionResult result));
  130. };
  131. class MockInstanceIDDriver : public InstanceIDDriver {
  132. public:
  133. MockInstanceIDDriver() : InstanceIDDriver(/*gcm_driver=*/nullptr) {}
  134. ~MockInstanceIDDriver() override = default;
  135. MOCK_METHOD1(GetInstanceID, InstanceID*(const std::string& app_id));
  136. MOCK_METHOD1(RemoveInstanceID, void(const std::string& app_id));
  137. MOCK_CONST_METHOD1(ExistsInstanceID, bool(const std::string& app_id));
  138. };
  139. class MockOnTokenCallback {
  140. public:
  141. FCMSyncNetworkChannel::TokenCallback Get() {
  142. return base::BindRepeating(&MockOnTokenCallback::Run,
  143. base::Unretained(this));
  144. }
  145. MOCK_METHOD1(Run, void(const std::string&));
  146. };
  147. class MockOnMessageCallback {
  148. public:
  149. FCMSyncNetworkChannel::MessageCallback Get() {
  150. return base::BindRepeating(&MockOnMessageCallback::Run,
  151. base::Unretained(this));
  152. }
  153. MOCK_METHOD4(Run,
  154. void(const std::string&,
  155. const std::string&,
  156. const std::string&,
  157. int64_t));
  158. };
  159. } // namespace
  160. class FCMNetworkHandlerTest : public testing::Test {
  161. public:
  162. void SetUp() override {
  163. // Our app handler obtains InstanceID through InstanceIDDriver. We mock
  164. // InstanceIDDriver and return MockInstanceID through it.
  165. mock_instance_id_driver_ =
  166. std::make_unique<StrictMock<MockInstanceIDDriver>>();
  167. mock_instance_id_ = std::make_unique<StrictMock<MockInstanceID>>();
  168. mock_gcm_driver_ = std::make_unique<StrictMock<MockGCMDriver>>();
  169. // This is called in FCMNetworkHandler.
  170. EXPECT_CALL(*mock_instance_id_driver_, GetInstanceID(kInvalidationsAppId))
  171. .WillRepeatedly(Return(mock_instance_id_.get()));
  172. }
  173. std::unique_ptr<FCMNetworkHandler> MakeHandler(
  174. const std::string& sender_id = "fake_sender_id") {
  175. return std::make_unique<FCMNetworkHandler>(mock_gcm_driver_.get(),
  176. mock_instance_id_driver_.get(),
  177. sender_id, kInvalidationsAppId);
  178. }
  179. std::unique_ptr<FCMNetworkHandler> MakeHandlerReadyForMessage(
  180. FCMSyncNetworkChannel::MessageCallback mock_on_message_callback) {
  181. std::unique_ptr<FCMNetworkHandler> handler = MakeHandler();
  182. handler->SetMessageReceiver(mock_on_message_callback);
  183. EXPECT_CALL(*mock_instance_id(), GetToken)
  184. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  185. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  186. })));
  187. handler->StartListening();
  188. return handler;
  189. }
  190. StrictMock<MockInstanceID>* mock_instance_id() {
  191. return mock_instance_id_.get();
  192. }
  193. scoped_refptr<TestMockTimeTaskRunner> CreateFakeTaskRunnerAndInjectToHandler(
  194. std::unique_ptr<FCMNetworkHandler>& handler) {
  195. scoped_refptr<TestMockTimeTaskRunner> task_runner(
  196. new TestMockTimeTaskRunner(GetDummyNow(), base::TimeTicks::Now()));
  197. auto token_validation_timer =
  198. std::make_unique<base::OneShotTimer>(task_runner->GetMockTickClock());
  199. token_validation_timer->SetTaskRunner(task_runner);
  200. handler->SetTokenValidationTimerForTesting(
  201. std::move(token_validation_timer));
  202. return task_runner;
  203. }
  204. private:
  205. base::test::SingleThreadTaskEnvironment task_environment_;
  206. std::unique_ptr<StrictMock<MockGCMDriver>> mock_gcm_driver_;
  207. std::unique_ptr<StrictMock<MockInstanceIDDriver>> mock_instance_id_driver_;
  208. std::unique_ptr<StrictMock<MockInstanceID>> mock_instance_id_;
  209. };
  210. class FCMNetworkHandlerTestWithTTL : public FCMNetworkHandlerTest {
  211. public:
  212. static constexpr int kTimeToLiveInSeconds = 100;
  213. FCMNetworkHandlerTestWithTTL() {
  214. base::FieldTrialParams feature_params = {
  215. {"time_to_live_seconds", base::NumberToString(kTimeToLiveInSeconds)}};
  216. override_features_.InitWithFeaturesAndParameters(
  217. /*enabled_features=*/
  218. {{switches::kSyncInstanceIDTokenTTL, feature_params},
  219. {switches::kPolicyInstanceIDTokenTTL, feature_params}},
  220. /*disabled_features=*/{});
  221. }
  222. ~FCMNetworkHandlerTestWithTTL() override = default;
  223. private:
  224. base::test::ScopedFeatureList override_features_;
  225. };
  226. TEST_F(FCMNetworkHandlerTest, ShouldPassTheTokenOnceRecieved) {
  227. std::unique_ptr<FCMNetworkHandler> handler = MakeHandler();
  228. MockOnTokenCallback mock_on_token_callback;
  229. handler->SetTokenReceiver(mock_on_token_callback.Get());
  230. // Check that the handler gets the token through GetToken.
  231. EXPECT_CALL(*mock_instance_id(), GetToken)
  232. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  233. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  234. })));
  235. EXPECT_CALL(mock_on_token_callback, Run("token")).Times(1);
  236. handler->StartListening();
  237. }
  238. TEST_F(FCMNetworkHandlerTest, ShouldPassTheTokenOnceSubscribed) {
  239. std::unique_ptr<FCMNetworkHandler> handler = MakeHandler();
  240. MockOnTokenCallback mock_on_token_callback;
  241. // Check that the handler gets the token through GetToken.
  242. EXPECT_CALL(*mock_instance_id(), GetToken)
  243. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  244. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  245. })));
  246. EXPECT_CALL(mock_on_token_callback, Run).Times(0);
  247. handler->StartListening();
  248. base::RunLoop().RunUntilIdle();
  249. EXPECT_CALL(mock_on_token_callback, Run("token")).Times(1);
  250. handler->SetTokenReceiver(mock_on_token_callback.Get());
  251. }
  252. TEST_F(FCMNetworkHandlerTest, ShouldNotInvokeMessageCallbackOnEmptyMessage) {
  253. MockOnMessageCallback mock_on_message_callback;
  254. gcm::IncomingMessage message;
  255. std::unique_ptr<FCMNetworkHandler> handler = MakeHandler();
  256. EXPECT_CALL(mock_on_message_callback, Run).Times(0);
  257. handler->SetMessageReceiver(mock_on_message_callback.Get());
  258. EXPECT_CALL(*mock_instance_id(), GetToken)
  259. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  260. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  261. })));
  262. handler->StartListening();
  263. handler->OnMessage(kInvalidationsAppId, gcm::IncomingMessage());
  264. }
  265. TEST_F(FCMNetworkHandlerTest, ShouldInvokeMessageCallbackOnValidMessage) {
  266. base::HistogramTester histogram_tester;
  267. MockOnMessageCallback mock_on_message_callback;
  268. gcm::IncomingMessage message = CreateValidMessage();
  269. std::unique_ptr<FCMNetworkHandler> handler =
  270. MakeHandlerReadyForMessage(mock_on_message_callback.Get());
  271. EXPECT_CALL(mock_on_message_callback, Run("payload", "private_topic", "", 42))
  272. .Times(1);
  273. EXPECT_CALL(mock_on_message_callback,
  274. Run("payload", "private_topic", "public_topic", 42))
  275. .Times(1);
  276. handler->OnMessage(kInvalidationsAppId, message);
  277. message.data["external_name"] = "public_topic";
  278. handler->OnMessage(kInvalidationsAppId, message);
  279. EXPECT_THAT(
  280. histogram_tester.GetAllSamples("FCMInvalidations.FCMMessageStatus"),
  281. testing::ElementsAre(base::Bucket(
  282. static_cast<int>(InvalidationParsingStatus::kSuccess) /* min */,
  283. 2 /* count */)));
  284. }
  285. TEST_F(FCMNetworkHandlerTest,
  286. ShouldNotInvokeMessageCallbackOnMessageWithEmptyVersion) {
  287. base::HistogramTester histogram_tester;
  288. MockOnMessageCallback mock_on_message_callback;
  289. gcm::IncomingMessage message = CreateValidMessage();
  290. // Clear version.
  291. auto it = message.data.find("version");
  292. message.data.erase(it);
  293. std::unique_ptr<FCMNetworkHandler> handler =
  294. MakeHandlerReadyForMessage(mock_on_message_callback.Get());
  295. EXPECT_CALL(mock_on_message_callback, Run).Times(0);
  296. handler->OnMessage(kInvalidationsAppId, message);
  297. EXPECT_THAT(
  298. histogram_tester.GetAllSamples("FCMInvalidations.FCMMessageStatus"),
  299. testing::ElementsAre(base::Bucket(
  300. static_cast<int>(InvalidationParsingStatus::kVersionEmpty) /* min */,
  301. 1 /* count */)));
  302. }
  303. TEST_F(FCMNetworkHandlerTest,
  304. ShouldNotInvokeMessageCallbackOnMessageWithInvalidVersion) {
  305. base::HistogramTester histogram_tester;
  306. MockOnMessageCallback mock_on_message_callback;
  307. gcm::IncomingMessage message = CreateValidMessage();
  308. // Set version to something that's not a valid number.
  309. message.data["version"] = "notanumber";
  310. std::unique_ptr<FCMNetworkHandler> handler =
  311. MakeHandlerReadyForMessage(mock_on_message_callback.Get());
  312. EXPECT_CALL(mock_on_message_callback, Run).Times(0);
  313. handler->OnMessage(kInvalidationsAppId, message);
  314. EXPECT_THAT(
  315. histogram_tester.GetAllSamples("FCMInvalidations.FCMMessageStatus"),
  316. testing::ElementsAre(base::Bucket(
  317. /*min=*/static_cast<int>(InvalidationParsingStatus::kVersionInvalid),
  318. /*count=*/1)));
  319. }
  320. TEST_F(FCMNetworkHandlerTest,
  321. ShouldNotInvokeMessageCallbackOnMessageWithEmptyPrivateTopic) {
  322. base::HistogramTester histogram_tester;
  323. MockOnMessageCallback mock_on_message_callback;
  324. gcm::IncomingMessage message = CreateValidMessage();
  325. // Clear private topic.
  326. message.sender_id = std::string();
  327. std::unique_ptr<FCMNetworkHandler> handler =
  328. MakeHandlerReadyForMessage(mock_on_message_callback.Get());
  329. EXPECT_CALL(mock_on_message_callback, Run).Times(0);
  330. handler->OnMessage(kInvalidationsAppId, message);
  331. EXPECT_THAT(
  332. histogram_tester.GetAllSamples("FCMInvalidations.FCMMessageStatus"),
  333. testing::ElementsAre(base::Bucket(
  334. static_cast<int>(
  335. InvalidationParsingStatus::kPrivateTopicEmpty) /* min */,
  336. 1 /* count */)));
  337. }
  338. TEST_F(FCMNetworkHandlerTest, ShouldRequestTokenImmediatellyEvenIfSaved) {
  339. // Setting up network handler.
  340. MockOnTokenCallback mock_on_token_callback;
  341. auto handler = MakeHandler();
  342. auto task_runner = CreateFakeTaskRunnerAndInjectToHandler(handler);
  343. handler->SetTokenReceiver(mock_on_token_callback.Get());
  344. // Check that after StartListening we receive the token and store it.
  345. EXPECT_CALL(*mock_instance_id(), GetToken)
  346. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  347. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  348. })));
  349. EXPECT_CALL(mock_on_token_callback, Run("token")).Times(1);
  350. handler->StartListening();
  351. handler->StopListening();
  352. task_runner->RunUntilIdle();
  353. // Setting up another network handler.
  354. auto handler2 = MakeHandler();
  355. auto task_runner2 = CreateFakeTaskRunnerAndInjectToHandler(handler2);
  356. handler2->SetTokenReceiver(mock_on_token_callback.Get());
  357. // Check that after StartListening the token will be requested, depite we have
  358. // saved token.
  359. EXPECT_CALL(*mock_instance_id(), GetToken)
  360. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  361. std::move(callback).Run("token_new", InstanceID::Result::SUCCESS);
  362. })));
  363. EXPECT_CALL(mock_on_token_callback, Run("token_new")).Times(1);
  364. handler->StartListening();
  365. task_runner->RunUntilIdle();
  366. }
  367. TEST_F(FCMNetworkHandlerTest, ShouldScheduleTokenValidationAndActOnNewToken) {
  368. // Setting up network handler.
  369. MockOnTokenCallback mock_on_token_callback;
  370. auto handler = MakeHandler();
  371. auto task_runner = CreateFakeTaskRunnerAndInjectToHandler(handler);
  372. handler->SetTokenReceiver(mock_on_token_callback.Get());
  373. // Checking that after start listening the token will be requested
  374. // and passed to the appropriate token receiver.
  375. EXPECT_CALL(*mock_instance_id(), GetToken)
  376. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  377. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  378. })));
  379. EXPECT_CALL(*mock_instance_id(), ValidateToken).Times(0);
  380. EXPECT_CALL(mock_on_token_callback, Run("token")).Times(1);
  381. handler->StartListening();
  382. testing::Mock::VerifyAndClearExpectations(mock_instance_id());
  383. // Adjust timers and check that validation will happen in time.
  384. // The old token was invalid, so token listener should be informed.
  385. const base::TimeDelta time_to_validation = base::Hours(24);
  386. task_runner->FastForwardBy(time_to_validation - base::Seconds(1));
  387. // But when it is time, validation happens.
  388. EXPECT_CALL(*mock_instance_id(), GetToken)
  389. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  390. std::move(callback).Run("token_new", InstanceID::Result::SUCCESS);
  391. })));
  392. EXPECT_CALL(mock_on_token_callback, Run("token_new")).Times(1);
  393. task_runner->FastForwardBy(base::Seconds(1));
  394. }
  395. TEST_F(FCMNetworkHandlerTest,
  396. ShouldScheduleTokenValidationAndDoNotActOnSameToken) {
  397. // Setting up network handler.
  398. MockOnTokenCallback mock_on_token_callback;
  399. std::unique_ptr<FCMNetworkHandler> handler = MakeHandler();
  400. auto task_runner = CreateFakeTaskRunnerAndInjectToHandler(handler);
  401. handler->SetTokenReceiver(mock_on_token_callback.Get());
  402. // Checking that after start listening the token will be requested
  403. // and passed to the appropriate token receiver
  404. EXPECT_CALL(*mock_instance_id(), GetToken)
  405. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  406. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  407. })));
  408. EXPECT_CALL(*mock_instance_id(), ValidateToken).Times(0);
  409. EXPECT_CALL(mock_on_token_callback, Run("token")).Times(1);
  410. handler->StartListening();
  411. testing::Mock::VerifyAndClearExpectations(mock_instance_id());
  412. // Adjust timers and check that validation will happen in time.
  413. // The old token is valid, so no token listener should be informed.
  414. const base::TimeDelta time_to_validation = base::Hours(24);
  415. task_runner->FastForwardBy(time_to_validation - base::Seconds(1));
  416. // But when it is time, validation happens.
  417. EXPECT_CALL(*mock_instance_id(), GetToken)
  418. .WillOnce(WithArg<4>(Invoke([](InstanceID::GetTokenCallback callback) {
  419. std::move(callback).Run("token", InstanceID::Result::SUCCESS);
  420. })));
  421. EXPECT_CALL(mock_on_token_callback, Run).Times(0);
  422. task_runner->FastForwardBy(base::Seconds(1));
  423. }
  424. TEST_F(FCMNetworkHandlerTestWithTTL, ShouldProvideTTLWithSyncSenderID) {
  425. EXPECT_CALL(*mock_instance_id(),
  426. GetToken(_, _, Eq(base::Seconds(kTimeToLiveInSeconds)), _, _));
  427. MakeHandler(/*sender_id=*/"8181035976")->StartListening();
  428. }
  429. TEST_F(FCMNetworkHandlerTestWithTTL, ShouldProvideTTLWithPolicySenderID) {
  430. EXPECT_CALL(*mock_instance_id(),
  431. GetToken(_, _, Eq(base::Seconds(kTimeToLiveInSeconds)), _, _));
  432. MakeHandler(/*sender_id=*/"1013309121859")->StartListening();
  433. }
  434. TEST_F(FCMNetworkHandlerTestWithTTL, ShouldNotProvideTTLWithFakeSenderID) {
  435. EXPECT_CALL(*mock_instance_id(), GetToken(_, _, Eq(base::TimeDelta()), _, _));
  436. MakeHandler(/*sender_id=*/"fake_sender_id")->StartListening();
  437. }
  438. } // namespace invalidation