ui/message_center/message_center_tray_unittest.cc

   1 // Copyright (c) 2013 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
   5 #include "ui/message_center/message_center_tray.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "ui/base/models/menu_model.h"
  10 #include "ui/message_center/message_center.h"
  11 #include "ui/message_center/notification.h"
  12 #include "ui/message_center/notification_types.h"
  13
  14 using base::ASCIIToUTF16;
  15
  16 namespace message_center {
  17 namespace {
  18
  19 class MockDelegate : public MessageCenterTrayDelegate {
  20  public:
  21   MockDelegate()
  22       : show_popups_success_(true),
  23         show_message_center_success_(true),
  24         enable_context_menu_(true) {}
  25   ~MockDelegate() override {}
  26   void OnMessageCenterTrayChanged() override {}
  27   bool ShowPopups() override { return show_message_center_success_; }
  28   void HidePopups() override {}
  29   bool ShowMessageCenter() override { return show_popups_success_; }
  30   void HideMessageCenter() override {}
  31   bool ShowNotifierSettings() override { return true; }
  32   bool IsContextMenuEnabled() const override { return enable_context_menu_; }
  33
  34   MessageCenterTray* GetMessageCenterTray() override { return NULL; }
  35
  36   bool show_popups_success_;
  37   bool show_message_center_success_;
  38   bool enable_context_menu_;
  39
  40  private:
  41   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
  42 };
  43
  44 }  // namespace
  45
  46 class MessageCenterTrayTest : public testing::Test {
  47  public:
  48   MessageCenterTrayTest() {}
  49   ~MessageCenterTrayTest() override {}
  50
  51   void SetUp() override {
  52     MessageCenter::Initialize();
  53     delegate_.reset(new MockDelegate);
  54     message_center_ = MessageCenter::Get();
  55     message_center_tray_.reset(
  56         new MessageCenterTray(delegate_.get(), message_center_));
  57   }
  58
  59   void TearDown() override {
  60     message_center_tray_.reset();
  61     delegate_.reset();
  62     message_center_ = NULL;
  63     MessageCenter::Shutdown();
  64   }
  65
  66  protected:
  67   NotifierId DummyNotifierId() {
  68     return NotifierId();
  69   }
  70
  71   void AddNotification(const std::string& id) {
  72     AddNotification(id, DummyNotifierId());
  73   }
  74
  75   void AddNotification(const std::string& id, NotifierId notifier_id) {
  76     scoped_ptr<Notification> notification(new Notification(
  77         message_center::NOTIFICATION_TYPE_SIMPLE, id,
  78         ASCIIToUTF16("Test Web Notification"),
  79         ASCIIToUTF16("Notification message body."), gfx::Image(),
  80         ASCIIToUTF16("www.test.org"), GURL(), notifier_id,
  81         message_center::RichNotificationData(), NULL /* delegate */));
  82     message_center_->AddNotification(notification.Pass());
  83   }
  84   scoped_ptr<MockDelegate> delegate_;
  85   scoped_ptr<MessageCenterTray> message_center_tray_;
  86   MessageCenter* message_center_;
  87
  88  private:
  89   DISALLOW_COPY_AND_ASSIGN(MessageCenterTrayTest);
  90 };
  91
  92 TEST_F(MessageCenterTrayTest, BasicMessageCenter) {
  93   ASSERT_FALSE(message_center_tray_->popups_visible());
  94   ASSERT_FALSE(message_center_tray_->message_center_visible());
  95
  96   bool shown = message_center_tray_->ShowMessageCenterBubble();
  97   EXPECT_TRUE(shown);
  98
  99   ASSERT_FALSE(message_center_tray_->popups_visible());
 100   ASSERT_TRUE(message_center_tray_->message_center_visible());
 101
 102   message_center_tray_->HideMessageCenterBubble();
 103
 104   ASSERT_FALSE(message_center_tray_->popups_visible());
 105   ASSERT_FALSE(message_center_tray_->message_center_visible());
 106
 107   message_center_tray_->ShowMessageCenterBubble();
 108
 109   ASSERT_FALSE(message_center_tray_->popups_visible());
 110   ASSERT_TRUE(message_center_tray_->message_center_visible());
 111
 112   message_center_tray_->HideMessageCenterBubble();
 113
 114   ASSERT_FALSE(message_center_tray_->popups_visible());
 115   ASSERT_FALSE(message_center_tray_->message_center_visible());
 116 }
 117
 118 TEST_F(MessageCenterTrayTest, BasicPopup) {
 119   ASSERT_FALSE(message_center_tray_->popups_visible());
 120   ASSERT_FALSE(message_center_tray_->message_center_visible());
 121
 122   message_center_tray_->ShowPopupBubble();
 123
 124   ASSERT_FALSE(message_center_tray_->popups_visible());
 125   ASSERT_FALSE(message_center_tray_->message_center_visible());
 126
 127   AddNotification("BasicPopup");
 128
 129   ASSERT_TRUE(message_center_tray_->popups_visible());
 130   ASSERT_FALSE(message_center_tray_->message_center_visible());
 131
 132   message_center_tray_->HidePopupBubble();
 133
 134   ASSERT_FALSE(message_center_tray_->popups_visible());
 135   ASSERT_FALSE(message_center_tray_->message_center_visible());
 136 }
 137
 138 TEST_F(MessageCenterTrayTest, MessageCenterClosesPopups) {
 139   ASSERT_FALSE(message_center_tray_->popups_visible());
 140   ASSERT_FALSE(message_center_tray_->message_center_visible());
 141
 142   AddNotification("MessageCenterClosesPopups");
 143
 144   ASSERT_TRUE(message_center_tray_->popups_visible());
 145   ASSERT_FALSE(message_center_tray_->message_center_visible());
 146
 147   bool shown = message_center_tray_->ShowMessageCenterBubble();
 148   EXPECT_TRUE(shown);
 149
 150   ASSERT_FALSE(message_center_tray_->popups_visible());
 151   ASSERT_TRUE(message_center_tray_->message_center_visible());
 152
 153   // The notification is queued if it's added when message center is visible.
 154   AddNotification("MessageCenterClosesPopups2");
 155
 156   message_center_tray_->ShowPopupBubble();
 157
 158   ASSERT_FALSE(message_center_tray_->popups_visible());
 159   ASSERT_TRUE(message_center_tray_->message_center_visible());
 160
 161   message_center_tray_->HideMessageCenterBubble();
 162
 163   // The queued notification appears as a popup.
 164   ASSERT_TRUE(message_center_tray_->popups_visible());
 165   ASSERT_FALSE(message_center_tray_->message_center_visible());
 166
 167   message_center_tray_->ShowMessageCenterBubble();
 168   message_center_tray_->HideMessageCenterBubble();
 169   ASSERT_FALSE(message_center_tray_->popups_visible());
 170   ASSERT_FALSE(message_center_tray_->message_center_visible());
 171 }
 172
 173 TEST_F(MessageCenterTrayTest, MessageCenterReopenPopupsForSystemPriority) {
 174   ASSERT_FALSE(message_center_tray_->popups_visible());
 175   ASSERT_FALSE(message_center_tray_->message_center_visible());
 176
 177   scoped_ptr<Notification> notification(new Notification(
 178       message_center::NOTIFICATION_TYPE_SIMPLE,
 179       "MessageCenterReopnPopupsForSystemPriority",
 180       ASCIIToUTF16("Test Web Notification"),
 181       ASCIIToUTF16("Notification message body."), gfx::Image(),
 182       ASCIIToUTF16("www.test.org"), GURL(), DummyNotifierId(),
 183       message_center::RichNotificationData(), NULL /* delegate */));
 184   notification->SetSystemPriority();
 185   message_center_->AddNotification(notification.Pass());
 186
 187   ASSERT_TRUE(message_center_tray_->popups_visible());
 188   ASSERT_FALSE(message_center_tray_->message_center_visible());
 189
 190   bool shown = message_center_tray_->ShowMessageCenterBubble();
 191   EXPECT_TRUE(shown);
 192
 193   ASSERT_FALSE(message_center_tray_->popups_visible());
 194   ASSERT_TRUE(message_center_tray_->message_center_visible());
 195
 196   message_center_tray_->HideMessageCenterBubble();
 197
 198   ASSERT_TRUE(message_center_tray_->popups_visible());
 199   ASSERT_FALSE(message_center_tray_->message_center_visible());
 200 }
 201
 202 TEST_F(MessageCenterTrayTest, ShowBubbleFails) {
 203   // Now the delegate will signal that it was unable to show a bubble.
 204   delegate_->show_popups_success_ = false;
 205   delegate_->show_message_center_success_ = false;
 206
 207   ASSERT_FALSE(message_center_tray_->popups_visible());
 208   ASSERT_FALSE(message_center_tray_->message_center_visible());
 209
 210   AddNotification("ShowBubbleFails");
 211
 212   message_center_tray_->ShowPopupBubble();
 213
 214   ASSERT_FALSE(message_center_tray_->popups_visible());
 215   ASSERT_FALSE(message_center_tray_->message_center_visible());
 216
 217   bool shown = message_center_tray_->ShowMessageCenterBubble();
 218   EXPECT_FALSE(shown);
 219
 220   ASSERT_FALSE(message_center_tray_->popups_visible());
 221   ASSERT_FALSE(message_center_tray_->message_center_visible());
 222
 223   message_center_tray_->HideMessageCenterBubble();
 224
 225   ASSERT_FALSE(message_center_tray_->popups_visible());
 226   ASSERT_FALSE(message_center_tray_->message_center_visible());
 227
 228   message_center_tray_->ShowMessageCenterBubble();
 229
 230   ASSERT_FALSE(message_center_tray_->popups_visible());
 231   ASSERT_FALSE(message_center_tray_->message_center_visible());
 232
 233   message_center_tray_->HidePopupBubble();
 234
 235   ASSERT_FALSE(message_center_tray_->popups_visible());
 236   ASSERT_FALSE(message_center_tray_->message_center_visible());
 237 }
 238
 239 #ifdef OS_CHROMEOS
 240 TEST_F(MessageCenterTrayTest, ContextMenuTestWithMessageCenter) {
 241   const std::string id1 = "id1";
 242   const std::string id2 = "id2";
 243   const std::string id3 = "id3";
 244   AddNotification(id1);
 245
 246   base::string16 display_source = ASCIIToUTF16("www.test.org");
 247   NotifierId notifier_id = DummyNotifierId();
 248
 249   NotifierId notifier_id2(NotifierId::APPLICATION, "sample-app");
 250   scoped_ptr<Notification> notification(new Notification(
 251       message_center::NOTIFICATION_TYPE_SIMPLE, id2,
 252       ASCIIToUTF16("Test Web Notification"),
 253       ASCIIToUTF16("Notification message body."), gfx::Image(),
 254       base::string16() /* empty display source */, GURL(), notifier_id2,
 255       message_center::RichNotificationData(), NULL /* delegate */));
 256   message_center_->AddNotification(notification.Pass());
 257
 258   AddNotification(id3);
 259
 260   scoped_ptr<ui::MenuModel> model(
 261       message_center_tray_->CreateNotificationMenuModel(
 262           notifier_id, display_source));
 263   EXPECT_EQ(2, model->GetItemCount());
 264   const int second_command = model->GetCommandIdAt(1);
 265
 266   // The second item is to open the settings.
 267   EXPECT_TRUE(model->IsEnabledAt(0));
 268   EXPECT_TRUE(model->IsEnabledAt(1));
 269   model->ActivatedAt(1);
 270   EXPECT_TRUE(message_center_tray_->message_center_visible());
 271
 272   message_center_tray_->HideMessageCenterBubble();
 273
 274   // The first item is to disable notifications from the notifier id. It also
 275   // removes all notifications from the same notifier, i.e. id1 and id3.
 276   model->ActivatedAt(0);
 277   NotificationList::Notifications notifications =
 278       message_center_->GetVisibleNotifications();
 279   EXPECT_EQ(1u, notifications.size());
 280   EXPECT_EQ(id2, (*notifications.begin())->id());
 281
 282   // Disables the context menu.
 283   delegate_->enable_context_menu_ = false;
 284
 285   // id2 doesn't have the display source, so it don't have the menu item for
 286   // disabling notifications.
 287   model = message_center_tray_->CreateNotificationMenuModel(
 288       notifier_id2, base::string16());
 289   EXPECT_EQ(1, model->GetItemCount());
 290   EXPECT_EQ(second_command, model->GetCommandIdAt(0));
 291
 292   // The command itself is disabled because delegate disables context menu.
 293   EXPECT_FALSE(model->IsEnabledAt(0));
 294 }
 295
 296 #else
 297 TEST_F(MessageCenterTrayTest, ContextMenuTestPopupsOnly) {
 298   const std::string id1 = "id1";
 299   const std::string id2 = "id2";
 300   const std::string id3 = "id3";
 301
 302   base::string16 display_source = ASCIIToUTF16("https://www.test.org");
 303   NotifierId notifier_id(GURL("https://www.test.org"));
 304
 305   AddNotification(id1, notifier_id);
 306
 307   NotifierId notifier_id2(NotifierId::APPLICATION, "sample-app");
 308   scoped_ptr<Notification> notification(new Notification(
 309       message_center::NOTIFICATION_TYPE_SIMPLE, id2,
 310       ASCIIToUTF16("Test Web Notification"),
 311       ASCIIToUTF16("Notification message body."), gfx::Image(),
 312       base::string16() /* empty display source */, GURL(), notifier_id2,
 313       message_center::RichNotificationData(), NULL /* delegate */));
 314   message_center_->AddNotification(notification.Pass());
 315
 316   AddNotification(id3, notifier_id);
 317
 318   // The dummy notifier is SYSTEM_COMPONENT so no context menu is visible.
 319   scoped_ptr<ui::MenuModel> model(
 320       message_center_tray_->CreateNotificationMenuModel(DummyNotifierId(),
 321                                                         display_source));
 322   EXPECT_EQ(nullptr, model.get());
 323
 324   model = message_center_tray_->CreateNotificationMenuModel(notifier_id,
 325                                                             display_source);
 326   EXPECT_EQ(1, model->GetItemCount());
 327
 328   // The first item is to disable notifications from the notifier id. It also
 329   // removes all notifications from the same notifier, i.e. id1 and id3.
 330   EXPECT_TRUE(model->IsEnabledAt(0));
 331   model->ActivatedAt(0);
 332
 333   NotificationList::Notifications notifications =
 334       message_center_->GetVisibleNotifications();
 335   EXPECT_EQ(1u, notifications.size());
 336   EXPECT_EQ(id2, (*notifications.begin())->id());
 337
 338   // Disables the context menu.
 339   delegate_->enable_context_menu_ = false;
 340
 341   // id2 doesn't have the display source, so it don't have the menu item for
 342   // disabling notifications.
 343   EXPECT_EQ(nullptr, message_center_tray_->CreateNotificationMenuModel(
 344                          notifier_id2, base::string16()));
 345 }
 346 #endif
 347
 348 TEST_F(MessageCenterTrayTest, DelegateDisabledContextMenu) {
 349   const std::string id1 = "id1";
 350   base::string16 display_source = ASCIIToUTF16("www.test.org");
 351   AddNotification(id1);
 352   NotifierId notifier_id(GURL("www.test.org"));
 353
 354   delegate_->enable_context_menu_ = false;
 355   // id2 doesn't have the display source, so it don't have the menu item for
 356   // disabling notifications.
 357   scoped_ptr<ui::MenuModel> model(
 358       message_center_tray_->CreateNotificationMenuModel(notifier_id,
 359                                                         display_source));
 360
 361 // The commands are disabled because delegate disables context menu.
 362 #ifndef OS_CHROMEOS
 363   EXPECT_EQ(1, model->GetItemCount());
 364 #else
 365   EXPECT_EQ(2, model->GetItemCount());
 366   EXPECT_FALSE(model->IsEnabledAt(1));
 367 #endif
 368
 369   EXPECT_FALSE(model->IsEnabledAt(0));
 370 }
 371
 372 }  // namespace message_center