cros_state_sender_unittest.cc 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. // Copyright 2020 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 "ash/components/phonehub/cros_state_sender.h"
  5. #include <memory>
  6. #include "ash/components/phonehub/fake_message_sender.h"
  7. #include "ash/components/phonehub/mutable_phone_model.h"
  8. #include "ash/components/phonehub/phone_model_test_util.h"
  9. #include "ash/services/multidevice_setup/public/cpp/fake_multidevice_setup_client.h"
  10. #include "ash/services/secure_channel/public/cpp/client/fake_connection_manager.h"
  11. #include "base/timer/mock_timer.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace ash {
  14. namespace phonehub {
  15. using multidevice_setup::mojom::Feature;
  16. using multidevice_setup::mojom::FeatureState;
  17. class CrosStateSenderTest : public testing::Test {
  18. protected:
  19. CrosStateSenderTest() = default;
  20. ~CrosStateSenderTest() override = default;
  21. CrosStateSenderTest(const CrosStateSender&) = delete;
  22. CrosStateSenderTest& operator=(const CrosStateSender&) = delete;
  23. // testing::Test:
  24. void SetUp() override {
  25. auto timer = std::make_unique<base::MockOneShotTimer>();
  26. mock_timer_ = timer.get();
  27. fake_message_sender_ = std::make_unique<FakeMessageSender>();
  28. fake_connection_manager_ =
  29. std::make_unique<secure_channel::FakeConnectionManager>();
  30. fake_multidevice_setup_client_ =
  31. std::make_unique<multidevice_setup::FakeMultiDeviceSetupClient>();
  32. phone_model_ = std::make_unique<MutablePhoneModel>();
  33. cros_state_sender_ = base::WrapUnique(new CrosStateSender(
  34. fake_message_sender_.get(), fake_connection_manager_.get(),
  35. fake_multidevice_setup_client_.get(), phone_model_.get(),
  36. std::move(timer)));
  37. }
  38. base::TimeDelta GetRetryDelay() { return cros_state_sender_->retry_delay_; }
  39. std::unique_ptr<FakeMessageSender> fake_message_sender_;
  40. std::unique_ptr<secure_channel::FakeConnectionManager>
  41. fake_connection_manager_;
  42. std::unique_ptr<multidevice_setup::FakeMultiDeviceSetupClient>
  43. fake_multidevice_setup_client_;
  44. std::unique_ptr<MutablePhoneModel> phone_model_;
  45. base::MockOneShotTimer* mock_timer_;
  46. private:
  47. std::unique_ptr<CrosStateSender> cros_state_sender_;
  48. };
  49. TEST_F(CrosStateSenderTest, PerformUpdateCrosStateRetrySequence) {
  50. fake_connection_manager_->SetStatus(
  51. secure_channel::ConnectionManager::Status::kConnected);
  52. EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
  53. // The retry time follows a doubling sequence.
  54. EXPECT_EQ(base::Seconds(15u), GetRetryDelay());
  55. mock_timer_->Fire();
  56. EXPECT_TRUE(mock_timer_->IsRunning());
  57. EXPECT_EQ(2u, fake_message_sender_->GetCrosStateCallCount());
  58. EXPECT_EQ(base::Seconds(30u), GetRetryDelay());
  59. mock_timer_->Fire();
  60. EXPECT_TRUE(mock_timer_->IsRunning());
  61. EXPECT_EQ(3u, fake_message_sender_->GetCrosStateCallCount());
  62. EXPECT_EQ(base::Seconds(60u), GetRetryDelay());
  63. mock_timer_->Fire();
  64. EXPECT_TRUE(mock_timer_->IsRunning());
  65. EXPECT_EQ(4u, fake_message_sender_->GetCrosStateCallCount());
  66. // The phone model becomes populated, stops retrying.
  67. EXPECT_EQ(base::Seconds(120u), GetRetryDelay());
  68. phone_model_->SetPhoneStatusModel(CreateFakePhoneStatusModel());
  69. mock_timer_->Fire();
  70. EXPECT_FALSE(mock_timer_->IsRunning());
  71. EXPECT_EQ(4u, fake_message_sender_->GetCrosStateCallCount());
  72. EXPECT_EQ(base::Seconds(120u), GetRetryDelay());
  73. fake_connection_manager_->SetStatus(
  74. secure_channel::ConnectionManager::Status::kConnecting);
  75. EXPECT_FALSE(mock_timer_->IsRunning());
  76. // Cancellation of the retry timer occurs properly when an attempt is
  77. // reinitiated but the status is not connecting.
  78. fake_connection_manager_->SetStatus(
  79. secure_channel::ConnectionManager::Status::kConnected);
  80. EXPECT_TRUE(mock_timer_->IsRunning());
  81. fake_connection_manager_->SetStatus(
  82. secure_channel::ConnectionManager::Status::kConnecting);
  83. EXPECT_FALSE(mock_timer_->IsRunning());
  84. }
  85. TEST_F(CrosStateSenderTest, UpdatesOnConnected) {
  86. // Set notification feature to be enabled.
  87. fake_multidevice_setup_client_->SetFeatureState(
  88. Feature::kPhoneHubNotifications, FeatureState::kEnabledByUser);
  89. // Set camera roll feature to be enabled.
  90. fake_multidevice_setup_client_->SetFeatureState(Feature::kPhoneHubCameraRoll,
  91. FeatureState::kEnabledByUser);
  92. // Expect no new messages since connection has not been established.
  93. EXPECT_EQ(0u, fake_message_sender_->GetCrosStateCallCount());
  94. EXPECT_FALSE(mock_timer_->IsRunning());
  95. // Update connection state to connecting.
  96. fake_connection_manager_->SetStatus(
  97. secure_channel::ConnectionManager::Status::kConnecting);
  98. // Connecting state does not trigger a request message.
  99. EXPECT_EQ(0u, fake_message_sender_->GetCrosStateCallCount());
  100. EXPECT_FALSE(mock_timer_->IsRunning());
  101. // Simulate connected state. Expect a new message to be sent.
  102. fake_connection_manager_->SetStatus(
  103. secure_channel::ConnectionManager::Status::kConnected);
  104. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().first);
  105. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().second);
  106. EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
  107. // Phone model is populated.
  108. phone_model_->SetPhoneStatusModel(CreateFakePhoneStatusModel());
  109. mock_timer_->Fire();
  110. EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
  111. // Simulate disconnected state, this should not trigger a new request.
  112. fake_connection_manager_->SetStatus(
  113. secure_channel::ConnectionManager::Status::kDisconnected);
  114. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().first);
  115. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().second);
  116. EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
  117. EXPECT_FALSE(mock_timer_->IsRunning());
  118. }
  119. TEST_F(CrosStateSenderTest, NotificationFeatureStateChanged) {
  120. // Set connection state to be connected.
  121. fake_connection_manager_->SetStatus(
  122. secure_channel::ConnectionManager::Status::kConnected);
  123. // Phone model is populated.
  124. phone_model_->SetPhoneStatusModel(CreateFakePhoneStatusModel());
  125. EXPECT_TRUE(mock_timer_->IsRunning());
  126. // Expect new messages to be sent when connection state is connected.
  127. EXPECT_FALSE(fake_message_sender_->GetRecentCrosState().first);
  128. EXPECT_FALSE(fake_message_sender_->GetRecentCrosState().second);
  129. EXPECT_EQ(1u, fake_message_sender_->GetCrosStateCallCount());
  130. mock_timer_->Fire();
  131. // Simulate enabling notification feature state and expect cros state to be
  132. // enabled.
  133. fake_multidevice_setup_client_->SetFeatureState(
  134. Feature::kPhoneHubNotifications, FeatureState::kEnabledByUser);
  135. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().first);
  136. EXPECT_EQ(2u, fake_message_sender_->GetCrosStateCallCount());
  137. mock_timer_->Fire();
  138. // Update a different feature state and expect that it did not affect the
  139. // cros state.
  140. fake_multidevice_setup_client_->SetFeatureState(
  141. Feature::kSmartLock, FeatureState::kDisabledByUser);
  142. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().first);
  143. EXPECT_EQ(3u, fake_message_sender_->GetCrosStateCallCount());
  144. mock_timer_->Fire();
  145. // Simulate disabling notification feature state and expect cros state to be
  146. // disabled.
  147. fake_multidevice_setup_client_->SetFeatureState(
  148. Feature::kPhoneHubNotifications, FeatureState::kDisabledByUser);
  149. EXPECT_FALSE(fake_message_sender_->GetRecentCrosState().first);
  150. EXPECT_EQ(4u, fake_message_sender_->GetCrosStateCallCount());
  151. // Simulate enabling camera roll feature state and expect cros state to be
  152. // updated.
  153. fake_multidevice_setup_client_->SetFeatureState(Feature::kPhoneHubCameraRoll,
  154. FeatureState::kEnabledByUser);
  155. EXPECT_TRUE(fake_message_sender_->GetRecentCrosState().second);
  156. EXPECT_EQ(5u, fake_message_sender_->GetCrosStateCallCount());
  157. // Firing the timer does not cause the cros state to be sent again.
  158. mock_timer_->Fire();
  159. EXPECT_EQ(5u, fake_message_sender_->GetCrosStateCallCount());
  160. }
  161. } // namespace phonehub
  162. } // namespace ash