// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/app_menu/notification_menu_view.h"
#include "ash/app_menu/notification_item_view.h"
#include "ash/app_menu/notification_menu_view_test_api.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/events/base_event_utils.h"
#include "ui/events/test/event_generator.h"
#include "ui/gfx/geometry/transform.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/views/controls/label.h"
#include "ui/views/test/views_test_base.h"
#include "ui/views/test/views_test_utils.h"
#include "ui/views/view.h"
#include "ui/views/widget/widget_delegate.h"
#include "ui/views/widget/widget_utils.h"
namespace ash {
namespace {
// The app id used in tests.
constexpr char kTestAppId[] = "test-app-id";
class MockNotificationMenuController : public views::SlideOutControllerDelegate,
public NotificationMenuView::Delegate {
public:
MockNotificationMenuController() = default;
MockNotificationMenuController(const MockNotificationMenuController&) =
delete;
MockNotificationMenuController& operator=(
const MockNotificationMenuController&) = delete;
~MockNotificationMenuController() override = default;
void ActivateNotificationAndClose(
const std::string& notification_id) override {
activation_count_++;
}
void OnOverflowAddedOrRemoved() override {
overflow_added_or_removed_count_++;
}
ui::Layer* GetSlideOutLayer() override {
return notification_menu_view_->GetSlideOutLayer();
}
void OnSlideChanged(bool in_progress) override {}
void OnSlideOut() override { slide_out_count_++; }
void set_notification_menu_view(
NotificationMenuView* notification_menu_view) {
notification_menu_view_ = notification_menu_view;
}
int slide_out_count_ = 0;
int activation_count_ = 0;
int overflow_added_or_removed_count_ = 0;
// Owned by NotificationMenuViewTest.
raw_ptr<NotificationMenuView, DanglingUntriaged> notification_menu_view_ =
nullptr;
};
} // namespace
class NotificationMenuViewTest : public views::ViewsTestBase {
public:
NotificationMenuViewTest() {}
NotificationMenuViewTest(const NotificationMenuViewTest&) = delete;
NotificationMenuViewTest& operator=(const NotificationMenuViewTest&) = delete;
~NotificationMenuViewTest() override = default;
// views::ViewsTestBase:
void SetUp() override {
views::ViewsTestBase::SetUp();
zero_duration_scope_ =
std::make_unique<ui::ScopedAnimationDurationScaleMode>(
ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
mock_notification_menu_controller_ =
std::make_unique<MockNotificationMenuController>();
auto notification_menu_view = std::make_unique<NotificationMenuView>(
mock_notification_menu_controller_.get(),
mock_notification_menu_controller_.get(), kTestAppId);
// Set the NotificationMenuView so |mock_notification_menu_controller_|
// can get the slide out layer. In production NotificationMenuController is
// the NotificationItemViewDelegate, and it gets a reference to
// NotificationMenuView when it is created.
mock_notification_menu_controller_->set_notification_menu_view(
notification_menu_view.get());
test_api_ = std::make_unique<NotificationMenuViewTestAPI>(
notification_menu_view.get());
widget_ = std::make_unique<views::Widget>();
views::Widget::InitParams init_params(
CreateParams(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
views::Widget::InitParams::TYPE_POPUP));
init_params.activatable = views::Widget::InitParams::Activatable::kYes;
widget_->Init(std::move(init_params));
notification_menu_view_ =
widget_->SetContentsView(std::move(notification_menu_view));
widget_->SetSize(notification_menu_view_->GetPreferredSize());
widget_->Show();
widget_->Activate();
}
void TearDown() override {
widget_->Close();
views::ViewsTestBase::TearDown();
}
message_center::Notification AddNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message) {
const message_center::NotifierId notifier_id(
message_center::NotifierType::APPLICATION, kTestAppId);
message_center::Notification notification(
message_center::NOTIFICATION_TYPE_SIMPLE, notification_id, title,
message, ui::ImageModel(), u"www.test.org", GURL(), notifier_id,
message_center::RichNotificationData(), nullptr /* delegate */);
notification_menu_view_->AddNotificationItemView(notification);
views::test::RunScheduledLayout(notification_menu_view_);
return notification;
}
message_center::Notification UpdateNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message) {
const message_center::NotifierId notifier_id(
message_center::NotifierType::APPLICATION, kTestAppId);
message_center::Notification notification(
message_center::NOTIFICATION_TYPE_SIMPLE, notification_id, title,
message, ui::ImageModel(), u"www.test.org", GURL(), notifier_id,
message_center::RichNotificationData(), nullptr /* delegate */);
notification_menu_view_->UpdateNotificationItemView(notification);
return notification;
}
void CheckDisplayedNotification(
const message_center::Notification& notification) {
// Check whether the notification and view contents match.
const auto* item =
notification_menu_view_->GetDisplayedNotificationItemView();
ASSERT_TRUE(item);
EXPECT_EQ(item->notification_id(), notification.id());
EXPECT_EQ(item->title(), notification.title());
EXPECT_EQ(item->message(), notification.message());
}
void BeginScroll() {
DispatchGesture(
ui::GestureEventDetails(ui::EventType::kGestureScrollBegin));
}
void EndScroll() {
DispatchGesture(ui::GestureEventDetails(ui::EventType::kGestureScrollEnd));
}
void ScrollBy(int dx) {
DispatchGesture(
ui::GestureEventDetails(ui::EventType::kGestureScrollUpdate, dx, 0));
}
void DispatchGesture(const ui::GestureEventDetails& details) {
ui::test::EventGenerator generator(
GetRootWindow(notification_menu_view_->GetWidget()));
const auto* item =
notification_menu_view_->GetDisplayedNotificationItemView();
ui::GestureEvent event(0, item->GetBoundsInScreen().y(), 0,
ui::EventTimeForNow(), details);
generator.Dispatch(&event);
}
float GetSlideAmount() const {
return notification_menu_view_->GetSlideOutLayer()
->transform()
.To2dTranslation()
.x();
}
NotificationMenuView* notification_menu_view() {
return notification_menu_view_;
}
NotificationMenuViewTestAPI* test_api() { return test_api_.get(); }
MockNotificationMenuController* mock_notification_menu_controller() {
return mock_notification_menu_controller_.get();
}
private:
std::unique_ptr<MockNotificationMenuController>
mock_notification_menu_controller_;
raw_ptr<NotificationMenuView, DanglingUntriaged> notification_menu_view_;
std::unique_ptr<NotificationMenuViewTestAPI> test_api_;
std::unique_ptr<views::Widget> widget_;
std::unique_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_scope_;
};
// Tests that the correct NotificationItemView is shown when notifications come
// and go.
TEST_F(NotificationMenuViewTest, Basic) {
// Add a notification to the view.
const message_center::Notification notification_0 =
AddNotification("notification_id_0", u"title_0", u"message_0");
// The counter should update to 1, and the displayed NotificationItemView
// should match the notification.
EXPECT_EQ(base::NumberToString16(1), test_api()->GetCounterViewContents());
EXPECT_EQ(1, test_api()->GetItemViewCount());
CheckDisplayedNotification(notification_0);
// Add a second notification to the view, the counter view and displayed
// NotificationItemView should change.
const message_center::Notification notification_1 =
AddNotification("notification_id_1", u"title_1", u"message_1");
EXPECT_EQ(base::NumberToString16(2), test_api()->GetCounterViewContents());
EXPECT_EQ(2, test_api()->GetItemViewCount());
CheckDisplayedNotification(notification_1);
// Remove |notification_1|, |notification_0| should be shown.
notification_menu_view()->OnNotificationRemoved(notification_1.id());
EXPECT_EQ(base::NumberToString16(1), test_api()->GetCounterViewContents());
EXPECT_EQ(1, test_api()->GetItemViewCount());
CheckDisplayedNotification(notification_0);
}
TEST_F(NotificationMenuViewTest, MultipleNotificationsBasic) {
// Add multiple notifications to the view.
const message_center::Notification notification_0 =
AddNotification("notification_id_0", u"title_0", u"message_0");
// Overflow should not be created until there are two notifications.
EXPECT_FALSE(test_api()->GetOverflowView());
EXPECT_EQ(
0, mock_notification_menu_controller()->overflow_added_or_removed_count_);
// Add a second notification, this will push |notification_0| into overflow.
const message_center::Notification notification_1 =
AddNotification("notification_id_1", u"title_1", u"message_1");
CheckDisplayedNotification(notification_1);
EXPECT_TRUE(test_api()->GetOverflowView());
EXPECT_EQ(
1, mock_notification_menu_controller()->overflow_added_or_removed_count_);
// Remove the notification that is in overflow.
notification_menu_view()->OnNotificationRemoved(notification_0.id());
// The displayed notification should not have changed, and the overflow view
// should be deleted.
CheckDisplayedNotification(notification_1);
EXPECT_FALSE(test_api()->GetOverflowView());
}
// Tests that when the displayed NotificationItemView is removed, the
// notification from the overflow view becomes the displayed view.
TEST_F(NotificationMenuViewTest, ShowNotificationFromOverflow) {
// Add multiple notifications to the view.
const message_center::Notification notification_0 =
AddNotification("notification_id_0", u"title_0", u"message_0");
EXPECT_FALSE(test_api()->GetOverflowView());
const message_center::Notification notification_1 =
AddNotification("notification_id_1", u"title_1", u"message_1");
// |notification_1| should be the displayed NotificationItemView.
CheckDisplayedNotification(notification_1);
EXPECT_TRUE(test_api()->GetOverflowView());
// Remove the displayed NotificationItemView, the overflow notification should
// take its place and overflow should be removed.
notification_menu_view()->OnNotificationRemoved(notification_1.id());
CheckDisplayedNotification(notification_0);
EXPECT_FALSE(test_api()->GetOverflowView());
}
// Tests that removing a notification that is not being shown only updates the
// counter.
TEST_F(NotificationMenuViewTest, RemoveOlderNotification) {
// Add two notifications.
const message_center::Notification notification_0 =
AddNotification("notification_id_0", u"title_0", u"message_0");
const message_center::Notification notification_1 =
AddNotification("notification_id_1", u"title_1", u"message_1");
// The latest notification should be shown.
EXPECT_EQ(base::NumberToString16(2), test_api()->GetCounterViewContents());
EXPECT_EQ(2, test_api()->GetItemViewCount());
CheckDisplayedNotification(notification_1);
// Remove the older notification, |notification_0|.
notification_menu_view()->OnNotificationRemoved(notification_0.id());
// The latest notification, |notification_1|, should be shown.
EXPECT_EQ(base::NumberToString16(1), test_api()->GetCounterViewContents());
EXPECT_EQ(1, test_api()->GetItemViewCount());
CheckDisplayedNotification(notification_1);
}
// Tests that the displayed NotificationItemView is only dismissed when dragged
// beyond the threshold.
TEST_F(NotificationMenuViewTest, SlideOut) {
AddNotification("notification_id", u"title", u"message");
EXPECT_EQ(0, mock_notification_menu_controller()->slide_out_count_);
BeginScroll();
// Scroll by a small amount, the notification should move but not slide out.
ScrollBy(-10);
EXPECT_EQ(0, mock_notification_menu_controller()->slide_out_count_);
EXPECT_EQ(-10.f, GetSlideAmount());
// End the scroll gesture, the notifications should return to its resting
// place.
EndScroll();
EXPECT_EQ(0, mock_notification_menu_controller()->slide_out_count_);
EXPECT_EQ(0.f, GetSlideAmount());
BeginScroll();
// Scroll beyond the threshold but do not release the gesture scroll.
ScrollBy(-200);
EXPECT_EQ(-200.f, GetSlideAmount());
// Release the gesture, the notification should slide out.
EndScroll();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, mock_notification_menu_controller()->slide_out_count_);
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
}
// Tests that tapping a notification activates it.
TEST_F(NotificationMenuViewTest, TapNotification) {
AddNotification("notification_id", u"title", u"message");
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
DispatchGesture(ui::GestureEventDetails(ui::EventType::kGestureTap));
EXPECT_EQ(1, mock_notification_menu_controller()->activation_count_);
}
// Tests that an in bounds mouse release activates a notification.
TEST_F(NotificationMenuViewTest, ClickNotification) {
AddNotification("notification_id", u"title", u"message");
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
const auto* item =
notification_menu_view()->GetDisplayedNotificationItemView();
const gfx::Point cursor_location = item->GetBoundsInScreen().origin();
ui::MouseEvent press(ui::EventType::kMousePressed, cursor_location,
cursor_location, ui::EventTimeForNow(),
ui::EF_LEFT_MOUSE_BUTTON, ui::EF_NONE);
notification_menu_view()->GetWidget()->OnMouseEvent(&press);
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
ui::MouseEvent release(ui::EventType::kMouseReleased, cursor_location,
cursor_location, ui::EventTimeForNow(),
ui::EF_LEFT_MOUSE_BUTTON, ui::EF_NONE);
notification_menu_view()->GetWidget()->OnMouseEvent(&release);
EXPECT_EQ(1, mock_notification_menu_controller()->activation_count_);
}
// Tests that an out of bounds mouse release does not activate a notification.
TEST_F(NotificationMenuViewTest, OutOfBoundsClick) {
AddNotification("notification_id", u"title", u"message");
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
const auto* item =
notification_menu_view()->GetDisplayedNotificationItemView();
const gfx::Point cursor_location = item->GetBoundsInScreen().origin();
ui::MouseEvent press(ui::EventType::kMousePressed, cursor_location,
cursor_location, ui::EventTimeForNow(),
ui::EF_LEFT_MOUSE_BUTTON, ui::EF_NONE);
notification_menu_view()->GetWidget()->OnMouseEvent(&press);
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
const gfx::Point out_of_bounds;
ui::MouseEvent out_of_bounds_release(
ui::EventType::kMouseReleased, out_of_bounds, out_of_bounds,
ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_NONE);
notification_menu_view()->GetWidget()->OnMouseEvent(&out_of_bounds_release);
EXPECT_EQ(0, mock_notification_menu_controller()->activation_count_);
}
// Tests updating notifications that do and do not exist.
TEST_F(NotificationMenuViewTest, UpdateNotification) {
// Add a notification.
const std::string notification_id = "notification_id";
AddNotification(notification_id, u"title", u"message");
// Send an updated notification with a matching |notification_id|.
const message_center::Notification updated_notification =
UpdateNotification(notification_id, u"new_title", u"new_message");
// The displayed notification's contents should have changed to match the
// updated notification.
EXPECT_EQ(base::NumberToString16(1), test_api()->GetCounterViewContents());
EXPECT_EQ(1, test_api()->GetItemViewCount());
CheckDisplayedNotification(updated_notification);
// Send an updated notification for a notification which doesn't yet exist.
UpdateNotification("Bad notification", u"Bad Title", u"Bad Message");
// Test that the displayed notification has not been changed.
EXPECT_EQ(base::NumberToString16(1), test_api()->GetCounterViewContents());
EXPECT_EQ(1, test_api()->GetItemViewCount());
CheckDisplayedNotification(updated_notification);
}
} // namespace ash
Codebase Browser
chromium