multi_device_notification_presenter_unittest.cc 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660
  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 "ash/multi_device_setup/multi_device_notification_presenter.h"
  5. #include <map>
  6. #include <memory>
  7. #include <utility>
  8. #include "ash/public/cpp/test/test_system_tray_client.h"
  9. #include "ash/services/multidevice_setup/public/cpp/fake_multidevice_setup.h"
  10. #include "ash/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
  11. #include "ash/session/test_session_controller_client.h"
  12. #include "ash/strings/grit/ash_strings.h"
  13. #include "ash/test/ash_test_base.h"
  14. #include "ash/test/ash_test_helper.h"
  15. #include "ash/test_shell_delegate.h"
  16. #include "base/bind.h"
  17. #include "base/logging.h"
  18. #include "base/memory/ptr_util.h"
  19. #include "base/strings/utf_string_conversions.h"
  20. #include "base/test/metrics/histogram_tester.h"
  21. #include "base/token.h"
  22. #include "mojo/public/cpp/bindings/pending_receiver.h"
  23. #include "ui/base/l10n/l10n_util.h"
  24. #include "ui/message_center/fake_message_center.h"
  25. #include "ui/message_center/message_center.h"
  26. namespace ash {
  27. namespace {
  28. const char kTestUserEmail[] = "test@example.com";
  29. const char kTestHostDeviceName[] = "Test Device";
  30. const char16_t kTestHostDeviceName16[] = u"Test Device";
  31. // This is the expected return value from GetChromeOSDeviceName() in tests.
  32. const char16_t kTestDeviceType[] = u"Chrome device";
  33. class TestMessageCenter : public message_center::FakeMessageCenter {
  34. public:
  35. TestMessageCenter() = default;
  36. TestMessageCenter(const TestMessageCenter&) = delete;
  37. TestMessageCenter& operator=(const TestMessageCenter&) = delete;
  38. ~TestMessageCenter() override = default;
  39. // message_center::FakeMessageCenter:
  40. void AddNotification(
  41. std::unique_ptr<message_center::Notification> notification) override {
  42. EXPECT_FALSE(notification_);
  43. notification_ = std::move(notification);
  44. }
  45. void UpdateNotification(
  46. const std::string& id,
  47. std::unique_ptr<message_center::Notification> new_notification) override {
  48. EXPECT_TRUE(notification_);
  49. EXPECT_EQ(notification_->id(), id);
  50. EXPECT_EQ(new_notification->id(), id);
  51. notification_ = std::move(new_notification);
  52. }
  53. void RemoveNotification(const std::string& id, bool by_user) override {
  54. EXPECT_TRUE(notification_);
  55. EXPECT_EQ(notification_->id(), id);
  56. notification_.reset();
  57. for (auto& observer : observer_list())
  58. observer.OnNotificationRemoved(id, by_user);
  59. }
  60. message_center::Notification* FindVisibleNotificationById(
  61. const std::string& id) override {
  62. if (notification_) {
  63. EXPECT_EQ(notification_->id(), id);
  64. return notification_.get();
  65. }
  66. return nullptr;
  67. }
  68. void ClickOnNotification(const std::string& id) override {
  69. EXPECT_TRUE(notification_);
  70. EXPECT_EQ(id, notification_->id());
  71. for (auto& observer : observer_list())
  72. observer.OnNotificationClicked(id, absl::nullopt, absl::nullopt);
  73. }
  74. void ClickOnNotificationButton(const std::string& id,
  75. int button_index) override {
  76. EXPECT_TRUE(notification_);
  77. EXPECT_EQ(id, notification_->id());
  78. for (auto& observer : observer_list())
  79. observer.OnNotificationClicked(id, button_index, absl::nullopt);
  80. }
  81. private:
  82. std::unique_ptr<message_center::Notification> notification_;
  83. };
  84. } // namespace
  85. class MultiDeviceNotificationPresenterTest : public NoSessionAshTestBase {
  86. public:
  87. MultiDeviceNotificationPresenterTest() = default;
  88. MultiDeviceNotificationPresenterTest(
  89. const MultiDeviceNotificationPresenterTest&) = delete;
  90. MultiDeviceNotificationPresenterTest& operator=(
  91. const MultiDeviceNotificationPresenterTest&) = delete;
  92. void SetUp() override {
  93. fake_multidevice_setup_ =
  94. std::make_unique<multidevice_setup::FakeMultiDeviceSetup>();
  95. auto delegate = std::make_unique<TestShellDelegate>();
  96. delegate->SetMultiDeviceSetupBinder(base::BindRepeating(
  97. &multidevice_setup::MultiDeviceSetupBase::BindReceiver,
  98. base::Unretained(fake_multidevice_setup_.get())));
  99. NoSessionAshTestBase::SetUp(std::move(delegate));
  100. test_system_tray_client_ = GetSystemTrayClient();
  101. notification_presenter_ =
  102. std::make_unique<MultiDeviceNotificationPresenter>(
  103. &test_message_center_);
  104. }
  105. void TearDown() override {
  106. notification_presenter_.reset();
  107. NoSessionAshTestBase::TearDown();
  108. }
  109. void InvokePendingMojoCalls() { notification_presenter_->FlushForTesting(); }
  110. void SignIntoAccount() {
  111. TestSessionControllerClient* test_session_client =
  112. GetSessionControllerClient();
  113. test_session_client->AddUserSession(
  114. kTestUserEmail, user_manager::USER_TYPE_REGULAR,
  115. true /* provide_pref_service */, false /* is_new_profile */);
  116. test_session_client->SetSessionState(session_manager::SessionState::ACTIVE);
  117. test_session_client->SwitchActiveUser(
  118. AccountId::FromUserEmail(kTestUserEmail));
  119. InvokePendingMojoCalls();
  120. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  121. }
  122. void ShowNewUserNotification() {
  123. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  124. fake_multidevice_setup_->delegate()->OnPotentialHostExistsForNewUser();
  125. InvokePendingMojoCalls();
  126. }
  127. void TriggerNoLongerNewUserEvent() {
  128. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  129. fake_multidevice_setup_->delegate()->OnNoLongerNewUser();
  130. InvokePendingMojoCalls();
  131. }
  132. void ShowExistingUserHostSwitchedNotification() {
  133. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  134. fake_multidevice_setup_->delegate()->OnConnectedHostSwitchedForExistingUser(
  135. kTestHostDeviceName);
  136. InvokePendingMojoCalls();
  137. }
  138. void ShowExistingUserNewChromebookNotification() {
  139. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  140. fake_multidevice_setup_->delegate()->OnNewChromebookAddedForExistingUser(
  141. kTestHostDeviceName);
  142. InvokePendingMojoCalls();
  143. }
  144. void ShowWifiSyncNotification() {
  145. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  146. fake_multidevice_setup_->delegate()->OnBecameEligibleForWifiSync();
  147. InvokePendingMojoCalls();
  148. }
  149. void ClickNotification() {
  150. test_message_center_.ClickOnNotification(
  151. MultiDeviceNotificationPresenter::kSetupNotificationId);
  152. }
  153. void ClickWifiSyncNotification() {
  154. test_message_center_.ClickOnNotification(
  155. MultiDeviceNotificationPresenter::kWifiSyncNotificationId);
  156. }
  157. void ClickWifiSyncNotificationButton(int button_index) {
  158. test_message_center_.ClickOnNotificationButton(
  159. MultiDeviceNotificationPresenter::kWifiSyncNotificationId,
  160. button_index);
  161. }
  162. void DismissWifiSyncNotification(bool by_user) {
  163. test_message_center_.RemoveNotification(
  164. MultiDeviceNotificationPresenter::kWifiSyncNotificationId, by_user);
  165. }
  166. void DismissNotification(bool by_user) {
  167. test_message_center_.RemoveNotification(
  168. MultiDeviceNotificationPresenter::kSetupNotificationId, by_user);
  169. }
  170. void VerifyNewUserPotentialHostExistsNotificationIsVisible() {
  171. VerifySetupNotificationIsVisible(
  172. MultiDeviceNotificationPresenter::Status::kNewUserNotificationVisible);
  173. }
  174. void VerifyExistingUserHostSwitchedNotificationIsVisible() {
  175. VerifySetupNotificationIsVisible(
  176. MultiDeviceNotificationPresenter::Status::
  177. kExistingUserHostSwitchedNotificationVisible);
  178. }
  179. void VerifyExistingUserNewChromebookAddedNotificationIsVisible() {
  180. VerifySetupNotificationIsVisible(
  181. MultiDeviceNotificationPresenter::Status::
  182. kExistingUserNewChromebookNotificationVisible);
  183. }
  184. void VerifyWifiSyncNotificationIsVisible() {
  185. const message_center::Notification* kVisibleNotification =
  186. test_message_center_.FindVisibleNotificationById(
  187. MultiDeviceNotificationPresenter::kWifiSyncNotificationId);
  188. std::u16string title = l10n_util::GetStringUTF16(
  189. IDS_ASH_MULTI_DEVICE_WIFI_SYNC_AVAILABLE_TITLE);
  190. std::u16string message = l10n_util::GetStringFUTF16(
  191. IDS_ASH_MULTI_DEVICE_WIFI_SYNC_AVAILABLE_MESSAGE, kTestDeviceType);
  192. EXPECT_EQ(title, kVisibleNotification->title());
  193. EXPECT_EQ(message, kVisibleNotification->message());
  194. }
  195. void VerifyNoNotificationIsVisible() {
  196. EXPECT_FALSE(test_message_center_.FindVisibleNotificationById(
  197. MultiDeviceNotificationPresenter::kSetupNotificationId));
  198. }
  199. void VerifyNoWifiSyncNotificationIsVisible() {
  200. EXPECT_FALSE(test_message_center_.FindVisibleNotificationById(
  201. MultiDeviceNotificationPresenter::kWifiSyncNotificationId));
  202. }
  203. void AssertPotentialHostBucketCount(std::string histogram, int count) {
  204. if (histogram_tester_.GetAllSamples(histogram).empty()) {
  205. EXPECT_EQ(count, 0);
  206. return;
  207. }
  208. histogram_tester_.ExpectBucketCount(
  209. histogram,
  210. MultiDeviceNotificationPresenter::NotificationType::
  211. kNewUserPotentialHostExists,
  212. count);
  213. }
  214. void AssertHostSwitchedBucketCount(std::string histogram, int count) {
  215. if (histogram_tester_.GetAllSamples(histogram).empty()) {
  216. EXPECT_EQ(count, 0);
  217. return;
  218. }
  219. histogram_tester_.ExpectBucketCount(
  220. histogram,
  221. MultiDeviceNotificationPresenter::NotificationType::
  222. kExistingUserHostSwitched,
  223. count);
  224. }
  225. void AssertNewChromebookBucketCount(std::string histogram, int count) {
  226. if (histogram_tester_.GetAllSamples(histogram).empty()) {
  227. EXPECT_EQ(count, 0);
  228. return;
  229. }
  230. histogram_tester_.ExpectBucketCount(
  231. histogram,
  232. MultiDeviceNotificationPresenter::NotificationType::
  233. kExistingUserNewChromebookAdded,
  234. count);
  235. }
  236. void AssertWifiSyncBucketCount(std::string histogram, int count) {
  237. if (histogram_tester_.GetAllSamples(histogram).empty()) {
  238. EXPECT_EQ(count, 0);
  239. return;
  240. }
  241. histogram_tester_.ExpectBucketCount(
  242. histogram,
  243. MultiDeviceNotificationPresenter::NotificationType::
  244. kWifiSyncAnnouncement,
  245. count);
  246. }
  247. base::HistogramTester histogram_tester_;
  248. TestSystemTrayClient* test_system_tray_client_;
  249. TestMessageCenter test_message_center_;
  250. std::unique_ptr<multidevice_setup::FakeMultiDeviceSetup>
  251. fake_multidevice_setup_;
  252. std::unique_ptr<MultiDeviceNotificationPresenter> notification_presenter_;
  253. private:
  254. void VerifySetupNotificationIsVisible(
  255. MultiDeviceNotificationPresenter::Status notification_status) {
  256. const message_center::Notification* kVisibleNotification =
  257. test_message_center_.FindVisibleNotificationById(
  258. MultiDeviceNotificationPresenter::kSetupNotificationId);
  259. std::u16string title;
  260. std::u16string message;
  261. switch (notification_status) {
  262. case MultiDeviceNotificationPresenter::Status::
  263. kNewUserNotificationVisible:
  264. title = l10n_util::GetStringUTF16(
  265. IDS_ASH_MULTI_DEVICE_SETUP_NEW_USER_POTENTIAL_HOST_EXISTS_TITLE);
  266. message = l10n_util::GetStringFUTF16(
  267. IDS_ASH_MULTI_DEVICE_SETUP_NEW_USER_POTENTIAL_HOST_EXISTS_MESSAGE,
  268. kTestDeviceType);
  269. break;
  270. case MultiDeviceNotificationPresenter::Status::
  271. kExistingUserHostSwitchedNotificationVisible:
  272. title = l10n_util::GetStringFUTF16(
  273. IDS_ASH_MULTI_DEVICE_SETUP_EXISTING_USER_HOST_SWITCHED_TITLE,
  274. kTestHostDeviceName16);
  275. message = l10n_util::GetStringFUTF16(
  276. IDS_ASH_MULTI_DEVICE_SETUP_EXISTING_USER_HOST_SWITCHED_MESSAGE,
  277. kTestDeviceType);
  278. break;
  279. case MultiDeviceNotificationPresenter::Status::
  280. kExistingUserNewChromebookNotificationVisible:
  281. title = l10n_util::GetStringFUTF16(
  282. IDS_ASH_MULTI_DEVICE_SETUP_EXISTING_USER_NEW_CHROME_DEVICE_ADDED_TITLE,
  283. kTestHostDeviceName16);
  284. message = l10n_util::GetStringFUTF16(
  285. IDS_ASH_MULTI_DEVICE_SETUP_EXISTING_USER_NEW_CHROME_DEVICE_ADDED_MESSAGE,
  286. kTestDeviceType);
  287. break;
  288. case MultiDeviceNotificationPresenter::Status::kNoNotificationVisible:
  289. NOTREACHED();
  290. }
  291. EXPECT_EQ(title, kVisibleNotification->title());
  292. EXPECT_EQ(message, kVisibleNotification->message());
  293. }
  294. };
  295. TEST_F(MultiDeviceNotificationPresenterTest, NotSignedIntoAccount) {
  296. static const session_manager::SessionState kNonActiveStates[] = {
  297. session_manager::SessionState::UNKNOWN,
  298. session_manager::SessionState::OOBE,
  299. session_manager::SessionState::LOGIN_PRIMARY,
  300. session_manager::SessionState::LOGGED_IN_NOT_ACTIVE,
  301. session_manager::SessionState::LOCKED,
  302. session_manager::SessionState::LOGIN_SECONDARY};
  303. // For each of the states which is not ACTIVE, set the session state. None of
  304. // these should trigger a SetAccountStatusChangeDelegate() call.
  305. for (const auto state : kNonActiveStates) {
  306. GetSessionControllerClient()->SetSessionState(state);
  307. InvokePendingMojoCalls();
  308. EXPECT_FALSE(fake_multidevice_setup_->delegate().is_bound());
  309. }
  310. SignIntoAccount();
  311. EXPECT_TRUE(fake_multidevice_setup_->delegate().is_bound());
  312. }
  313. TEST_F(MultiDeviceNotificationPresenterTest,
  314. TestHostNewUserPotentialHostExistsNotification_RemoveProgrammatically) {
  315. SignIntoAccount();
  316. ShowNewUserNotification();
  317. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  318. notification_presenter_->RemoveMultiDeviceSetupNotification();
  319. VerifyNoNotificationIsVisible();
  320. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  321. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  322. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationShown", 1);
  323. }
  324. TEST_F(MultiDeviceNotificationPresenterTest,
  325. TestHostNewUserPotentialHostExistsNotification_TapNotification) {
  326. SignIntoAccount();
  327. ShowNewUserNotification();
  328. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  329. ClickNotification();
  330. VerifyNoNotificationIsVisible();
  331. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 1);
  332. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationClicked", 1);
  333. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationShown", 1);
  334. }
  335. TEST_F(MultiDeviceNotificationPresenterTest,
  336. TestHostNewUserPotentialHostExistsNotification_DismissedNotification) {
  337. SignIntoAccount();
  338. ShowNewUserNotification();
  339. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  340. DismissNotification(true /* by_user */);
  341. VerifyNoNotificationIsVisible();
  342. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  343. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  344. ShowNewUserNotification();
  345. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  346. DismissNotification(false /* by_user */);
  347. VerifyNoNotificationIsVisible();
  348. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  349. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  350. }
  351. TEST_F(MultiDeviceNotificationPresenterTest, TestNoLongerNewUserEvent) {
  352. SignIntoAccount();
  353. ShowNewUserNotification();
  354. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  355. TriggerNoLongerNewUserEvent();
  356. VerifyNoNotificationIsVisible();
  357. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  358. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  359. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationShown", 1);
  360. }
  361. TEST_F(MultiDeviceNotificationPresenterTest,
  362. TestHostExistingUserHostSwitchedNotification_RemoveProgrammatically) {
  363. SignIntoAccount();
  364. ShowExistingUserHostSwitchedNotification();
  365. VerifyExistingUserHostSwitchedNotificationIsVisible();
  366. notification_presenter_->RemoveMultiDeviceSetupNotification();
  367. VerifyNoNotificationIsVisible();
  368. EXPECT_EQ(test_system_tray_client_->show_connected_devices_settings_count(),
  369. 0);
  370. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  371. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationShown", 1);
  372. }
  373. TEST_F(MultiDeviceNotificationPresenterTest,
  374. TestHostExistingUserHostSwitchedNotification_TapNotification) {
  375. SignIntoAccount();
  376. ShowExistingUserHostSwitchedNotification();
  377. VerifyExistingUserHostSwitchedNotificationIsVisible();
  378. ClickNotification();
  379. VerifyNoNotificationIsVisible();
  380. EXPECT_EQ(test_system_tray_client_->show_connected_devices_settings_count(),
  381. 1);
  382. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationClicked", 1);
  383. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationShown", 1);
  384. }
  385. TEST_F(MultiDeviceNotificationPresenterTest,
  386. TestHostExistingUserHostSwitchedNotification_DismissedNotification) {
  387. SignIntoAccount();
  388. ShowExistingUserHostSwitchedNotification();
  389. VerifyExistingUserHostSwitchedNotificationIsVisible();
  390. DismissNotification(true /* by_user */);
  391. VerifyNoNotificationIsVisible();
  392. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  393. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  394. ShowExistingUserHostSwitchedNotification();
  395. VerifyExistingUserHostSwitchedNotificationIsVisible();
  396. DismissNotification(false /* by_user */);
  397. VerifyNoNotificationIsVisible();
  398. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  399. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  400. }
  401. TEST_F(
  402. MultiDeviceNotificationPresenterTest,
  403. TestHostExistingUserNewChromebookAddedNotification_RemoveProgrammatically) {
  404. SignIntoAccount();
  405. ShowExistingUserNewChromebookNotification();
  406. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  407. notification_presenter_->RemoveMultiDeviceSetupNotification();
  408. VerifyNoNotificationIsVisible();
  409. EXPECT_EQ(test_system_tray_client_->show_connected_devices_settings_count(),
  410. 0);
  411. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  412. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationShown", 1);
  413. }
  414. TEST_F(MultiDeviceNotificationPresenterTest,
  415. TestWifiSyncNotification_TapNotification) {
  416. SignIntoAccount();
  417. ShowWifiSyncNotification();
  418. VerifyWifiSyncNotificationIsVisible();
  419. ClickWifiSyncNotification();
  420. VerifyNoWifiSyncNotificationIsVisible();
  421. EXPECT_EQ(test_system_tray_client_->show_wifi_sync_settings_count(), 1);
  422. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationClicked", 1);
  423. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationDismissed", 0);
  424. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationShown", 1);
  425. }
  426. TEST_F(MultiDeviceNotificationPresenterTest,
  427. TestWifiSyncNotification_TapTurnOnButton) {
  428. SignIntoAccount();
  429. ShowWifiSyncNotification();
  430. VerifyWifiSyncNotificationIsVisible();
  431. ClickWifiSyncNotificationButton(0);
  432. VerifyNoWifiSyncNotificationIsVisible();
  433. EXPECT_EQ(test_system_tray_client_->show_wifi_sync_settings_count(), 1);
  434. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationClicked", 1);
  435. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationDismissed", 0);
  436. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationShown", 1);
  437. }
  438. TEST_F(MultiDeviceNotificationPresenterTest,
  439. TestWifiSyncNotification_TapCancelButton) {
  440. SignIntoAccount();
  441. ShowWifiSyncNotification();
  442. VerifyWifiSyncNotificationIsVisible();
  443. ClickWifiSyncNotificationButton(1);
  444. VerifyNoWifiSyncNotificationIsVisible();
  445. EXPECT_EQ(test_system_tray_client_->show_wifi_sync_settings_count(), 0);
  446. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  447. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  448. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationShown", 1);
  449. }
  450. TEST_F(MultiDeviceNotificationPresenterTest,
  451. TestWifiSyncNotification_DismissedNotification) {
  452. SignIntoAccount();
  453. ShowWifiSyncNotification();
  454. VerifyWifiSyncNotificationIsVisible();
  455. DismissWifiSyncNotification(/*by_user=*/true);
  456. VerifyNoWifiSyncNotificationIsVisible();
  457. EXPECT_EQ(test_system_tray_client_->show_wifi_sync_settings_count(), 0);
  458. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationClicked", 0);
  459. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  460. AssertWifiSyncBucketCount("MultiDeviceSetup_NotificationShown", 1);
  461. }
  462. TEST_F(MultiDeviceNotificationPresenterTest,
  463. TestHostExistingUserNewChromebookAddedNotification_TapNotification) {
  464. SignIntoAccount();
  465. ShowExistingUserNewChromebookNotification();
  466. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  467. ClickNotification();
  468. VerifyNoNotificationIsVisible();
  469. EXPECT_EQ(test_system_tray_client_->show_connected_devices_settings_count(),
  470. 1);
  471. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationClicked", 1);
  472. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationShown", 1);
  473. }
  474. TEST_F(
  475. MultiDeviceNotificationPresenterTest,
  476. TestHostExistingUserNewChromebookAddedNotification_DismissedNotification) {
  477. SignIntoAccount();
  478. ShowExistingUserNewChromebookNotification();
  479. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  480. DismissNotification(true /* by_user */);
  481. VerifyNoNotificationIsVisible();
  482. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  483. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  484. ShowExistingUserNewChromebookNotification();
  485. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  486. DismissNotification(false /* by_user */);
  487. VerifyNoNotificationIsVisible();
  488. EXPECT_EQ(test_system_tray_client_->show_multi_device_setup_count(), 0);
  489. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationDismissed", 1);
  490. }
  491. TEST_F(MultiDeviceNotificationPresenterTest, NotificationsReplaceOneAnother) {
  492. SignIntoAccount();
  493. ShowNewUserNotification();
  494. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  495. ShowExistingUserHostSwitchedNotification();
  496. VerifyExistingUserHostSwitchedNotificationIsVisible();
  497. ShowExistingUserNewChromebookNotification();
  498. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  499. ClickNotification();
  500. VerifyNoNotificationIsVisible();
  501. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationShown", 1);
  502. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationShown", 1);
  503. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationShown", 1);
  504. }
  505. TEST_F(MultiDeviceNotificationPresenterTest, NotificationsReplaceThemselves) {
  506. SignIntoAccount();
  507. ShowNewUserNotification();
  508. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  509. ShowNewUserNotification();
  510. VerifyNewUserPotentialHostExistsNotificationIsVisible();
  511. notification_presenter_->RemoveMultiDeviceSetupNotification();
  512. ShowExistingUserHostSwitchedNotification();
  513. VerifyExistingUserHostSwitchedNotificationIsVisible();
  514. ShowExistingUserHostSwitchedNotification();
  515. VerifyExistingUserHostSwitchedNotificationIsVisible();
  516. notification_presenter_->RemoveMultiDeviceSetupNotification();
  517. ShowExistingUserNewChromebookNotification();
  518. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  519. ShowExistingUserNewChromebookNotification();
  520. VerifyExistingUserNewChromebookAddedNotificationIsVisible();
  521. notification_presenter_->RemoveMultiDeviceSetupNotification();
  522. AssertPotentialHostBucketCount("MultiDeviceSetup_NotificationShown", 2);
  523. AssertHostSwitchedBucketCount("MultiDeviceSetup_NotificationShown", 2);
  524. AssertNewChromebookBucketCount("MultiDeviceSetup_NotificationShown", 2);
  525. }
  526. } // namespace ash