Turn on and use the AppInfo data.

chrome/browser/notifications/sync_notifier/chrome_notifier_service_unittest.cc

 // Copyright (c) 2012 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 <map>
 
 #include "base/command_line.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.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/chrome_notifier_service.h"
 #include "chrome/browser/notifications/sync_notifier/sync_notifier_test_utils.h"
 #include "chrome/browser/notifications/sync_notifier/synced_notification.h"
+#include "chrome/browser/notifications/sync_notifier/synced_notification_app_info.h"
+#include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.h"
+#include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service_factory.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
@@ skipping 88 matching lines @@
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableSyncSyncedNotifications);
 
     // Prevent test code from trying to go to the network.
     ChromeNotifierService::set_avoid_bitmap_fetching_for_test(true);
     notification_manager_.reset(new StubNotificationUIManager(GURL(
         kSyncedNotificationsWelcomeOrigin)));
 
     // Set up a profile for the unit tests to use.
     profile_.reset(new TestingProfile());
+
+    // Set up the testing SyncedNotificationAppInfoService with some test data.
+    AddTestingAppInfos();
   }
 
   virtual void TearDown() {
     notification_manager_.reset();
   }
 
   StubNotificationUIManager* notification_manager() {
     return notification_manager_.get();
   }
 
@@ skipping 10 matching lines @@
       const std::string& text,
       const std::string& app_icon_url,
       const std::string& image_url,
       const std::string& app_id,
       const std::string& key,
       sync_pb::CoalescedSyncedNotification_ReadState read_state) {
     SyncData sync_data = CreateSyncData(title, text, app_icon_url, image_url,
                                         app_id, key, read_state);
     // Set enough fields in sync_data, including specifics, for our tests
     // to pass.
-    return new SyncedNotification(sync_data);
+    return new SyncedNotification(sync_data, NULL, notification_manager_.get());
   }
 
   // Helper to create syncer::SyncChange.
   static SyncChange CreateSyncChange(
       SyncChange::SyncChangeType type,
       SyncedNotification* notification) {
     // Take control of the notification to clean it up after we create data
     // out of it.
     scoped_ptr<SyncedNotification> scoped_notification(notification);
     return SyncChange(
         FROM_HERE,
         type,
         ChromeNotifierService::CreateSyncDataFromNotification(*notification));
   }
 
+  void AddTestingAppInfos() {
+    // Get the SyncedNotificationAppInfoService from the browser object.
+    SyncedNotificationAppInfoService* synced_notification_app_info_service =
+        SyncedNotificationAppInfoServiceFactory::GetForProfile(
+            profile_.get(), Profile::EXPLICIT_ACCESS);
+
+    // Create a notification to add.
+    // The sending_service_infos_ list will take ownership of this pointer.
+    scoped_ptr<SyncedNotificationAppInfo> test_service1(
+        new SyncedNotificationAppInfo(profile_.get(),
+                                      std::string(kSendingService1Name),
+                                      synced_notification_app_info_service));
+
+    // Add some App IDs.
+    test_service1->AddAppId(kAppId1);
+    test_service1->AddAppId(kAppId2);
+
+    // Set this icon's GURLs.
+    test_service1->SetSettingsURLs(GURL(kTestIconUrl), GURL());
+
+    // Call AddForTest.
+    synced_notification_app_info_service->AddForTest(test_service1.Pass());
+  }
+
  protected:
   scoped_ptr<TestingProfile> profile_;
 
  private:
   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_wrapper_;
   scoped_ptr<StubNotificationUIManager> notification_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeNotifierServiceTest);
 };
 
-// TODO(petewil): Add more tests as I add functionalty.  Tests are based on
-// chrome/browser/extensions/app_notification_manager_sync_unittest.cc
-
 // Create a Notification, convert it to SyncData and convert it back.
 TEST_F(ChromeNotifierServiceTest, NotificationToSyncDataToNotification) {
+  ChromeNotifierService notifier(profile_.get(), notification_manager());
+
   scoped_ptr<SyncedNotification> notification1(
       CreateNotification(kTitle1, kText1, kIconUrl1, kImageUrl1, kAppId1,
                          kKey1, kUnread));
   SyncData sync_data =
       ChromeNotifierService::CreateSyncDataFromNotification(*notification1);
   scoped_ptr<SyncedNotification> notification2(
-      ChromeNotifierService::CreateNotificationFromSyncData(sync_data));
+      notifier.CreateNotificationFromSyncData(sync_data));
   EXPECT_TRUE(notification2.get());
   EXPECT_TRUE(notification1->EqualsIgnoringReadState(*notification2));
   EXPECT_EQ(notification1->GetReadState(), notification2->GetReadState());
 }
 
 // Model assocation:  We have no local data, and no remote data.
 TEST_F(ChromeNotifierServiceTest, ModelAssocBothEmpty) {
 
   ChromeNotifierService notifier(profile_.get(), notification_manager());
 
@@ skipping 180 matching lines @@
   EXPECT_TRUE(notifier.FindNotificationById(kKey3));
   EXPECT_TRUE(notifier.FindNotificationById(kKey4));
   EXPECT_TRUE(notifier.FindNotificationById(kKey5));
   EXPECT_TRUE(notifier.FindNotificationById(kKey6));
   EXPECT_TRUE(notifier.FindNotificationById(kKey7));
 
   // Test the type conversion and construction functions.
   for (SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     scoped_ptr<SyncedNotification> notification1(
-        ChromeNotifierService::CreateNotificationFromSyncData(*iter));
+        notifier.CreateNotificationFromSyncData(*iter));
     // TODO(petewil): Revisit this when we add version info to notifications.
     const std::string& key = notification1->GetKey();
     const SyncedNotification* notification2 =
         notifier.FindNotificationById(key);
     EXPECT_TRUE(NULL != notification2);
     EXPECT_TRUE(notification1->EqualsIgnoringReadState(*notification2));
     EXPECT_EQ(notification1->GetReadState(), notification2->GetReadState());
   }
   EXPECT_TRUE(notifier.FindNotificationById(kKey1));
   EXPECT_TRUE(notifier.FindNotificationById(kKey2));
@@ skipping 117 matching lines @@
   EXPECT_EQ(std::string(kTitle2), notification1->GetTitle());
 
   // Ensure no new data will be sent to the remote store for notification1.
   EXPECT_EQ(0U, processor()->change_list_size());
   EXPECT_FALSE(processor()->ContainsId(kKey1));
 }
 
 TEST_F(ChromeNotifierServiceTest, ServiceEnabledTest) {
   ChromeNotifierService notifier(profile_.get(), notification_manager());
   std::set<std::string>::iterator iter;
-  std::string first_synced_notification_service_id(
-      kFirstSyncedNotificationServiceId);
+  std::string first_synced_notification_service_id(kSendingService1Name);
 
   // Create some local fake data.
   scoped_ptr<SyncedNotification> n1(CreateNotification(
       kTitle1, kText1, kIconUrl1, kImageUrl1, kAppId1, kKey1, kUnread));
   notifier.AddForTest(n1.Pass());
 
   // Enable the service and ensure the service is in the list.
   // Initially the service starts in the disabled state.
-  notifier.OnSyncedNotificationServiceEnabled(kFirstSyncedNotificationServiceId,
-                                              true);
+  notifier.OnSyncedNotificationServiceEnabled(kSendingService1Name, true);
   iter = find(notifier.enabled_sending_services_.begin(),
               notifier.enabled_sending_services_.end(),
               first_synced_notification_service_id);
+
   EXPECT_NE(notifier.enabled_sending_services_.end(), iter);
+
   // TODO(petewil): Verify Display gets called too.
-
   // Disable the service and ensure it is gone from the list and the
   // notification_manager.
-  notifier.OnSyncedNotificationServiceEnabled(kFirstSyncedNotificationServiceId,
-                                              false);
+  notifier.OnSyncedNotificationServiceEnabled(kSendingService1Name, false);
   iter = find(notifier.enabled_sending_services_.begin(),
               notifier.enabled_sending_services_.end(),
               first_synced_notification_service_id);
+
   EXPECT_EQ(notifier.enabled_sending_services_.end(), iter);
   EXPECT_EQ(notification_manager()->dismissed_id(), std::string(kKey1));
-
 }
 
 // http://crbug.com/341326
 #if defined(TOOLKIT_GTK)
 #define MAYBE_AddNewSendingServicesTest DISABLED_AddNewSendingServicesTest
 #else
 #define MAYBE_AddNewSendingServicesTest AddNewSendingServicesTest
 #endif
 TEST_F(ChromeNotifierServiceTest, MAYBE_AddNewSendingServicesTest) {
   // This test will see if we get a new sending service after the first
   // notification for that service.
   ChromeNotifierService notifier(profile_.get(), notification_manager());
   notifier.set_avoid_bitmap_fetching_for_test(true);
 
   // We initially have no data.
   EXPECT_EQ(0U, notifier.enabled_sending_services_.size());
   EXPECT_EQ(0U, notifier.GetAllSyncData(SYNCED_NOTIFICATIONS).size());
 
   // Set up an ADD.
   SyncChangeList changes;
   changes.push_back(
       CreateSyncChange(SyncChange::ACTION_ADD,
                        CreateNotification(kTitle1,
                                           kText1,
                                           kIconUrl1,
                                           kImageUrl1,
-                                          kFirstSyncedNotificationServiceId,
+                                          kAppId1,
                                           kKey1,
                                           kUnread)));
 
   notifier.ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(1U, notifier.GetAllSyncData(SYNCED_NOTIFICATIONS).size());
 
   // Verify that the first synced notification service is enabled in memory.
   std::set<std::string>::iterator iter;
-  std::string first_notification_service_id(kFirstSyncedNotificationServiceId);
+  std::string first_notification_service_id(kSendingService1Name);
   iter = find(notifier.enabled_sending_services_.begin(),
               notifier.enabled_sending_services_.end(),
               first_notification_service_id);
 
   EXPECT_NE(notifier.enabled_sending_services_.end(), iter);
 
   // We should have gotten the synced notification and a welcome notification.
   EXPECT_EQ(2U, notification_manager()->added_notifications());
   EXPECT_TRUE(notification_manager()->welcomed());
 
   changes.clear();
   changes.push_back(
       CreateSyncChange(SyncChange::ACTION_ADD,
                        CreateNotification(kTitle2,
                                           kText2,
                                           kIconUrl2,
                                           kImageUrl2,
-                                          kFirstSyncedNotificationServiceId,
+                                          kAppId1,
                                           kKey2,
                                           kUnread)));
   notifier.ProcessSyncChanges(FROM_HERE, changes);
 
   // But adding another notification should not cause another welcome.
   EXPECT_EQ(3U, notification_manager()->added_notifications());
 }
 
 TEST_F(ChromeNotifierServiceTest, CheckInitializedServicesTest) {
   // This test will see if we get a new sending service after the first
   // notification for that service.
   ChromeNotifierService notifier(profile_.get(), notification_manager());
   notifier.set_avoid_bitmap_fetching_for_test(true);
 
   // Initialize but do not enable the sending service.
-  notifier.initialized_sending_services_.insert(
-      kFirstSyncedNotificationServiceId);
+  notifier.initialized_sending_services_.insert(kSendingService1Name);
   ASSERT_EQ(0U, notifier.enabled_sending_services_.size());
   ASSERT_EQ(1U, notifier.initialized_sending_services_.size());
 
   // We initially have no data.
   EXPECT_EQ(0U, notifier.enabled_sending_services_.size());
   EXPECT_EQ(0U, notifier.GetAllSyncData(SYNCED_NOTIFICATIONS).size());
 
   // Set up an ADD.
-  std::string first_synced_notification_service_id(
-      kFirstSyncedNotificationServiceId);
+  std::string first_synced_notification_service_id(kSendingService1Name);
 
   SyncChangeList changes;
   changes.push_back(
       CreateSyncChange(SyncChange::ACTION_ADD,
                        CreateNotification(kTitle1,
                                           kText1,
                                           kIconUrl1,
                                           kImageUrl1,
-                                          kFirstSyncedNotificationServiceId,
+                                          kAppId1,
                                           kKey1,
                                           kUnread)));
 
   notifier.ProcessSyncChanges(FROM_HERE, changes);
 
   // Since we added to |initialized_sending_services_| before receiving the
   // synced notification, we should not have enabled this service while
   // processing the sync change.
   EXPECT_EQ(0U, notifier.enabled_sending_services_.size());
   EXPECT_EQ(0U, notification_manager()->added_notifications());
 }
 
-TEST_F(ChromeNotifierServiceTest, CheckFindAppInfo) {
+TEST_F(ChromeNotifierServiceTest, SetAddedAppIdsTest) {
   ChromeNotifierService notifier(profile_.get(), notification_manager());
   notifier.set_avoid_bitmap_fetching_for_test(true);
 
-  SyncedNotificationAppInfoTemp* app_info =
-      notifier.FindAppInfo(kFirstSyncedNotificationServiceId);
-  EXPECT_TRUE(app_info != NULL);
+  // Add some notifications to our notification list.
+  scoped_ptr<SyncedNotification> n1(CreateNotification(
+      kTitle1, kText1, kIconUrl1, kImageUrl1, kAppId1, kKey1, kUnread));
+  n1->SetNotifierServiceForTest(&notifier);
+  notifier.AddForTest(n1.Pass());
+
+  EXPECT_EQ(static_cast<size_t>(0),
+            notification_manager()->added_notifications());
+
+  // Call SetAddedAppIds.
+  std::vector<std::string> added_app_ids;
+  added_app_ids.push_back(std::string(kAppId1));
+  notifier.OnAddedAppIds(added_app_ids);
+
+  // Verify the notification was added by the notification_manager.
+  // We see one welcome notification and one new notification.
+  EXPECT_EQ(static_cast<size_t>(2),
+            notification_manager()->added_notifications());
 }
 
+TEST_F(ChromeNotifierServiceTest, SetRemovedAppIdsTest) {
+  ChromeNotifierService notifier(profile_.get(), notification_manager());
+  notifier.set_avoid_bitmap_fetching_for_test(true);
+
+  // Add some notifications to our notification list.
+  scoped_ptr<SyncedNotification> n1(CreateNotification(
+      kTitle1, kText1, kIconUrl1, kImageUrl1, kAppId1, kKey1, kUnread));
+  notifier.AddForTest(n1.Pass());
+
+  // Call SetRemovedAppIds.
+  std::vector<std::string> removed_app_ids;
+  removed_app_ids.push_back(std::string(kAppId1));
+  notifier.OnRemovedAppIds(removed_app_ids);
+
+  // Verify the notification was "removed" in the notification manager.
+  EXPECT_EQ(std::string(kKey1), notification_manager()->dismissed_id());
+}
+
+// TODO(petewil): Add a test that we do *not* get a welcome dialog unless we
+// have a valid app info for the notification.
+
 }  // namespace notifier