Home | History | Annotate | Download | only in sync_notifier 
      1 // Copyright 2014 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 "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.h"
      6 
      7 #include "chrome/browser/notifications/sync_notifier/sync_notifier_test_utils.h"
      8 #include "chrome/browser/profiles/profile.h"
      9 #include "chrome/test/base/testing_pref_service_syncable.h"
     10 #include "chrome/test/base/testing_profile.h"
     11 #include "content/public/test/test_browser_thread.h"
     12 #include "sync/api/fake_sync_change_processor.h"
     13 #include "sync/api/sync_change.h"
     14 #include "sync/api/sync_change_processor.h"
     15 #include "sync/api/sync_error_factory.h"
     16 #include "sync/api/sync_error_factory_mock.h"
     17 #include "sync/protocol/sync.pb.h"
     18 #include "testing/gtest/include/gtest/gtest.h"
     19 
     20 using sync_pb::EntitySpecifics;
     21 using syncer::SyncData;
     22 using syncer::SyncChange;
     23 using syncer::SyncChangeList;
     24 using syncer::SyncDataList;
     25 using syncer::SYNCED_NOTIFICATION_APP_INFO;
     26 using notifier::SyncedNotificationAppInfo;
     27 using notifier::SyncedNotificationAppInfoService;
     28 using sync_pb::SyncedNotificationAppInfoSpecifics;
     29 
     30 namespace notifier {
     31 
     32 // Extract app_info id from syncer::SyncData.
     33 std::string GetAppInfoId(const SyncData& sync_data) {
     34   SyncedNotificationAppInfoSpecifics specifics =
     35       sync_data.GetSpecifics().synced_notification_app_info();
     36 
     37   // TODO(petewil): It would be better if we had a designated unique identifier
     38   // instead of relying on the display name to be unique.
     39   return specifics.synced_notification_app_info(0).settings_display_name();
     40 }
     41 
     42 // Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
     43 // back up to Sync.
     44 class TestChangeProcessor : public syncer::SyncChangeProcessor {
     45  public:
     46   TestChangeProcessor() {}
     47   virtual ~TestChangeProcessor() {}
     48 
     49   // Store a copy of all the changes passed in so we can examine them later.
     50   virtual syncer::SyncError ProcessSyncChanges(
     51       const tracked_objects::Location& from_here,
     52       const SyncChangeList& change_list) OVERRIDE {
     53     change_map_.clear();
     54     for (SyncChangeList::const_iterator iter = change_list.begin();
     55          iter != change_list.end();
     56          ++iter) {
     57       // Put the data into the change tracking map.
     58       change_map_[GetAppInfoId(iter->sync_data())] = *iter;
     59     }
     60 
     61     return syncer::SyncError();
     62   }
     63 
     64   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type)
     65       const OVERRIDE {
     66     return syncer::SyncDataList();
     67   }
     68 
     69   size_t change_list_size() { return change_map_.size(); }
     70 
     71   bool ContainsId(const std::string& id) {
     72     return change_map_.find(id) != change_map_.end();
     73   }
     74 
     75   SyncChange GetChangeById(const std::string& id) {
     76     EXPECT_TRUE(ContainsId(id));
     77     return change_map_[id];
     78   }
     79 
     80  private:
     81   // Track the changes received in ProcessSyncChanges.
     82   std::map<std::string, SyncChange> change_map_;
     83 
     84   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
     85 };
     86 
     87 class SyncedNotificationAppInfoServiceTest : public testing::Test {
     88 
     89  public:
     90   SyncedNotificationAppInfoServiceTest()
     91       : sync_processor_(new TestChangeProcessor),
     92         sync_processor_delegate_(
     93             new syncer::FakeSyncChangeProcessor()) {}
     94 
     95   virtual ~SyncedNotificationAppInfoServiceTest() {}
     96 
     97   // Overrides from testing::Test.
     98   virtual void SetUp() { profile_.reset(new TestingProfile()); }
     99 
    100   // Introduce some sample test data into the system.
    101   void AddTestingAppInfosToList(
    102       SyncedNotificationAppInfoService* app_info_service) {
    103     // Create the app_info struct, setting the settings display name.
    104 
    105     // The sending_service_infos_ list will take ownership of this pointer.
    106     SyncedNotificationAppInfo* test_item1 = new SyncedNotificationAppInfo(
    107         NULL, kSendingService1Name, app_info_service);
    108 
    109     // Add some App IDs.
    110     test_item1->AddAppId(kAppId1);
    111     test_item1->AddAppId(kAppId2);
    112 
    113     // Set this icon GURL.
    114     test_item1->SetSettingsURLs(GURL(kTestIconUrl), GURL());
    115 
    116     // Add to the list.
    117     app_info_service->sending_service_infos_.push_back(test_item1);
    118 
    119     // Add a second test item for another service.
    120     SyncedNotificationAppInfo* test_item2 = new SyncedNotificationAppInfo(
    121         NULL, kSendingService2Name, app_info_service);
    122 
    123     // Add some App IDs.
    124     test_item2->AddAppId(kAppId4);
    125     test_item2->AddAppId(kAppId5);
    126 
    127     // Set thi icon GURL.
    128     test_item2->SetSettingsURLs(GURL(kTestIconUrl), GURL());
    129 
    130     // Add to the list.
    131     app_info_service->sending_service_infos_.push_back(test_item2);
    132   }
    133 
    134   // Put some representative test data into the AppInfo protobuf.
    135   static void FillProtobufWithTestData1(
    136       sync_pb::SyncedNotificationAppInfo& protobuf) {
    137     protobuf.add_app_id(std::string(kAppId1));
    138     protobuf.add_app_id(std::string(kAppId2));
    139     protobuf.set_settings_display_name(kSendingService1Name);
    140     protobuf.set_info_url(kTestInfoUrl);
    141     protobuf.mutable_icon()->set_url(kTestIconUrl);
    142   }
    143 
    144   static void FillProtobufWithTestData2(
    145       sync_pb::SyncedNotificationAppInfo& protobuf) {
    146     protobuf.add_app_id(std::string(kAppId3));
    147     protobuf.set_settings_display_name(kSendingService1Name);
    148     protobuf.mutable_icon()->set_url(kTestIconUrl);
    149   }
    150 
    151   // Helper to create syncer::SyncChange.
    152   static SyncChange CreateSyncChange(SyncChange::SyncChangeType type,
    153                                      const std::string& settings_display_name,
    154                                      const std::string& info_url,
    155                                      const std::string& icon_url,
    156                                      const std::string& app_id1,
    157                                      const std::string& app_id2) {
    158 
    159     return SyncChange(
    160         FROM_HERE,
    161         type,
    162         CreateSyncData(
    163             settings_display_name, info_url, icon_url, app_id1, app_id2));
    164   }
    165 
    166   // Build a SyncData object to look like what Sync would deliver.
    167   static SyncData CreateSyncData(const std::string& settings_display_name,
    168                                  const std::string& info_url,
    169                                  const std::string& icon_url,
    170                                  const std::string& app_id1,
    171                                  const std::string& app_id2) {
    172     // CreateLocalData makes a copy of this, so it can safely live on the stack.
    173     EntitySpecifics entity_specifics;
    174     EXPECT_FALSE(app_id1.empty());
    175 
    176     sync_pb::SyncedNotificationAppInfoSpecifics* specifics =
    177         entity_specifics.mutable_synced_notification_app_info();
    178 
    179     // Add a synced_notification_app_info object.
    180     specifics->add_synced_notification_app_info();
    181     sync_pb::SyncedNotificationAppInfo* app_info =
    182         specifics->mutable_synced_notification_app_info(0);
    183 
    184     // Add the key, the settings display name.
    185     app_info->set_settings_display_name(settings_display_name);
    186 
    187     // Add the welcome notification info URL.
    188     app_info->set_info_url(info_url);
    189 
    190     // Add the icon URL.
    191     app_info->mutable_icon()->set_url(icon_url);
    192 
    193     // Add the app IDs.
    194     app_info->add_app_id(app_id1);
    195 
    196     // Only add the second if it is non-empty
    197     if (!app_id2.empty()) {
    198       app_info->add_app_id(app_id2);
    199     }
    200 
    201     // Create the sync data.
    202     SyncData sync_data =
    203         SyncData::CreateLocalData("syncer::SYNCED_NOTIFICATION_APP_INFO",
    204                                   "SyncedNotificationAppInfoServiceUnitTest",
    205                                   entity_specifics);
    206 
    207     return sync_data;
    208   }
    209 
    210   TestChangeProcessor* processor() {
    211     return static_cast<TestChangeProcessor*>(sync_processor_.get());
    212   }
    213 
    214   scoped_ptr<syncer::SyncChangeProcessor> PassProcessor() {
    215     return sync_processor_delegate_.Pass();
    216   }
    217 
    218  protected:
    219   scoped_ptr<TestingProfile> profile_;
    220 
    221  private:
    222   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
    223   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_delegate_;
    224 
    225   DISALLOW_COPY_AND_ASSIGN(SyncedNotificationAppInfoServiceTest);
    226 };
    227 
    228 // Null data case - we have no data, and sync has no data when we start up.
    229 TEST_F(SyncedNotificationAppInfoServiceTest, MergeDataAndStartSyncingTest) {
    230     SyncedNotificationAppInfoService app_info_service(profile_.get());
    231 
    232   app_info_service.MergeDataAndStartSyncing(
    233       SYNCED_NOTIFICATION_APP_INFO,
    234       SyncDataList(),  // Empty.
    235       PassProcessor(),
    236       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
    237 
    238   EXPECT_EQ(static_cast<size_t>(0),
    239             app_info_service.sending_service_infos_size());
    240 }
    241 
    242 // Process sync changes when there is no local data.
    243 TEST_F(SyncedNotificationAppInfoServiceTest, ProcessSyncChangesEmptyModel) {
    244   // We initially have no data.
    245   SyncedNotificationAppInfoService app_info_service(profile_.get());
    246   app_info_service.set_avoid_bitmap_fetching_for_test(true);
    247 
    248   // Set up an ADD.
    249   SyncChangeList changes;
    250   changes.push_back(CreateSyncChange(SyncChange::ACTION_ADD,
    251                                      kSendingService1Name,
    252                                      kTestInfoUrl,
    253                                      kTestIconUrl,
    254                                      kAppId1,
    255                                      kAppId2));
    256 
    257   // Process the changes we built.
    258   app_info_service.ProcessSyncChanges(FROM_HERE, changes);
    259 
    260   // Verify sync change made it to the SyncedNotificationAppInfo list.
    261   SyncedNotificationAppInfo* app_info1 =
    262       app_info_service.FindSyncedNotificationAppInfoByName(
    263           kSendingService1Name);
    264   EXPECT_NE(static_cast<SyncedNotificationAppInfo*>(NULL), app_info1);
    265   EXPECT_TRUE(app_info1->HasAppId(kAppId1));
    266   EXPECT_TRUE(app_info1->HasAppId(kAppId2));
    267   EXPECT_FALSE(app_info1->HasAppId(kAppId3));
    268   EXPECT_EQ(app_info1->settings_icon_url(), GURL(kTestIconUrl));
    269 }
    270 
    271 // Process sync changes when there is local data.
    272 TEST_F(SyncedNotificationAppInfoServiceTest, ProcessSyncChangesNonEmptyModel) {
    273     SyncedNotificationAppInfoService app_info_service(profile_.get());
    274     app_info_service.set_avoid_bitmap_fetching_for_test(true);
    275 
    276   // Create some local fake data. We rely on the specific ids set up here.
    277   AddTestingAppInfosToList(&app_info_service);
    278 
    279   // Set up an UPDATE.
    280   SyncChangeList changes;
    281 
    282   changes.push_back(CreateSyncChange(SyncChange::ACTION_UPDATE,
    283                                      kSendingService1Name,
    284                                      kTestInfoUrl,
    285                                      kTestIconUrl,
    286                                      kAppId1,
    287                                      kAppId3));
    288 
    289   // Simulate incoming changed sync data at runtime.
    290   app_info_service.ProcessSyncChanges(FROM_HERE, changes);
    291 
    292   // We should find that the first item now has a different set of app ids.
    293   SyncedNotificationAppInfo* app_info1 =
    294       app_info_service.FindSyncedNotificationAppInfoByName(
    295           kSendingService1Name);
    296   EXPECT_NE(static_cast<SyncedNotificationAppInfo*>(NULL), app_info1);
    297   EXPECT_TRUE(app_info1->HasAppId(kAppId1));
    298   EXPECT_FALSE(app_info1->HasAppId(kAppId2));
    299   EXPECT_TRUE(app_info1->HasAppId(kAppId3));
    300   EXPECT_EQ(app_info1->settings_icon_url(), GURL(kTestIconUrl));
    301 }
    302 
    303 // Test ProcessIncomingAppInfoProtobuf with an add.
    304 TEST_F(SyncedNotificationAppInfoServiceTest,
    305        ProcessIncomingAppInfoProtobufAddTest) {
    306   // Get an app info service object.
    307   SyncedNotificationAppInfoService app_info_service(profile_.get());
    308   app_info_service.set_avoid_bitmap_fetching_for_test(true);
    309 
    310   // Get an app info protobuf.
    311   sync_pb::SyncedNotificationAppInfo protobuf;
    312   FillProtobufWithTestData1(protobuf);
    313 
    314   // Call the function we are testing.
    315   app_info_service.ProcessIncomingAppInfoProtobuf(protobuf);
    316 
    317   // Ensure that we now have an app_info in our list, and it looks like we
    318   // expect.
    319   notifier::SyncedNotificationAppInfo* found_app_info;
    320   found_app_info = app_info_service.FindSyncedNotificationAppInfoByName(
    321       kSendingService1Name);
    322   EXPECT_NE(static_cast<notifier::SyncedNotificationAppInfo*>(NULL),
    323             found_app_info);
    324   EXPECT_TRUE(found_app_info->HasAppId(kAppId1));
    325   EXPECT_TRUE(found_app_info->HasAppId(kAppId2));
    326 }
    327 
    328 // Test ProcessIncomingAppInfoProtobuf with an update
    329 TEST_F(SyncedNotificationAppInfoServiceTest,
    330        ProcessIncomingAppInfoProtobufUpdateTest) {
    331   // Get an app info service object.
    332   SyncedNotificationAppInfoService app_info_service(profile_.get());
    333   app_info_service.set_avoid_bitmap_fetching_for_test(true);
    334 
    335   // Make an app info with the same display name as the first one in the test
    336   // data.
    337   sync_pb::SyncedNotificationAppInfo protobuf1;
    338   FillProtobufWithTestData1(protobuf1);
    339   app_info_service.ProcessIncomingAppInfoProtobuf(protobuf1);
    340 
    341   // Ensure that we now have an app_info in our list, and it looks like we
    342   // expect.
    343   notifier::SyncedNotificationAppInfo* found_app_info1;
    344   found_app_info1 = app_info_service.FindSyncedNotificationAppInfoByName(
    345       kSendingService1Name);
    346   EXPECT_NE(static_cast<notifier::SyncedNotificationAppInfo*>(NULL),
    347             found_app_info1);
    348   EXPECT_TRUE(found_app_info1->HasAppId(kAppId1));
    349   EXPECT_TRUE(found_app_info1->HasAppId(kAppId2));
    350 
    351   // Make an update to the protobuf that has already been sent.
    352   app_info_service.FreeSyncedNotificationAppInfoByName(kSendingService1Name);
    353   // Change appid1 to appid3
    354   sync_pb::SyncedNotificationAppInfo protobuf2;
    355   FillProtobufWithTestData2(protobuf2);
    356   app_info_service.ProcessIncomingAppInfoProtobuf(protobuf2);
    357 
    358   // Ensure we have the same named app info as before, but it has the new
    359   // contents.
    360   notifier::SyncedNotificationAppInfo* found_app_info2;
    361   found_app_info2 = app_info_service.FindSyncedNotificationAppInfoByName(
    362       kSendingService1Name);
    363   EXPECT_NE(static_cast<notifier::SyncedNotificationAppInfo*>(NULL),
    364             found_app_info2);
    365   EXPECT_FALSE(found_app_info2->HasAppId(kAppId1));
    366   EXPECT_TRUE(found_app_info2->HasAppId(kAppId3));
    367 }
    368 
    369 // Test our function that creates a synced notification from a protobuf.
    370 TEST_F(SyncedNotificationAppInfoServiceTest,
    371        CreateSyncedNotificationAppInfoFromProtobufTest) {
    372   SyncedNotificationAppInfoService app_info_service(profile_.get());
    373   // Build a protobuf and fill it with data.
    374   sync_pb::SyncedNotificationAppInfo protobuf;
    375   FillProtobufWithTestData1(protobuf);
    376 
    377   scoped_ptr<SyncedNotificationAppInfo> app_info;
    378   app_info =
    379       app_info_service.CreateSyncedNotificationAppInfoFromProtobuf(protobuf);
    380 
    381   // Ensure the app info class has the fields we expect.
    382   EXPECT_EQ(std::string(kSendingService1Name),
    383             app_info->settings_display_name());
    384   EXPECT_EQ(GURL(kTestInfoUrl), app_info->welcome_link_url());
    385   EXPECT_TRUE(app_info->HasAppId(kAppId1));
    386   EXPECT_TRUE(app_info->HasAppId(kAppId2));
    387   EXPECT_EQ(GURL(std::string(kTestIconUrl)), app_info->settings_icon_url());
    388 }
    389 
    390 // Test our find by sending service name function.
    391 TEST_F(SyncedNotificationAppInfoServiceTest,
    392        FindSyncedNotificationAppInfoByNameTest) {
    393   SyncedNotificationAppInfoService app_info_service(profile_.get());
    394 
    395   AddTestingAppInfosToList(&app_info_service);
    396 
    397   SyncedNotificationAppInfo* found;
    398 
    399   found = app_info_service.FindSyncedNotificationAppInfoByName(
    400       kSendingService1Name);
    401 
    402   EXPECT_NE(static_cast<SyncedNotificationAppInfo*>(NULL), found);
    403   EXPECT_EQ(std::string(kSendingService1Name), found->settings_display_name());
    404 
    405   found = app_info_service.FindSyncedNotificationAppInfoByName(
    406       kSendingService3Name);
    407   EXPECT_EQ(NULL, found);
    408 }
    409 
    410 // Test our find by AppId function.
    411 TEST_F(SyncedNotificationAppInfoServiceTest,
    412        FindSyncedNotificationAppInfoByAppIdTest) {
    413   SyncedNotificationAppInfoService app_info_service(profile_.get());
    414 
    415   AddTestingAppInfosToList(&app_info_service);
    416 
    417   SyncedNotificationAppInfo* found;
    418 
    419   found = app_info_service.FindSyncedNotificationAppInfoByAppId(kAppId1);
    420 
    421   EXPECT_NE(static_cast<SyncedNotificationAppInfo*>(NULL), found);
    422   EXPECT_EQ(std::string(kSendingService1Name), found->settings_display_name());
    423 
    424   found = app_info_service.FindSyncedNotificationAppInfoByName(kAppId5);
    425   EXPECT_EQ(NULL, found);
    426 }
    427 
    428 // Test our find sending service name by app id function.
    429 TEST_F(SyncedNotificationAppInfoServiceTest,
    430        FindSendingServiceNameFromAppIdTest) {
    431   SyncedNotificationAppInfoService app_info_service(profile_.get());
    432 
    433   AddTestingAppInfosToList(&app_info_service);
    434 
    435   std::string found_name;
    436 
    437   found_name = app_info_service.FindSendingServiceNameFromAppId(kAppId1);
    438 
    439   EXPECT_EQ(std::string(kSendingService1Name), found_name);
    440 
    441   found_name = app_info_service.FindSendingServiceNameFromAppId(kAppId6);
    442   EXPECT_TRUE(found_name.empty());
    443 }
    444 
    445 // Test our delete function.
    446 TEST_F(SyncedNotificationAppInfoServiceTest,
    447        FreeSyncedNotificationAppInfoByNameTest) {
    448   SyncedNotificationAppInfoService app_info_service(profile_.get());
    449 
    450   AddTestingAppInfosToList(&app_info_service);
    451 
    452   SyncedNotificationAppInfo* found;
    453 
    454   app_info_service.FreeSyncedNotificationAppInfoByName(kSendingService1Name);
    455   found = app_info_service.FindSyncedNotificationAppInfoByName(
    456       kSendingService1Name);
    457   EXPECT_EQ(NULL, found);
    458 }
    459 
    460 TEST_F(SyncedNotificationAppInfoServiceTest,
    461        GetAllSendingServiceSettingsDataTest) {
    462   SyncedNotificationAppInfoService app_info_service(profile_.get());
    463 
    464   AddTestingAppInfosToList(&app_info_service);
    465 
    466   std::vector<SyncedNotificationSendingServiceSettingsData> data;
    467   data = app_info_service.GetAllSendingServiceSettingsData();
    468 
    469   EXPECT_EQ(static_cast<unsigned int>(2), data.size());
    470   EXPECT_EQ(kSendingService1Name, data[0].settings_display_name);
    471   EXPECT_EQ(kSendingService2Name, data[1].settings_display_name);
    472 }
    473 
    474 }  // namespace notifier
    475