| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <string> |
| |
| #include "base/memory/scoped_ptr.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "chrome/browser/notifications/notification.h" |
| #include "chrome/browser/notifications/notification_test_util.h" |
| #include "chrome/browser/notifications/notification_ui_manager.h" |
| #include "chrome/browser/notifications/sync_notifier/sync_notifier_test_utils.h" |
| #include "chrome/browser/notifications/sync_notifier/synced_notification.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/test/test_browser_thread.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/skia/include/core/SkBitmap.h" |
| #include "ui/message_center/notification_types.h" |
| |
| using syncer::SyncData; |
| using notifier::SyncedNotification; |
| using sync_pb::EntitySpecifics; |
| using sync_pb::SyncedNotificationSpecifics; |
| |
| namespace { |
| const int kNotificationPriority = static_cast<int>( |
| message_center::LOW_PRIORITY); |
| |
| } // namespace |
| |
| namespace notifier { |
| |
| class SyncedNotificationTest : public testing::Test { |
| public: |
| SyncedNotificationTest() |
| : ui_thread_(content::BrowserThread::UI, &message_loop_) {} |
| virtual ~SyncedNotificationTest() {} |
| |
| // Methods from testing::Test. |
| |
| virtual void SetUp() OVERRIDE { |
| notification_manager_.reset(new StubNotificationUIManager(GURL( |
| kSyncedNotificationsWelcomeOrigin))); |
| |
| sync_data1_ = CreateSyncData(kTitle1, kText1, kIconUrl1, kImageUrl1, |
| kAppId1, kKey1, kUnread); |
| sync_data2_ = CreateSyncData(kTitle2, kText2, kIconUrl2, kImageUrl2, |
| kAppId2, kKey2, kUnread); |
| // Notification 3 will have the same ID as notification1, but different |
| // data inside. |
| sync_data3_ = CreateSyncData(kTitle3, kText3, kIconUrl3, kImageUrl3, |
| kAppId1, kKey1, kUnread); |
| // Notification 4 will be the same as 1, but the read state will be 'read'. |
| sync_data4_ = CreateSyncData(kTitle1, kText1, kIconUrl1, kImageUrl1, |
| kAppId1, kKey1, kDismissed); |
| |
| notification1_.reset(new SyncedNotification( |
| sync_data1_, NULL, notification_manager_.get())); |
| notification2_.reset(new SyncedNotification( |
| sync_data2_, NULL, notification_manager_.get())); |
| notification3_.reset(new SyncedNotification( |
| sync_data3_, NULL, notification_manager_.get())); |
| notification4_.reset(new SyncedNotification( |
| sync_data4_, NULL, notification_manager_.get())); |
| |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| notification_manager_.reset(); |
| } |
| |
| virtual void AddButtonBitmaps(SyncedNotification* notification, |
| unsigned int how_many) { |
| for (unsigned int i = 0; i < how_many; ++i) { |
| notification->button_bitmaps_.push_back(gfx::Image()); |
| notification->button_bitmaps_fetch_pending_.push_back(true); |
| } |
| } |
| |
| StubNotificationUIManager* notification_manager() { |
| return notification_manager_.get(); |
| } |
| |
| scoped_ptr<SyncedNotification> notification1_; |
| scoped_ptr<SyncedNotification> notification2_; |
| scoped_ptr<SyncedNotification> notification3_; |
| scoped_ptr<SyncedNotification> notification4_; |
| syncer::SyncData sync_data1_; |
| syncer::SyncData sync_data2_; |
| syncer::SyncData sync_data3_; |
| syncer::SyncData sync_data4_; |
| |
| private: |
| base::MessageLoopForIO message_loop_; |
| content::TestBrowserThread ui_thread_; |
| scoped_ptr<StubNotificationUIManager> notification_manager_; |
| |
| DISALLOW_COPY_AND_ASSIGN(SyncedNotificationTest); |
| }; |
| |
| // test simple accessors |
| |
| TEST_F(SyncedNotificationTest, GetAppIdTest) { |
| std::string found_app_id = notification1_->GetAppId(); |
| std::string expected_app_id(kAppId1); |
| |
| EXPECT_EQ(found_app_id, expected_app_id); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetKeyTest) { |
| std::string found_key = notification1_->GetKey(); |
| std::string expected_key(kKey1); |
| |
| EXPECT_EQ(expected_key, found_key); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetTitleTest) { |
| std::string found_title = notification1_->GetTitle(); |
| std::string expected_title(kTitle1); |
| |
| EXPECT_EQ(expected_title, found_title); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetIconURLTest) { |
| std::string found_icon_url = notification1_->GetAppIconUrl().spec(); |
| std::string expected_icon_url(kIconUrl1); |
| |
| EXPECT_EQ(expected_icon_url, found_icon_url); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetReadStateTest) { |
| SyncedNotification::ReadState found_state1 = |
| notification1_->GetReadState(); |
| SyncedNotification::ReadState expected_state1(SyncedNotification::kUnread); |
| |
| EXPECT_EQ(expected_state1, found_state1); |
| |
| SyncedNotification::ReadState found_state2 = |
| notification4_->GetReadState(); |
| SyncedNotification::ReadState expected_state2(SyncedNotification::kDismissed); |
| |
| EXPECT_EQ(expected_state2, found_state2); |
| } |
| |
| // TODO(petewil): Improve ctor to pass in an image and type so this test can |
| // pass on actual data. |
| TEST_F(SyncedNotificationTest, GetImageURLTest) { |
| GURL found_image_url = notification1_->GetImageUrl(); |
| GURL expected_image_url = GURL(kImageUrl1); |
| |
| EXPECT_EQ(expected_image_url, found_image_url); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetTextTest) { |
| std::string found_text = notification1_->GetText(); |
| std::string expected_text(kText1); |
| |
| EXPECT_EQ(expected_text, found_text); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetCreationTimeTest) { |
| uint64 found_time = notification1_->GetCreationTime(); |
| EXPECT_EQ(kFakeCreationTime, found_time); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetPriorityTest) { |
| double found_priority = notification1_->GetPriority(); |
| EXPECT_EQ(static_cast<double>(kNotificationPriority), found_priority); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetButtonCountTest) { |
| int found_button_count = notification1_->GetButtonCount(); |
| EXPECT_EQ(2, found_button_count); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetNotificationCountTest) { |
| int found_notification_count = notification1_->GetNotificationCount(); |
| EXPECT_EQ(3, found_notification_count); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetDefaultDestinationDataTest) { |
| std::string default_destination_title = |
| notification1_->GetDefaultDestinationTitle(); |
| GURL default_destination_icon_url = |
| notification1_->GetDefaultDestinationIconUrl(); |
| GURL default_destination_url = |
| notification1_->GetDefaultDestinationUrl(); |
| EXPECT_EQ(std::string(kDefaultDestinationTitle), default_destination_title); |
| EXPECT_EQ(GURL(kDefaultDestinationIconUrl), |
| default_destination_icon_url); |
| EXPECT_EQ(GURL(kDefaultDestinationUrl), default_destination_url); |
| } |
| |
| TEST_F(SyncedNotificationTest, GetButtonDataTest) { |
| std::string button_one_title = notification1_->GetButtonTitle(0); |
| GURL button_one_icon_url = notification1_->GetButtonIconUrl(0); |
| GURL button_one_url = notification1_->GetButtonUrl(0); |
| std::string button_two_title = notification1_->GetButtonTitle(1); |
| GURL button_two_icon_url = notification1_->GetButtonIconUrl(1); |
| GURL button_two_url = notification1_->GetButtonUrl(1); |
| EXPECT_EQ(std::string(kButtonOneTitle), button_one_title); |
| EXPECT_EQ(GURL(kButtonOneIconUrl), button_one_icon_url); |
| EXPECT_EQ(GURL(kButtonOneUrl), button_one_url); |
| EXPECT_EQ(std::string(kButtonTwoTitle), button_two_title); |
| EXPECT_EQ(GURL(kButtonTwoIconUrl), button_two_icon_url); |
| EXPECT_EQ(GURL(kButtonTwoUrl), button_two_url); |
| } |
| |
| TEST_F(SyncedNotificationTest, ContainedNotificationTest) { |
| std::string notification_title1 = |
| notification1_->GetContainedNotificationTitle(0); |
| std::string notification_title2 = |
| notification1_->GetContainedNotificationTitle(1); |
| std::string notification_title3 = |
| notification1_->GetContainedNotificationTitle(2); |
| std::string notification_message1 = |
| notification1_->GetContainedNotificationMessage(0); |
| std::string notification_message2 = |
| notification1_->GetContainedNotificationMessage(1); |
| std::string notification_message3 = |
| notification1_->GetContainedNotificationMessage(2); |
| |
| EXPECT_EQ(std::string(kContainedTitle1), notification_title1); |
| EXPECT_EQ(std::string(kContainedTitle2), notification_title2); |
| EXPECT_EQ(std::string(kContainedTitle3), notification_title3); |
| EXPECT_EQ(std::string(kContainedMessage1), notification_message1); |
| EXPECT_EQ(std::string(kContainedMessage2), notification_message2); |
| EXPECT_EQ(std::string(kContainedMessage3), notification_message3); |
| } |
| |
| // test that EqualsIgnoringReadState works as we expect |
| TEST_F(SyncedNotificationTest, EqualsIgnoringReadStateTest) { |
| EXPECT_TRUE(notification1_->EqualsIgnoringReadState(*notification1_)); |
| EXPECT_TRUE(notification2_->EqualsIgnoringReadState(*notification2_)); |
| EXPECT_FALSE(notification1_->EqualsIgnoringReadState(*notification2_)); |
| EXPECT_FALSE(notification1_->EqualsIgnoringReadState(*notification3_)); |
| EXPECT_TRUE(notification1_->EqualsIgnoringReadState(*notification4_)); |
| } |
| |
| TEST_F(SyncedNotificationTest, UpdateTest) { |
| scoped_ptr<SyncedNotification> notification5; |
| notification5.reset(new SyncedNotification( |
| sync_data1_, NULL, notification_manager())); |
| |
| // update with the sync data from notification2, and ensure they are equal. |
| notification5->Update(sync_data2_); |
| EXPECT_TRUE(notification5->EqualsIgnoringReadState(*notification2_)); |
| EXPECT_EQ(notification5->GetReadState(), notification2_->GetReadState()); |
| EXPECT_FALSE(notification5->EqualsIgnoringReadState(*notification1_)); |
| } |
| |
| TEST_F(SyncedNotificationTest, ShowTest) { |
| // Call the method under test using the pre-populated data. |
| notification1_->Show(NULL); |
| |
| const Notification notification = notification_manager()->notification(); |
| |
| // Check the base fields of the notification. |
| EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, notification.type()); |
| EXPECT_EQ(std::string(kTitle1), base::UTF16ToUTF8(notification.title())); |
| EXPECT_EQ(std::string(kText1), base::UTF16ToUTF8(notification.message())); |
| EXPECT_EQ(std::string(kExpectedOriginUrl), notification.origin_url().spec()); |
| EXPECT_EQ(std::string(kKey1), base::UTF16ToUTF8(notification.replace_id())); |
| |
| EXPECT_EQ(kFakeCreationTime, notification.timestamp().ToDoubleT()); |
| EXPECT_EQ(kNotificationPriority, notification.priority()); |
| } |
| |
| TEST_F(SyncedNotificationTest, DismissTest) { |
| |
| // Call the method under test using a dismissed notification. |
| notification4_->Show(NULL); |
| |
| EXPECT_EQ(std::string(kKey1), notification_manager()->dismissed_id()); |
| } |
| |
| TEST_F(SyncedNotificationTest, CreateBitmapFetcherTest) { |
| scoped_ptr<SyncedNotification> notification6; |
| notification6.reset(new SyncedNotification( |
| sync_data1_, NULL, notification_manager())); |
| |
| // Add two bitmaps to the queue. |
| notification6->CreateBitmapFetcher(GURL(kIconUrl1)); |
| notification6->CreateBitmapFetcher(GURL(kIconUrl2)); |
| |
| EXPECT_EQ(GURL(kIconUrl1), notification6->fetchers_[0]->url()); |
| EXPECT_EQ(GURL(kIconUrl2), notification6->fetchers_[1]->url()); |
| |
| notification6->CreateBitmapFetcher(GURL(kIconUrl2)); |
| } |
| |
| TEST_F(SyncedNotificationTest, OnFetchCompleteTest) { |
| // Set up the internal state that FetchBitmaps() would have set. |
| notification1_->notification_manager_ = notification_manager(); |
| |
| // Add the bitmaps to the queue for us to match up. |
| notification1_->CreateBitmapFetcher(GURL(kIconUrl1)); |
| notification1_->CreateBitmapFetcher(GURL(kImageUrl1)); |
| notification1_->CreateBitmapFetcher(GURL(kButtonOneIconUrl)); |
| notification1_->CreateBitmapFetcher(GURL(kButtonTwoIconUrl)); |
| |
| // Put some realistic looking bitmap data into the url_fetcher. |
| SkBitmap bitmap; |
| |
| // Put a real bitmap into "bitmap". 2x2 bitmap of green 32 bit pixels. |
| bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2); |
| bitmap.allocPixels(); |
| bitmap.eraseColor(SK_ColorGREEN); |
| |
| // Allocate the button_bitmaps_ array as the calling function normally would. |
| AddButtonBitmaps(notification1_.get(), 2); |
| |
| notification1_->OnFetchComplete(GURL(kIconUrl1), &bitmap); |
| |
| // When we call OnFetchComplete on the last bitmap, show should be called. |
| notification1_->OnFetchComplete(GURL(kImageUrl1), &bitmap); |
| |
| notification1_->OnFetchComplete(GURL(kButtonOneIconUrl), &bitmap); |
| |
| notification1_->OnFetchComplete(GURL(kButtonTwoIconUrl), &bitmap); |
| |
| // Expect that the app icon has some data in it. |
| EXPECT_FALSE(notification1_->GetAppIcon().IsEmpty()); |
| EXPECT_FALSE(notification_manager()->notification().small_image().IsEmpty()); |
| |
| // Since we check Show() thoroughly in its own test, we only check cursorily. |
| EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, |
| notification_manager()->notification().type()); |
| EXPECT_EQ(std::string(kTitle1), |
| base::UTF16ToUTF8(notification_manager()->notification().title())); |
| EXPECT_EQ( |
| std::string(kText1), |
| base::UTF16ToUTF8(notification_manager()->notification().message())); |
| |
| // TODO(petewil): Check that the bitmap in the notification is what we expect. |
| // This fails today, the type info is different. |
| // EXPECT_TRUE(gfx::BitmapsAreEqual( |
| // image, notification1_->GetAppIconBitmap())); |
| } |
| |
| // TODO(petewil): Empty bitmap should count as a successful fetch. |
| TEST_F(SyncedNotificationTest, EmptyBitmapTest) { |
| // Set up the internal state that FetchBitmaps() would have set. |
| notification1_->notification_manager_ = notification_manager(); |
| |
| // Add the bitmaps to the queue for us to match up. |
| notification1_->CreateBitmapFetcher(GURL(kIconUrl1)); |
| notification1_->CreateBitmapFetcher(GURL(kImageUrl1)); |
| notification1_->CreateBitmapFetcher(GURL(kButtonOneIconUrl)); |
| notification1_->CreateBitmapFetcher(GURL(kButtonTwoIconUrl)); |
| |
| // Put some realistic looking bitmap data into the url_fetcher. |
| SkBitmap bitmap; |
| SkBitmap empty_bitmap; |
| |
| // Put a real bitmap into "bitmap". 2x2 bitmap of green 32 bit pixels. |
| bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2); |
| bitmap.allocPixels(); |
| bitmap.eraseColor(SK_ColorGREEN); |
| |
| // Put a null bitmap into "bitmap". 2x2 bitmap of green 32 bit pixels. |
| empty_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 0, 0); |
| empty_bitmap.allocPixels(); |
| empty_bitmap.eraseColor(SK_ColorGREEN); |
| |
| // Allocate the button_bitmaps_ array as the calling function normally would. |
| AddButtonBitmaps(notification1_.get(), 2); |
| |
| notification1_->OnFetchComplete(GURL(kIconUrl1), &bitmap); |
| |
| // When we call OnFetchComplete on the last bitmap, show should be called. |
| notification1_->OnFetchComplete(GURL(kImageUrl1), &bitmap); |
| |
| notification1_->OnFetchComplete(GURL(kButtonOneIconUrl), &empty_bitmap); |
| |
| notification1_->OnFetchComplete(GURL(kButtonTwoIconUrl), NULL); |
| |
| // Since we check Show() thoroughly in its own test, we only check cursorily. |
| EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, |
| notification_manager()->notification().type()); |
| EXPECT_EQ(std::string(kTitle1), |
| base::UTF16ToUTF8(notification_manager()->notification().title())); |
| EXPECT_EQ( |
| std::string(kText1), |
| base::UTF16ToUTF8(notification_manager()->notification().message())); |
| } |
| |
| TEST_F(SyncedNotificationTest, ShowIfNewlyEnabledTest) { |
| // Call the method using the wrong app id, nothing should get shown. |
| notification1_->ShowAllForAppId(NULL, kAppId2); |
| |
| // Ensure no notification was generated and shown. |
| const Notification notification1 = notification_manager()->notification(); |
| EXPECT_EQ(std::string(), base::UTF16ToUTF8(notification1.replace_id())); |
| |
| // Call the method under test using the pre-populated data. |
| notification1_->ShowAllForAppId(NULL, kAppId1); |
| |
| const Notification notification2 = notification_manager()->notification(); |
| |
| // Check the base fields of the notification. |
| EXPECT_EQ(message_center::NOTIFICATION_TYPE_IMAGE, notification2.type()); |
| EXPECT_EQ(std::string(kTitle1), base::UTF16ToUTF8(notification2.title())); |
| EXPECT_EQ(std::string(kText1), base::UTF16ToUTF8(notification2.message())); |
| EXPECT_EQ(std::string(kExpectedOriginUrl), notification2.origin_url().spec()); |
| EXPECT_EQ(std::string(kKey1), base::UTF16ToUTF8(notification2.replace_id())); |
| |
| EXPECT_EQ(kFakeCreationTime, notification2.timestamp().ToDoubleT()); |
| EXPECT_EQ(kNotificationPriority, notification2.priority()); |
| } |
| |
| TEST_F(SyncedNotificationTest, HideIfNewlyRemovedTest) { |
| // Add the notification to the notification manger, so it exists before we |
| // we remove it. |
| notification1_->Show(NULL); |
| const Notification* found1 = notification_manager()->FindById(kKey1); |
| EXPECT_NE(reinterpret_cast<Notification*>(NULL), found1); |
| |
| // Call the method under test using the pre-populated data. |
| notification1_->HideAllForAppId(kAppId1); |
| |
| // Ensure the notification was removed from the notification manager |
| EXPECT_EQ(std::string(kKey1), notification_manager()->dismissed_id()); |
| } |
| |
| // TODO(petewil): Add a test for a notification being read and or deleted. |
| |
| } // namespace notifier |