lock_on_leave_controller_unittest.cc 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231
  1. // Copyright 2021 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/system/human_presence/lock_on_leave_controller.h"
  5. #include <memory>
  6. #include "ash/constants/ash_features.h"
  7. #include "ash/constants/ash_switches.h"
  8. #include "ash/test/ash_test_base.h"
  9. #include "base/command_line.h"
  10. #include "base/run_loop.h"
  11. #include "base/test/scoped_command_line.h"
  12. #include "base/test/scoped_feature_list.h"
  13. #include "chromeos/ash/components/dbus/human_presence/fake_human_presence_dbus_client.h"
  14. #include "chromeos/ash/components/dbus/human_presence/human_presence_dbus_client.h"
  15. #include "testing/gtest/include/gtest/gtest.h"
  16. namespace ash {
  17. class LockOnLeaveControllerTest : public AshTestBase {
  18. public:
  19. void SetUp() override {
  20. // We need to enable kQuickDim to construct
  21. // HumanPresenceOrientationController.
  22. scoped_feature_list_.InitAndEnableFeature(features::kQuickDim);
  23. base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kHasHps);
  24. // Initialize FakeHumanPresenceDBusClient.
  25. HumanPresenceDBusClient::InitializeFake();
  26. human_presence_client_ = FakeHumanPresenceDBusClient::Get();
  27. human_presence_client_->Reset();
  28. AshTestBase::SetUp();
  29. }
  30. protected:
  31. FakeHumanPresenceDBusClient* human_presence_client_ = nullptr;
  32. private:
  33. base::test::ScopedFeatureList scoped_feature_list_;
  34. base::test::ScopedCommandLine scoped_command_line_;
  35. };
  36. // EnableLockOnLeave should be skipped if the service is not available.
  37. TEST_F(LockOnLeaveControllerTest,
  38. EnableLockOnLeaveDoesNothingIfServiceUnavailable) {
  39. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  40. base::RunLoop().RunUntilIdle();
  41. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  42. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  43. lock_on_leave_controller->EnableLockOnLeave();
  44. base::RunLoop().RunUntilIdle();
  45. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  46. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  47. }
  48. // DisableLockOnLeave should be called when the human presence service becomes
  49. // available.
  50. TEST_F(LockOnLeaveControllerTest, CallDisableLockOnLeaveOnServiceAvailable) {
  51. human_presence_client_->set_hps_service_is_available(true);
  52. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  53. base::RunLoop().RunUntilIdle();
  54. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  55. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  56. }
  57. // EnableLockOnLeave should succeed if the service is available.
  58. TEST_F(LockOnLeaveControllerTest, EnableLockOnLeaveSucceedsIfServiceAvailable) {
  59. human_presence_client_->set_hps_service_is_available(true);
  60. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  61. base::RunLoop().RunUntilIdle();
  62. human_presence_client_->Reset();
  63. lock_on_leave_controller->EnableLockOnLeave();
  64. base::RunLoop().RunUntilIdle();
  65. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  66. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  67. }
  68. // The DBus EnableHpsSense method should only be called once for multiple calls
  69. // of EnableLockOnLeave.
  70. TEST_F(LockOnLeaveControllerTest, EnableHpsSenseOnlyCalledOnceOnTwoCalls) {
  71. human_presence_client_->set_hps_service_is_available(true);
  72. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  73. base::RunLoop().RunUntilIdle();
  74. human_presence_client_->Reset();
  75. // Only 1 dbus calls should be sent.
  76. lock_on_leave_controller->EnableLockOnLeave();
  77. lock_on_leave_controller->EnableLockOnLeave();
  78. base::RunLoop().RunUntilIdle();
  79. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  80. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  81. }
  82. TEST_F(LockOnLeaveControllerTest, DisableLockOnLeaveDoesNothingIfNotEnabled) {
  83. human_presence_client_->set_hps_service_is_available(true);
  84. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  85. base::RunLoop().RunUntilIdle();
  86. human_presence_client_->Reset();
  87. // Calls DisableLockOnLeave does nothing if LockOnLeave is not enabled.
  88. lock_on_leave_controller->DisableLockOnLeave();
  89. base::RunLoop().RunUntilIdle();
  90. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  91. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  92. }
  93. // DisableLockOnLeave should succeed if LockOnLeave is enabled.
  94. TEST_F(LockOnLeaveControllerTest, DisableLockOnLeaveSuceedsIfEnabled) {
  95. human_presence_client_->set_hps_service_is_available(true);
  96. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  97. lock_on_leave_controller->EnableLockOnLeave();
  98. human_presence_client_->Reset();
  99. // DisableLockOnLeave succeeds since LockOnLeave is enabled.
  100. lock_on_leave_controller->DisableLockOnLeave();
  101. base::RunLoop().RunUntilIdle();
  102. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  103. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  104. }
  105. // The DBus method DisableHpsSense should only be called once with two
  106. // consecutive calls to DisableLockOnLeave.
  107. TEST_F(LockOnLeaveControllerTest, DisableHpsSenseOnlyCalledOnceOnTwoCalls) {
  108. human_presence_client_->set_hps_service_is_available(true);
  109. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  110. lock_on_leave_controller->EnableLockOnLeave();
  111. base::RunLoop().RunUntilIdle();
  112. human_presence_client_->Reset();
  113. // Only 1 dbus calls should be sent.
  114. lock_on_leave_controller->DisableLockOnLeave();
  115. lock_on_leave_controller->DisableLockOnLeave();
  116. base::RunLoop().RunUntilIdle();
  117. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  118. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  119. }
  120. // No dbus call should be sent on restart if LockOnLeave is currently disabled.
  121. TEST_F(LockOnLeaveControllerTest, NoDbusCallsOnRestartIfLockOnLeaveDisabled) {
  122. human_presence_client_->set_hps_service_is_available(true);
  123. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  124. base::RunLoop().RunUntilIdle();
  125. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  126. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  127. // LockOnLeave is disabled; Restart will not send dbus calls.
  128. human_presence_client_->Shutdown();
  129. human_presence_client_->Restart();
  130. base::RunLoop().RunUntilIdle();
  131. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  132. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  133. }
  134. // The DBus method EnableHpsSense should be called on restart if LockOnLeave is
  135. // enabled currently.
  136. TEST_F(LockOnLeaveControllerTest,
  137. EnableLockOnLeaveOnRestartIfLockOnLeaveWasEnabled) {
  138. human_presence_client_->set_hps_service_is_available(true);
  139. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  140. base::RunLoop().RunUntilIdle();
  141. lock_on_leave_controller->EnableLockOnLeave();
  142. base::RunLoop().RunUntilIdle();
  143. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  144. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  145. // LockOnLeave is enabled; Restart will call EnableHpsSense.
  146. human_presence_client_->Shutdown();
  147. human_presence_client_->Restart();
  148. base::RunLoop().RunUntilIdle();
  149. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  150. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 2);
  151. }
  152. // The DBus method DisableHpsSense should be called on service available even if
  153. // we need to enable it immediately after that.
  154. TEST_F(LockOnLeaveControllerTest, AlwaysCallDisableOnServiceAvailable) {
  155. human_presence_client_->set_hps_service_is_available(true);
  156. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  157. lock_on_leave_controller->EnableLockOnLeave();
  158. // At this point, OnServiceAvailable is not called yet, so no disable/enable
  159. // functions should be called.
  160. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  161. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  162. base::RunLoop().RunUntilIdle();
  163. // Although we only need enabling, the disable function should also be called.
  164. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  165. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  166. }
  167. // Confirm that the DBus method EnableHpsSense is only called when both
  168. // EnableLockOnLeave and OnOrientationChanged(true) is set.
  169. TEST_F(LockOnLeaveControllerTest, OrientationChanging) {
  170. human_presence_client_->set_hps_service_is_available(true);
  171. auto lock_on_leave_controller = std::make_unique<LockOnLeaveController>();
  172. lock_on_leave_controller->EnableLockOnLeave();
  173. base::RunLoop().RunUntilIdle();
  174. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  175. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  176. human_presence_client_->Reset();
  177. // Orientation changed, LockOnLeave should be disabled.
  178. lock_on_leave_controller->OnOrientationChanged(false);
  179. base::RunLoop().RunUntilIdle();
  180. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 1);
  181. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  182. human_presence_client_->Reset();
  183. // Calling enable/disable will not sent any dbus call while OrientationChanged
  184. // to be false.
  185. lock_on_leave_controller->DisableLockOnLeave();
  186. base::RunLoop().RunUntilIdle();
  187. lock_on_leave_controller->OnOrientationChanged(false);
  188. base::RunLoop().RunUntilIdle();
  189. lock_on_leave_controller->EnableLockOnLeave();
  190. base::RunLoop().RunUntilIdle();
  191. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  192. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 0);
  193. // Changing orientation will trigger enabling if EnableLockOnLeave was set.
  194. lock_on_leave_controller->OnOrientationChanged(true);
  195. base::RunLoop().RunUntilIdle();
  196. EXPECT_EQ(human_presence_client_->disable_hps_sense_count(), 0);
  197. EXPECT_EQ(human_presence_client_->enable_hps_sense_count(), 1);
  198. }
  199. } // namespace ash