search_unittest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
1// Copyright (c) 2013 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 "base/command_line.h" 6#include "base/metrics/field_trial.h" 7#include "base/metrics/histogram_base.h" 8#include "base/metrics/histogram_samples.h" 9#include "base/metrics/statistics_recorder.h" 10#include "base/prefs/pref_service.h" 11#include "chrome/browser/search/search.h" 12#include "chrome/browser/search_engines/template_url_service.h" 13#include "chrome/browser/search_engines/template_url_service_factory.h" 14#include "chrome/browser/ui/tabs/tab_strip_model.h" 15#include "chrome/common/chrome_switches.h" 16#include "chrome/common/metrics/entropy_provider.h" 17#include "chrome/common/pref_names.h" 18#include "chrome/common/url_constants.h" 19#include "chrome/test/base/browser_with_test_window_test.h" 20#include "chrome/test/base/ui_test_utils.h" 21#include "content/public/browser/web_contents.h" 22 23namespace chrome { 24 25TEST(EmbeddedSearchFieldTrialTest, GetFieldTrialInfo) { 26 FieldTrialFlags flags; 27 uint64 group_number = 0; 28 const uint64 ZERO = 0; 29 30 EXPECT_FALSE(GetFieldTrialInfo(std::string(), &flags, &group_number)); 31 EXPECT_EQ(ZERO, group_number); 32 EXPECT_EQ(ZERO, flags.size()); 33 34 EXPECT_TRUE(GetFieldTrialInfo("Group77", &flags, &group_number)); 35 EXPECT_EQ(uint64(77), group_number); 36 EXPECT_EQ(ZERO, flags.size()); 37 38 group_number = 0; 39 EXPECT_FALSE(GetFieldTrialInfo("Group77.2", &flags, &group_number)); 40 EXPECT_EQ(ZERO, group_number); 41 EXPECT_EQ(ZERO, flags.size()); 42 43 EXPECT_FALSE(GetFieldTrialInfo("Invalid77", &flags, &group_number)); 44 EXPECT_EQ(ZERO, group_number); 45 EXPECT_EQ(ZERO, flags.size()); 46 47 EXPECT_FALSE(GetFieldTrialInfo("Invalid77", &flags, NULL)); 48 EXPECT_EQ(ZERO, flags.size()); 49 50 EXPECT_TRUE(GetFieldTrialInfo("Group77 ", &flags, &group_number)); 51 EXPECT_EQ(uint64(77), group_number); 52 EXPECT_EQ(ZERO, flags.size()); 53 54 group_number = 0; 55 flags.clear(); 56 EXPECT_EQ(uint64(9999), GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); 57 EXPECT_TRUE(GetFieldTrialInfo("Group77 foo:6", &flags, &group_number)); 58 EXPECT_EQ(uint64(77), group_number); 59 EXPECT_EQ(uint64(1), flags.size()); 60 EXPECT_EQ(uint64(6), GetUInt64ValueForFlagWithDefault("foo", 9999, flags)); 61 62 group_number = 0; 63 flags.clear(); 64 EXPECT_TRUE(GetFieldTrialInfo( 65 "Group77 bar:1 baz:7 cat:dogs", &flags, &group_number)); 66 EXPECT_EQ(uint64(77), group_number); 67 EXPECT_EQ(uint64(3), flags.size()); 68 EXPECT_EQ(true, GetBoolValueForFlagWithDefault("bar", false, flags)); 69 EXPECT_EQ(uint64(7), GetUInt64ValueForFlagWithDefault("baz", 0, flags)); 70 EXPECT_EQ("dogs", 71 GetStringValueForFlagWithDefault("cat", std::string(), flags)); 72 EXPECT_EQ("default", 73 GetStringValueForFlagWithDefault("moose", "default", flags)); 74 75 group_number = 0; 76 flags.clear(); 77 EXPECT_FALSE(GetFieldTrialInfo( 78 "Group77 bar:1 baz:7 cat:dogs DISABLED", &flags, &group_number)); 79 EXPECT_EQ(ZERO, group_number); 80 EXPECT_EQ(ZERO, flags.size()); 81} 82 83class InstantExtendedAPIEnabledTest : public testing::Test { 84 public: 85 InstantExtendedAPIEnabledTest() : histogram_(NULL) { 86 } 87 protected: 88 virtual void SetUp() { 89 field_trial_list_.reset(new base::FieldTrialList( 90 new metrics::SHA1EntropyProvider("42"))); 91 base::StatisticsRecorder::Initialize(); 92 ResetInstantExtendedOptInStateGateForTest(); 93 previous_metrics_count_.resize(INSTANT_EXTENDED_OPT_IN_STATE_ENUM_COUNT, 0); 94 base::HistogramBase* histogram = GetHistogram(); 95 if (histogram) { 96 scoped_ptr<base::HistogramSamples> samples(histogram->SnapshotSamples()); 97 if (samples.get()) { 98 for (int state = INSTANT_EXTENDED_NOT_SET; 99 state < INSTANT_EXTENDED_OPT_IN_STATE_ENUM_COUNT; ++state) { 100 previous_metrics_count_[state] = samples->GetCount(state); 101 } 102 } 103 } 104 } 105 106 virtual CommandLine* GetCommandLine() const { 107 return CommandLine::ForCurrentProcess(); 108 } 109 110 void ValidateMetrics(base::HistogramBase::Sample value) { 111 base::HistogramBase* histogram = GetHistogram(); 112 if (histogram) { 113 scoped_ptr<base::HistogramSamples> samples(histogram->SnapshotSamples()); 114 if (samples.get()) { 115 for (int state = INSTANT_EXTENDED_NOT_SET; 116 state < INSTANT_EXTENDED_OPT_IN_STATE_ENUM_COUNT; ++state) { 117 if (state == value) { 118 EXPECT_EQ(previous_metrics_count_[state] + 1, 119 samples->GetCount(state)); 120 } else { 121 EXPECT_EQ(previous_metrics_count_[state], samples->GetCount(state)); 122 } 123 } 124 } 125 } 126 } 127 128 private: 129 base::HistogramBase* GetHistogram() { 130 if (!histogram_) { 131 histogram_ = base::StatisticsRecorder::FindHistogram( 132 "InstantExtended.OptInState"); 133 } 134 return histogram_; 135 } 136 base::HistogramBase* histogram_; 137 scoped_ptr<base::FieldTrialList> field_trial_list_; 138 std::vector<int> previous_metrics_count_; 139}; 140 141TEST_F(InstantExtendedAPIEnabledTest, EnabledViaCommandLineFlag) { 142 GetCommandLine()->AppendSwitch(switches::kEnableInstantExtendedAPI); 143 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 144 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 145#if defined(OS_IOS) || defined(OS_ANDROID) 146 EXPECT_EQ(1ul, EmbeddedSearchPageVersion()); 147#else 148 EXPECT_EQ(2ul, EmbeddedSearchPageVersion()); 149#endif 150 ValidateMetrics(INSTANT_EXTENDED_OPT_IN); 151} 152 153TEST_F(InstantExtendedAPIEnabledTest, EnabledViaFinchFlag) { 154 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 155 "InstantExtended/Group1 espv:42/")); 156 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 157 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 158 EXPECT_EQ(42ul, EmbeddedSearchPageVersion()); 159 ValidateMetrics(INSTANT_EXTENDED_NOT_SET); 160} 161 162TEST_F(InstantExtendedAPIEnabledTest, DisabledViaCommandLineFlag) { 163 GetCommandLine()->AppendSwitch(switches::kDisableInstantExtendedAPI); 164 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 165 "InstantExtended/Group1 espv:2/")); 166 EXPECT_FALSE(IsInstantExtendedAPIEnabled()); 167 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 168 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 169 ValidateMetrics(INSTANT_EXTENDED_OPT_OUT); 170} 171 172TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyEnabledViaCommandLineFlag) { 173 GetCommandLine()->AppendSwitch(switches::kEnableLocalOnlyInstantExtendedAPI); 174 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 175 EXPECT_TRUE(IsLocalOnlyInstantExtendedAPIEnabled()); 176 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 177 ValidateMetrics(INSTANT_EXTENDED_OPT_IN_LOCAL); 178} 179 180TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyEnabledViaFinch) { 181 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 182 "InstantExtended/Group1 local_only:1/")); 183 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 184 EXPECT_TRUE(IsLocalOnlyInstantExtendedAPIEnabled()); 185 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 186 ValidateMetrics(INSTANT_EXTENDED_NOT_SET); 187} 188 189TEST_F(InstantExtendedAPIEnabledTest, BothLocalAndRegularOptOutCommandLine) { 190 GetCommandLine()->AppendSwitch(switches::kDisableLocalOnlyInstantExtendedAPI); 191 GetCommandLine()->AppendSwitch(switches::kDisableInstantExtendedAPI); 192 EXPECT_FALSE(IsInstantExtendedAPIEnabled()); 193 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 194 ValidateMetrics(INSTANT_EXTENDED_OPT_OUT_BOTH); 195} 196 197TEST_F(InstantExtendedAPIEnabledTest, BothLocalAndRegularOptInCommandLine) { 198 GetCommandLine()->AppendSwitch(switches::kEnableLocalOnlyInstantExtendedAPI); 199 GetCommandLine()->AppendSwitch(switches::kEnableInstantExtendedAPI); 200 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 201 EXPECT_TRUE(IsLocalOnlyInstantExtendedAPIEnabled()); 202 ValidateMetrics(INSTANT_EXTENDED_OPT_IN_LOCAL); 203} 204 205TEST_F(InstantExtendedAPIEnabledTest, 206 LocalOnlyCommandLineTrumpedByCommandLine) { 207 GetCommandLine()->AppendSwitch(switches::kEnableLocalOnlyInstantExtendedAPI); 208 GetCommandLine()->AppendSwitch(switches::kDisableInstantExtendedAPI); 209 EXPECT_FALSE(IsInstantExtendedAPIEnabled()); 210 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 211 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 212 ValidateMetrics(INSTANT_EXTENDED_OPT_OUT); 213} 214 215TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyCommandLineTrumpsFinch) { 216 GetCommandLine()->AppendSwitch(switches::kEnableLocalOnlyInstantExtendedAPI); 217 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 218 "InstantExtended/Group1 espv:2/")); 219 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 220 EXPECT_TRUE(IsLocalOnlyInstantExtendedAPIEnabled()); 221 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 222 ValidateMetrics(INSTANT_EXTENDED_OPT_IN_LOCAL); 223} 224 225TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyFinchTrumpedByCommandLine) { 226 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 227 "InstantExtended/Group1 local_only:1/")); 228 GetCommandLine()->AppendSwitch(switches::kDisableInstantExtendedAPI); 229 EXPECT_FALSE(IsInstantExtendedAPIEnabled()); 230 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 231 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 232 ValidateMetrics(INSTANT_EXTENDED_OPT_OUT); 233} 234 235TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyFinchTrumpsFinch) { 236 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 237 "InstantExtended/Group1 espv:1 local_only:1/")); 238 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 239 EXPECT_TRUE(IsLocalOnlyInstantExtendedAPIEnabled()); 240 EXPECT_EQ(0ul, EmbeddedSearchPageVersion()); 241 ValidateMetrics(INSTANT_EXTENDED_NOT_SET); 242} 243 244TEST_F(InstantExtendedAPIEnabledTest, LocalOnlyDisabledViaCommandLineFlag) { 245 GetCommandLine()->AppendSwitch(switches::kDisableLocalOnlyInstantExtendedAPI); 246 ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString( 247 "InstantExtended/Group1 espv:2/")); 248 EXPECT_TRUE(IsInstantExtendedAPIEnabled()); 249 EXPECT_FALSE(IsLocalOnlyInstantExtendedAPIEnabled()); 250 EXPECT_EQ(2ul, EmbeddedSearchPageVersion()); 251 ValidateMetrics(INSTANT_EXTENDED_OPT_OUT_LOCAL); 252} 253 254class SearchTest : public BrowserWithTestWindowTest { 255 protected: 256 virtual void SetUp() OVERRIDE { 257 BrowserWithTestWindowTest::SetUp(); 258 TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse( 259 profile(), &TemplateURLServiceFactory::BuildInstanceFor); 260 TemplateURLService* template_url_service = 261 TemplateURLServiceFactory::GetForProfile(profile()); 262 ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service); 263 SetSearchProvider(false); 264 } 265 266 void SetSearchProvider(bool is_google) { 267 TemplateURLService* template_url_service = 268 TemplateURLServiceFactory::GetForProfile(profile()); 269 TemplateURLData data; 270 if (is_google) { 271 data.SetURL("http://www.google.com/"); 272 data.instant_url = "http://www.google.com/"; 273 } else { 274 data.SetURL("http://foo.com/url?bar={searchTerms}"); 275 data.instant_url = "http://foo.com/instant?" 276 "{google:omniboxStartMarginParameter}foo=foo#foo=foo"; 277 data.alternate_urls.push_back("http://foo.com/alt#quux={searchTerms}"); 278 data.search_terms_replacement_key = "strk"; 279 } 280 TemplateURL* template_url = new TemplateURL(profile(), data); 281 // Takes ownership of |template_url|. 282 template_url_service->Add(template_url); 283 template_url_service->SetDefaultSearchProvider(template_url); 284 } 285 286 // Build an Instant URL with or without a valid search terms replacement key 287 // as per |has_search_term_replacement_key|. Set that URL as the instant URL 288 // for the default search provider. 289 void SetDefaultInstantTemplateUrl(bool has_search_term_replacement_key) { 290 TemplateURLService* template_url_service = 291 TemplateURLServiceFactory::GetForProfile(profile()); 292 293 static const char kInstantURLWithStrk[] = 294 "http://foo.com/instant?foo=foo#foo=foo&strk"; 295 static const char kInstantURLNoStrk[] = 296 "http://foo.com/instant?foo=foo#foo=foo"; 297 298 TemplateURLData data; 299 data.SetURL("http://foo.com/url?bar={searchTerms}"); 300 data.instant_url = (has_search_term_replacement_key ? 301 kInstantURLWithStrk : kInstantURLNoStrk); 302 data.search_terms_replacement_key = "strk"; 303 304 TemplateURL* template_url = new TemplateURL(profile(), data); 305 // Takes ownership of |template_url|. 306 template_url_service->Add(template_url); 307 template_url_service->SetDefaultSearchProvider(template_url); 308 } 309 310}; 311 312struct SearchTestCase { 313 const char* url; 314 bool expected_result; 315 const char* comment; 316}; 317 318TEST_F(SearchTest, ShouldAssignURLToInstantRendererExtendedDisabled) { 319 const SearchTestCase kTestCases[] = { 320 {"chrome-search://foo/bar", true, ""}, 321 {"http://foo.com/instant", true, ""}, 322 {"http://foo.com/instant?foo=bar", true, ""}, 323 {"https://foo.com/instant", true, ""}, 324 {"https://foo.com/instant#foo=bar", true, ""}, 325 {"HtTpS://fOo.CoM/instant", true, ""}, 326 {"http://foo.com:80/instant", true, ""}, 327 {"invalid URL", false, "Invalid URL"}, 328 {"unknown://scheme/path", false, "Unknown scheme"}, 329 {"ftp://foo.com/instant", false, "Non-HTTP scheme"}, 330 {"http://sub.foo.com/instant", false, "Non-exact host"}, 331 {"http://foo.com:26/instant", false, "Non-default port"}, 332 {"http://foo.com/instant/bar", false, "Non-exact path"}, 333 {"http://foo.com/Instant", false, "Case sensitive path"}, 334 {"http://foo.com/", false, "Non-exact path"}, 335 {"https://foo.com/", false, "Non-exact path"}, 336 {"https://foo.com/url?strk", false, "Non-extended mode"}, 337 {"https://foo.com/alt?strk", false, "Non-extended mode"}, 338 }; 339 340 for (size_t i = 0; i < arraysize(kTestCases); ++i) { 341 const SearchTestCase& test = kTestCases[i]; 342 EXPECT_EQ(test.expected_result, 343 ShouldAssignURLToInstantRenderer(GURL(test.url), profile())) 344 << test.url << " " << test.comment; 345 } 346} 347 348TEST_F(SearchTest, ShouldAssignURLToInstantRendererExtendedEnabled) { 349 EnableInstantExtendedAPIForTesting(); 350 351 const SearchTestCase kTestCases[] = { 352 {chrome::kChromeSearchLocalNtpUrl, true, ""}, 353 {chrome::kChromeSearchLocalGoogleNtpUrl, true, ""}, 354 {"https://foo.com/instant?strk", true, ""}, 355 {"https://foo.com/instant#strk", true, ""}, 356 {"https://foo.com/instant?strk=0", true, ""}, 357 {"https://foo.com/url?strk", true, ""}, 358 {"https://foo.com/alt?strk", true, ""}, 359 {"http://foo.com/instant", false, "Non-HTTPS"}, 360 {"http://foo.com/instant?strk", false, "Non-HTTPS"}, 361 {"http://foo.com/instant?strk=1", false, "Non-HTTPS"}, 362 {"https://foo.com/instant", false, "No search terms replacement"}, 363 {"https://foo.com/?strk", false, "Non-exact path"}, 364 }; 365 366 for (size_t i = 0; i < arraysize(kTestCases); ++i) { 367 const SearchTestCase& test = kTestCases[i]; 368 EXPECT_EQ(test.expected_result, 369 ShouldAssignURLToInstantRenderer(GURL(test.url), profile())) 370 << test.url << " " << test.comment; 371 } 372} 373 374TEST_F(SearchTest, CoerceCommandLineURLToTemplateURL) { 375 TemplateURL* template_url = 376 TemplateURLServiceFactory::GetForProfile(profile())-> 377 GetDefaultSearchProvider(); 378 EXPECT_EQ( 379 GURL("https://foo.com/dev?bar=bar#bar=bar"), 380 CoerceCommandLineURLToTemplateURL( 381 GURL("http://myserver.com:9000/dev?bar=bar#bar=bar"), 382 template_url->instant_url_ref(), kDisableStartMargin)); 383} 384 385const SearchTestCase kInstantNTPTestCases[] = { 386 {"https://foo.com/instant?strk", true, "Valid Instant URL"}, 387 {"https://foo.com/instant#strk", true, "Valid Instant URL"}, 388 {"https://foo.com/url?strk", true, "Valid search URL"}, 389 {"https://foo.com/url#strk", true, "Valid search URL"}, 390 {"https://foo.com/alt?strk", true, "Valid alternative URL"}, 391 {"https://foo.com/alt#strk", true, "Valid alternative URL"}, 392 {"https://foo.com/url?strk&bar=", true, "No query terms"}, 393 {"https://foo.com/url?strk&q=abc", true, "No query terms key"}, 394 {"https://foo.com/url?strk#bar=abc", true, "Query terms key in ref"}, 395 {"https://foo.com/url?strk&bar=abc", false, "Has query terms"}, 396 {"http://foo.com/instant?strk=1", false, "Insecure URL"}, 397 {"https://foo.com/instant", false, "No search term replacement"}, 398 {"chrome://blank/", false, "Chrome scheme"}, 399 {"chrome-search://foo", false, "Chrome-search scheme"}, 400 {chrome::kChromeSearchLocalNtpUrl, true, "Local new tab page"}, 401 {chrome::kChromeSearchLocalGoogleNtpUrl, true, "Local new tab page"}, 402 {"https://bar.com/instant?strk=1", false, "Random non-search page"}, 403}; 404 405TEST_F(SearchTest, InstantNTPExtendedEnabled) { 406 EnableInstantExtendedAPIForTesting(); 407 AddTab(browser(), GURL("chrome://blank")); 408 for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) { 409 const SearchTestCase& test = kInstantNTPTestCases[i]; 410 NavigateAndCommitActiveTab(GURL(test.url)); 411 SetSearchProvider(test.url == chrome::kChromeSearchLocalGoogleNtpUrl); 412 const content::WebContents* contents = 413 browser()->tab_strip_model()->GetWebContentsAt(0); 414 EXPECT_EQ(test.expected_result, IsInstantNTP(contents)) 415 << test.url << " " << test.comment; 416 } 417} 418 419TEST_F(SearchTest, InstantNTPExtendedDisabled) { 420 AddTab(browser(), GURL("chrome://blank")); 421 for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) { 422 const SearchTestCase& test = kInstantNTPTestCases[i]; 423 NavigateAndCommitActiveTab(GURL(test.url)); 424 const content::WebContents* contents = 425 browser()->tab_strip_model()->GetWebContentsAt(0); 426 EXPECT_FALSE(IsInstantNTP(contents)) << test.url << " " << test.comment; 427 } 428} 429 430TEST_F(SearchTest, InstantNTPCustomNavigationEntry) { 431 EnableInstantExtendedAPIForTesting(); 432 AddTab(browser(), GURL("chrome://blank")); 433 for (size_t i = 0; i < arraysize(kInstantNTPTestCases); ++i) { 434 const SearchTestCase& test = kInstantNTPTestCases[i]; 435 NavigateAndCommitActiveTab(GURL(test.url)); 436 SetSearchProvider(test.url == chrome::kChromeSearchLocalGoogleNtpUrl); 437 content::WebContents* contents = 438 browser()->tab_strip_model()->GetWebContentsAt(0); 439 content::NavigationController& controller = contents->GetController(); 440 controller.SetTransientEntry( 441 controller.CreateNavigationEntry(GURL("chrome://blank"), 442 content::Referrer(), 443 content::PAGE_TRANSITION_LINK, 444 false, 445 std::string(), 446 contents->GetBrowserContext())); 447 // The active entry is chrome://blank and not an NTP. 448 EXPECT_FALSE(IsInstantNTP(contents)); 449 EXPECT_EQ(test.expected_result, 450 NavEntryIsInstantNTP(contents, 451 controller.GetLastCommittedEntry())) 452 << test.url << " " << test.comment; 453 } 454} 455 456TEST_F(SearchTest, GetInstantURLExtendedDisabled) { 457 // Instant is disabled, so no Instant URL. 458 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 459 460 // Enable Instant. 461 profile()->GetPrefs()->SetBoolean(prefs::kInstantEnabled, true); 462 EXPECT_EQ(GURL("http://foo.com/instant?foo=foo#foo=foo"), 463 GetInstantURL(profile(), kDisableStartMargin)); 464 465 // Override the Instant URL on the commandline. 466 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 467 switches::kInstantURL, 468 "http://myserver.com:9000/dev?bar=bar#bar=bar"); 469 EXPECT_EQ(GURL("http://myserver.com:9000/dev?bar=bar#bar=bar"), 470 GetInstantURL(profile(), kDisableStartMargin)); 471} 472 473TEST_F(SearchTest, GetInstantURLExtendedEnabled) { 474 EnableInstantExtendedAPIForTesting(); 475 476 // Instant is disabled, so no Instant URL. 477 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 478 479 // Enable Instant. Still no Instant URL because "strk" is missing. 480 profile()->GetPrefs()->SetBoolean(prefs::kInstantExtendedEnabled, true); 481 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 482 483 // Set an Instant URL with a valid search terms replacement key. 484 SetDefaultInstantTemplateUrl(true); 485 486 // Now there should be a valid Instant URL. Note the HTTPS "upgrade". 487 EXPECT_EQ(GURL("https://foo.com/instant?foo=foo#foo=foo&strk"), 488 GetInstantURL(profile(), kDisableStartMargin)); 489 490 // Enable suggest. No difference. 491 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true); 492 EXPECT_EQ(GURL("https://foo.com/instant?foo=foo#foo=foo&strk"), 493 GetInstantURL(profile(), kDisableStartMargin)); 494 495 // Disable Instant. No difference, because suggest is still enabled. 496 profile()->GetPrefs()->SetBoolean(prefs::kInstantExtendedEnabled, false); 497 EXPECT_EQ(GURL("https://foo.com/instant?foo=foo#foo=foo&strk"), 498 GetInstantURL(profile(), kDisableStartMargin)); 499 500 // Override the Instant URL on the commandline. Oops, forgot "strk". 501 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 502 switches::kInstantURL, 503 "http://myserver.com:9000/dev?bar=bar#bar=bar"); 504 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 505 506 // Override with "strk". For fun, put it in the query, instead of the ref. 507 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 508 switches::kInstantURL, 509 "http://myserver.com:9000/dev?bar=bar&strk#bar=bar"); 510 EXPECT_EQ(GURL("http://myserver.com:9000/dev?bar=bar&strk#bar=bar"), 511 GetInstantURL(profile(), kDisableStartMargin)); 512 513 // Disable suggest. No Instant URL. 514 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, false); 515 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 516} 517 518TEST_F(SearchTest, StartMarginCGI) { 519 // Instant is disabled, so no Instant URL. 520 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 521 522 // Enable Instant. No margin. 523 profile()->GetPrefs()->SetBoolean(prefs::kInstantEnabled, true); 524 EXPECT_EQ(GURL("http://foo.com/instant?foo=foo#foo=foo"), 525 GetInstantURL(profile(), kDisableStartMargin)); 526 527 // With start margin. 528 EXPECT_EQ(GURL("http://foo.com/instant?es_sm=10&foo=foo#foo=foo"), 529 GetInstantURL(profile(), 10)); 530} 531 532TEST_F(SearchTest, DefaultSearchProviderSupportsInstant) { 533 EnableInstantExtendedAPIForTesting(); 534 535 // Enable Instant. Still no Instant URL because "strk" is missing. 536 profile()->GetPrefs()->SetBoolean(prefs::kInstantExtendedEnabled, true); 537 538 // No default search provider support yet. 539 EXPECT_FALSE(DefaultSearchProviderSupportsInstant(profile())); 540 541 // Set an Instant URL with a valid search terms replacement key. 542 SetDefaultInstantTemplateUrl(true); 543 544 // Default search provider should now support instant. 545 EXPECT_TRUE(DefaultSearchProviderSupportsInstant(profile())); 546 // Enable suggest. No difference. 547 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true); 548 EXPECT_TRUE(DefaultSearchProviderSupportsInstant(profile())); 549 550 // Disable Instant. No difference. 551 profile()->GetPrefs()->SetBoolean(prefs::kInstantExtendedEnabled, false); 552 EXPECT_TRUE(DefaultSearchProviderSupportsInstant(profile())); 553 554 // Override the Instant URL on the commandline. Oops, forgot "strk". 555 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 556 switches::kInstantURL, 557 "http://myserver.com:9000/dev?bar=bar#bar=bar"); 558 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 559 560 // Check that command line overrides don't affect the default search provider. 561 EXPECT_TRUE(DefaultSearchProviderSupportsInstant(profile())); 562 563 // Disable suggest. No Instant URL. 564 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, false); 565 EXPECT_EQ(GURL(), GetInstantURL(profile(), kDisableStartMargin)); 566 // Even with suggest disabled, the default search provider still supports 567 // instant. 568 EXPECT_TRUE(DefaultSearchProviderSupportsInstant(profile())); 569 570 // Set an Instant URL with no valid search terms replacement key. 571 SetDefaultInstantTemplateUrl(false); 572 573 EXPECT_FALSE(DefaultSearchProviderSupportsInstant(profile())); 574} 575 576TEST_F(SearchTest, IsInstantCheckboxEnabledExtendedDisabled) { 577 // Enable suggest. 578 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true); 579 580 // Set an Instant URL with a valid search terms replacement key. 581 SetDefaultInstantTemplateUrl(true); 582 583 const char* pref_name = GetInstantPrefName(); 584 profile()->GetPrefs()->SetBoolean(pref_name, true); 585 586 EXPECT_TRUE(IsInstantCheckboxEnabled(profile())); 587 EXPECT_TRUE(IsInstantCheckboxChecked(profile())); 588 589 // Set an Instant URL with no valid search terms replacement key. 590 SetDefaultInstantTemplateUrl(false); 591 592 // For non-extended instant, the checkbox should still be enabled and checked. 593 EXPECT_TRUE(IsInstantCheckboxEnabled(profile())); 594 EXPECT_TRUE(IsInstantCheckboxChecked(profile())); 595 596 // Disable suggest. 597 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, false); 598 599 // With suggest off, the checkbox should now be disabled and unchecked. 600 EXPECT_FALSE(IsInstantCheckboxEnabled(profile())); 601 EXPECT_FALSE(IsInstantCheckboxChecked(profile())); 602} 603 604TEST_F(SearchTest, IsInstantCheckboxEnabledExtendedEnabled) { 605 // Enable instant extended. 606 EnableInstantExtendedAPIForTesting(); 607 608 // Enable suggest. 609 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true); 610 611 // Set an Instant URL with a valid search terms replacement key. 612 SetDefaultInstantTemplateUrl(true); 613 614 const char* pref_name = GetInstantPrefName(); 615 profile()->GetPrefs()->SetBoolean(pref_name, true); 616 617 EXPECT_TRUE(IsInstantCheckboxEnabled(profile())); 618 EXPECT_TRUE(IsInstantCheckboxChecked(profile())); 619 620 // Set an Instant URL with no valid search terms replacement key. 621 SetDefaultInstantTemplateUrl(false); 622 623 // For extended instant, the checkbox should now be disabled. 624 EXPECT_FALSE(IsInstantCheckboxEnabled(profile())); 625 626 // Disable suggest. 627 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, false); 628 629 EXPECT_FALSE(IsInstantCheckboxEnabled(profile())); 630 EXPECT_FALSE(IsInstantCheckboxChecked(profile())); 631 632 // Set an Instant URL with a search terms replacement key. 633 SetDefaultInstantTemplateUrl(true); 634 635 // Should still be disabled, since suggest is still off. 636 EXPECT_FALSE(IsInstantCheckboxEnabled(profile())); 637 638 profile()->GetPrefs()->SetBoolean(prefs::kSearchSuggestEnabled, true); 639 640 // Now that suggest is back on and the instant url is good, the checkbox 641 // should be enabled and checked again. 642 EXPECT_TRUE(IsInstantCheckboxEnabled(profile())); 643 EXPECT_TRUE(IsInstantCheckboxChecked(profile())); 644} 645 646 647} // namespace chrome 648