src/chrome/browser/sync/test/integration/search_engines_helper.cc

   1 // Copyright (c) 2012 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/sync/test/integration/search_engines_helper.h"
   6
   7 #include <vector>
   8
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/time/time.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/search_engines/template_url.h"
  15 #include "chrome/browser/search_engines/template_url_service.h"
  16 #include "chrome/browser/search_engines/template_url_service_factory.h"
  17 #include "chrome/browser/sync/profile_sync_service_harness.h"
  18 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
  19 #include "chrome/browser/sync/test/integration/sync_test.h"
  20
  21 using sync_datatype_helper::test;
  22
  23 namespace {
  24
  25 GUIDToTURLMap CreateGUIDToTURLMap(TemplateURLService* service) {
  26   CHECK(service);
  27
  28   GUIDToTURLMap map;
  29   TemplateURLService::TemplateURLVector turls = service->GetTemplateURLs();
  30   for (TemplateURLService::TemplateURLVector::iterator it = turls.begin();
  31        it != turls.end(); ++it) {
  32     CHECK(*it);
  33     CHECK(map.find((*it)->sync_guid()) == map.end());
  34     map[(*it)->sync_guid()] = *it;
  35   }
  36
  37   return map;
  38 }
  39
  40 std::string GetTURLInfoString(const TemplateURL* turl) {
  41   DCHECK(turl);
  42   return "TemplateURL: shortname: " + UTF16ToASCII(turl->short_name()) +
  43       " keyword: " + UTF16ToASCII(turl->keyword()) + " url: " + turl->url();
  44 }
  45
  46 bool TURLsMatch(const TemplateURL* turl1, const TemplateURL* turl2) {
  47   CHECK(turl1);
  48   CHECK(turl2);
  49   bool result = (turl1->url() == turl2->url()) &&
  50       (turl1->keyword() == turl2->keyword()) &&
  51       (turl1->short_name() == turl2->short_name());
  52
  53   // Print some useful debug info.
  54   if (!result) {
  55     LOG(ERROR) << "TemplateURLs did not match: " << GetTURLInfoString(turl1)
  56                << " vs " << GetTURLInfoString(turl2);
  57   }
  58
  59   return result;
  60 }
  61
  62 bool ServicesMatch(int profile_a, int profile_b) {
  63   TemplateURLService* service_a =
  64       search_engines_helper::GetServiceForBrowserContext(profile_a);
  65   TemplateURLService* service_b =
  66       search_engines_helper::GetServiceForBrowserContext(profile_b);
  67   CHECK(service_a);
  68   CHECK(service_b);
  69
  70   // Services that have synced should have identical TURLs, including the GUIDs.
  71   // Make sure we compare those fields in addition to the user-visible fields.
  72   GUIDToTURLMap a_turls = CreateGUIDToTURLMap(service_a);
  73   GUIDToTURLMap b_turls = CreateGUIDToTURLMap(service_b);
  74
  75   if (a_turls.size() != b_turls.size()) {
  76     LOG(ERROR) << "Service a and b do not match in size: " << a_turls.size()
  77                << " vs " << b_turls.size() << " respectively.";
  78     return false;
  79   }
  80
  81   for (GUIDToTURLMap::iterator it = a_turls.begin();
  82        it != a_turls.end(); ++it) {
  83     if (b_turls.find(it->first) == b_turls.end()) {
  84       LOG(ERROR) << "TURL GUID from a not found in b's TURLs: " << it->first;
  85       return false;
  86     }
  87     if (!TURLsMatch(b_turls[it->first], it->second))
  88       return false;
  89   }
  90
  91   const TemplateURL* default_a = service_a->GetDefaultSearchProvider();
  92   const TemplateURL* default_b = service_b->GetDefaultSearchProvider();
  93   CHECK(default_a);
  94   CHECK(default_b);
  95   if (!TURLsMatch(default_a, default_b)) {
  96     LOG(ERROR) << "Default search providers do not match: A's default: "
  97                << default_a->keyword() << " B's default: "
  98                << default_b->keyword();
  99     return false;
 100   } else {
 101     LOG(INFO) << "A had default with URL: " << default_a->url()
 102               << " and keyword: " << default_a->keyword();
 103   }
 104
 105   return true;
 106 }
 107
 108 // Convenience helper for consistently generating the same keyword for a given
 109 // seed.
 110 string16 CreateKeyword(int seed) {
 111   return ASCIIToUTF16(base::StringPrintf("test%d", seed));
 112 }
 113
 114 }  // namespace
 115
 116 namespace search_engines_helper {
 117
 118 TemplateURLService* GetServiceForBrowserContext(int profile_index) {
 119   return TemplateURLServiceFactory::GetForProfile(
 120       test()->GetProfile(profile_index));
 121 }
 122
 123 TemplateURLService* GetVerifierService() {
 124   return TemplateURLServiceFactory::GetForProfile(test()->verifier());
 125 }
 126
 127 bool ServiceMatchesVerifier(int profile_index) {
 128   TemplateURLService* verifier = GetVerifierService();
 129   TemplateURLService* other = GetServiceForBrowserContext(profile_index);
 130
 131   CHECK(verifier);
 132   CHECK(other);
 133
 134   TemplateURLService::TemplateURLVector verifier_turls =
 135       verifier->GetTemplateURLs();
 136   if (verifier_turls.size() != other->GetTemplateURLs().size()) {
 137     LOG(ERROR) << "Verifier and other service have a different count of TURLs: "
 138                << verifier_turls.size() << " vs "
 139                << other->GetTemplateURLs().size() << " respectively.";
 140     return false;
 141   }
 142
 143   for (size_t i = 0; i < verifier_turls.size(); ++i) {
 144     const TemplateURL* verifier_turl = verifier_turls.at(i);
 145     CHECK(verifier_turl);
 146     const TemplateURL* other_turl = other->GetTemplateURLForKeyword(
 147         verifier_turl->keyword());
 148
 149     if (!other_turl) {
 150       LOG(ERROR) << "The other service did not contain a TURL with keyword: "
 151                  << verifier_turl->keyword();
 152       return false;
 153     }
 154     if (!TURLsMatch(verifier_turl, other_turl))
 155       return false;
 156   }
 157
 158   return true;
 159 }
 160
 161 bool AllServicesMatch() {
 162   // Use 0 as the baseline.
 163   if (test()->use_verifier() && !ServiceMatchesVerifier(0)) {
 164     LOG(ERROR) << "TemplateURLService 0 does not match verifier.";
 165     return false;
 166   }
 167
 168   for (int it = 1; it < test()->num_clients(); ++it) {
 169     if (!ServicesMatch(0, it)) {
 170       LOG(ERROR) << "TemplateURLService " << it << " does not match with "
 171                  << "service 0.";
 172       return false;
 173     }
 174   }
 175   return true;
 176 }
 177
 178 TemplateURL* CreateTestTemplateURL(Profile* profile, int seed) {
 179   return CreateTestTemplateURL(profile, seed, CreateKeyword(seed),
 180                                base::StringPrintf("0000-0000-0000-%04d", seed));
 181 }
 182
 183 TemplateURL* CreateTestTemplateURL(Profile* profile,
 184                                    int seed,
 185                                    const string16& keyword,
 186                                    const std::string& sync_guid) {
 187   return CreateTestTemplateURL(profile, seed, keyword,
 188       base::StringPrintf("http://www.test%d.com/", seed), sync_guid);
 189 }
 190
 191 TemplateURL* CreateTestTemplateURL(Profile* profile,
 192                                    int seed,
 193                                    const string16& keyword,
 194                                    const std::string& url,
 195                                    const std::string& sync_guid) {
 196   TemplateURLData data;
 197   data.short_name = CreateKeyword(seed);
 198   data.SetKeyword(keyword);
 199   data.SetURL(url);
 200   data.favicon_url = GURL("http://favicon.url");
 201   data.safe_for_autoreplace = true;
 202   data.date_created = base::Time::FromTimeT(100);
 203   data.last_modified = base::Time::FromTimeT(100);
 204   data.prepopulate_id = 999999;
 205   data.sync_guid = sync_guid;
 206   return new TemplateURL(profile, data);
 207 }
 208
 209 void AddSearchEngine(int profile_index, int seed) {
 210   Profile* profile = test()->GetProfile(profile_index);
 211   TemplateURLServiceFactory::GetForProfile(profile)->Add(
 212       CreateTestTemplateURL(profile, seed));
 213   if (test()->use_verifier())
 214     GetVerifierService()->Add(CreateTestTemplateURL(profile, seed));
 215 }
 216
 217 void EditSearchEngine(int profile_index,
 218                       const string16& keyword,
 219                       const string16& short_name,
 220                       const string16& new_keyword,
 221                       const std::string& url) {
 222   DCHECK(!url.empty());
 223   TemplateURLService* service = GetServiceForBrowserContext(profile_index);
 224   TemplateURL* turl = service->GetTemplateURLForKeyword(keyword);
 225   EXPECT_TRUE(turl);
 226   ASSERT_FALSE(new_keyword.empty());
 227   service->ResetTemplateURL(turl, short_name, new_keyword, url);
 228   // Make sure we do the same on the verifier.
 229   if (test()->use_verifier()) {
 230     TemplateURL* verifier_turl =
 231         GetVerifierService()->GetTemplateURLForKeyword(keyword);
 232     EXPECT_TRUE(verifier_turl);
 233     GetVerifierService()->ResetTemplateURL(verifier_turl, short_name,
 234                                            new_keyword, url);
 235   }
 236 }
 237
 238 void DeleteSearchEngineBySeed(int profile_index, int seed) {
 239   TemplateURLService* service = GetServiceForBrowserContext(profile_index);
 240   string16 keyword(CreateKeyword(seed));
 241   TemplateURL* turl = service->GetTemplateURLForKeyword(keyword);
 242   EXPECT_TRUE(turl);
 243   service->Remove(turl);
 244   // Make sure we do the same on the verifier.
 245   if (test()->use_verifier()) {
 246     TemplateURL* verifier_turl =
 247         GetVerifierService()->GetTemplateURLForKeyword(keyword);
 248     EXPECT_TRUE(verifier_turl);
 249     GetVerifierService()->Remove(verifier_turl);
 250   }
 251 }
 252
 253 void ChangeDefaultSearchProvider(int profile_index, int seed) {
 254   TemplateURLService* service = GetServiceForBrowserContext(profile_index);
 255   ASSERT_TRUE(service);
 256   TemplateURL* turl = service->GetTemplateURLForKeyword(CreateKeyword(seed));
 257   ASSERT_TRUE(turl);
 258   service->SetDefaultSearchProvider(turl);
 259   if (test()->use_verifier()) {
 260     TemplateURL* verifier_turl =
 261         GetVerifierService()->GetTemplateURLForKeyword(CreateKeyword(seed));
 262     ASSERT_TRUE(verifier_turl);
 263     GetVerifierService()->SetDefaultSearchProvider(verifier_turl);
 264   }
 265 }
 266
 267 }  // namespace search_engines_helper