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/metrics/variations/variations_service.h" 6 7 #include <vector> 8 9 #include "base/base64.h" 10 #include "base/prefs/testing_pref_service.h" 11 #include "base/sha1.h" 12 #include "base/strings/string_number_conversions.h" 13 #include "base/strings/string_util.h" 14 #include "chrome/browser/web_resource/resource_request_allowed_notifier_test_util.h" 15 #include "chrome/common/pref_names.h" 16 #include "chrome/test/base/testing_browser_process.h" 17 #include "chrome/test/base/testing_pref_service_syncable.h" 18 #include "components/variations/proto/study.pb.h" 19 #include "components/variations/proto/variations_seed.pb.h" 20 #include "content/public/test/test_browser_thread.h" 21 #include "net/base/url_util.h" 22 #include "net/http/http_response_headers.h" 23 #include "net/http/http_status_code.h" 24 #include "net/url_request/test_url_fetcher_factory.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 27 #if defined(OS_CHROMEOS) 28 #include "chrome/browser/chromeos/settings/cros_settings.h" 29 #include "chrome/browser/chromeos/settings/device_settings_service.h" 30 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h" 31 #endif 32 33 namespace chrome_variations { 34 35 namespace { 36 37 // A test class used to validate expected functionality in VariationsService. 38 class TestVariationsService : public VariationsService { 39 public: 40 TestVariationsService(TestRequestAllowedNotifier* test_notifier, 41 PrefService* local_state) 42 : VariationsService(test_notifier, local_state, NULL), 43 intercepts_fetch_(true), 44 fetch_attempted_(false), 45 seed_stored_(false) { 46 // Set this so StartRepeatedVariationsSeedFetch can be called in tests. 47 SetCreateTrialsFromSeedCalledForTesting(true); 48 } 49 50 virtual ~TestVariationsService() { 51 } 52 53 void set_intercepts_fetch(bool value) { 54 intercepts_fetch_ = value; 55 } 56 57 bool fetch_attempted() const { return fetch_attempted_; } 58 59 bool seed_stored() const { return seed_stored_; } 60 61 virtual void DoActualFetch() OVERRIDE { 62 if (intercepts_fetch_) { 63 fetch_attempted_ = true; 64 return; 65 } 66 67 VariationsService::DoActualFetch(); 68 } 69 70 protected: 71 virtual void StoreSeed(const std::string& seed_data, 72 const std::string& seed_signature, 73 const base::Time& date_fetched) OVERRIDE { 74 seed_stored_ = true; 75 } 76 77 private: 78 bool intercepts_fetch_; 79 bool fetch_attempted_; 80 bool seed_stored_; 81 82 DISALLOW_COPY_AND_ASSIGN(TestVariationsService); 83 }; 84 85 class TestVariationsServiceObserver : public VariationsService::Observer { 86 public: 87 TestVariationsServiceObserver() 88 : best_effort_changes_notified_(0), 89 crticial_changes_notified_(0) { 90 } 91 virtual ~TestVariationsServiceObserver() { 92 } 93 94 virtual void OnExperimentChangesDetected(Severity severity) OVERRIDE { 95 switch (severity) { 96 case BEST_EFFORT: 97 ++best_effort_changes_notified_; 98 break; 99 case CRITICAL: 100 ++crticial_changes_notified_; 101 break; 102 } 103 } 104 105 int best_effort_changes_notified() const { 106 return best_effort_changes_notified_; 107 } 108 109 int crticial_changes_notified() const { 110 return crticial_changes_notified_; 111 } 112 113 private: 114 // Number of notification received with BEST_EFFORT severity. 115 int best_effort_changes_notified_; 116 117 // Number of notification received with CRITICAL severity. 118 int crticial_changes_notified_; 119 120 DISALLOW_COPY_AND_ASSIGN(TestVariationsServiceObserver); 121 }; 122 123 // Populates |seed| with simple test data. The resulting seed will contain one 124 // study called "test", which contains one experiment called "abc" with 125 // probability weight 100. |seed|'s study field will be cleared before adding 126 // the new study. 127 variations::VariationsSeed CreateTestSeed() { 128 variations::VariationsSeed seed; 129 variations::Study* study = seed.add_study(); 130 study->set_name("test"); 131 study->set_default_experiment_name("abc"); 132 variations::Study_Experiment* experiment = study->add_experiment(); 133 experiment->set_name("abc"); 134 experiment->set_probability_weight(100); 135 seed.set_serial_number("123"); 136 return seed; 137 } 138 139 // Serializes |seed| to protobuf binary format. 140 std::string SerializeSeed(const variations::VariationsSeed& seed) { 141 std::string serialized_seed; 142 seed.SerializeToString(&serialized_seed); 143 return serialized_seed; 144 } 145 146 // Simulates a variations service response by setting a date header and the 147 // specified HTTP |response_code| on |fetcher|. 148 void SimulateServerResponse(int response_code, net::TestURLFetcher* fetcher) { 149 ASSERT_TRUE(fetcher); 150 scoped_refptr<net::HttpResponseHeaders> headers( 151 new net::HttpResponseHeaders("date:Wed, 13 Feb 2013 00:25:24 GMT\0\0")); 152 fetcher->set_response_headers(headers); 153 fetcher->set_response_code(response_code); 154 } 155 156 } // namespace 157 158 class VariationsServiceTest : public ::testing::Test { 159 protected: 160 VariationsServiceTest() {} 161 162 private: 163 #if defined(OS_CHROMEOS) 164 // Not used directly. Initializes CrosSettings for testing. 165 chromeos::ScopedTestDeviceSettingsService test_device_settings_service_; 166 chromeos::ScopedTestCrosSettings test_cros_settings_; 167 #endif 168 169 DISALLOW_COPY_AND_ASSIGN(VariationsServiceTest); 170 }; 171 172 #if !defined(OS_CHROMEOS) 173 TEST_F(VariationsServiceTest, VariationsURLIsValid) { 174 #if defined(OS_ANDROID) 175 // Android uses profile prefs as the PrefService to generate the URL. 176 TestingPrefServiceSyncable prefs; 177 VariationsService::RegisterProfilePrefs(prefs.registry()); 178 #else 179 TestingPrefServiceSimple prefs; 180 VariationsService::RegisterPrefs(prefs.registry()); 181 #endif 182 const std::string default_variations_url = 183 VariationsService::GetDefaultVariationsServerURLForTesting(); 184 185 std::string value; 186 GURL url = VariationsService::GetVariationsServerURL(&prefs); 187 EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true)); 188 EXPECT_FALSE(net::GetValueForKeyInQuery(url, "restrict", &value)); 189 190 prefs.SetString(prefs::kVariationsRestrictParameter, "restricted"); 191 url = VariationsService::GetVariationsServerURL(&prefs); 192 EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true)); 193 EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value)); 194 EXPECT_EQ("restricted", value); 195 } 196 #else 197 class VariationsServiceTestChromeOS : public VariationsServiceTest { 198 protected: 199 VariationsServiceTestChromeOS() {} 200 201 virtual void SetUp() OVERRIDE { 202 cros_settings_ = chromeos::CrosSettings::Get(); 203 DCHECK(cros_settings_ != NULL); 204 // Remove the real DeviceSettingsProvider and replace it with a stub that 205 // allows modifications in a test. 206 device_settings_provider_ = cros_settings_->GetProvider( 207 chromeos::kReportDeviceVersionInfo); 208 EXPECT_TRUE(device_settings_provider_ != NULL); 209 EXPECT_TRUE(cros_settings_->RemoveSettingsProvider( 210 device_settings_provider_)); 211 cros_settings_->AddSettingsProvider(&stub_settings_provider_); 212 } 213 214 virtual void TearDown() OVERRIDE { 215 // Restore the real DeviceSettingsProvider. 216 EXPECT_TRUE( 217 cros_settings_->RemoveSettingsProvider(&stub_settings_provider_)); 218 cros_settings_->AddSettingsProvider(device_settings_provider_); 219 } 220 221 void SetVariationsRestrictParameterPolicyValue(std::string value) { 222 cros_settings_->SetString(chromeos::kVariationsRestrictParameter, value); 223 } 224 225 private: 226 chromeos::CrosSettings* cros_settings_; 227 chromeos::StubCrosSettingsProvider stub_settings_provider_; 228 chromeos::CrosSettingsProvider* device_settings_provider_; 229 230 DISALLOW_COPY_AND_ASSIGN(VariationsServiceTestChromeOS); 231 }; 232 233 TEST_F(VariationsServiceTestChromeOS, VariationsURLIsValid) { 234 TestingPrefServiceSimple prefs; 235 VariationsService::RegisterPrefs(prefs.registry()); 236 const std::string default_variations_url = 237 VariationsService::GetDefaultVariationsServerURLForTesting(); 238 239 std::string value; 240 GURL url = VariationsService::GetVariationsServerURL(&prefs); 241 EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true)); 242 EXPECT_FALSE(net::GetValueForKeyInQuery(url, "restrict", &value)); 243 244 SetVariationsRestrictParameterPolicyValue("restricted"); 245 url = VariationsService::GetVariationsServerURL(&prefs); 246 EXPECT_TRUE(StartsWithASCII(url.spec(), default_variations_url, true)); 247 EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value)); 248 EXPECT_EQ("restricted", value); 249 } 250 #endif 251 252 TEST_F(VariationsServiceTest, VariationsURLHasOSNameParam) { 253 TestingPrefServiceSimple prefs; 254 VariationsService::RegisterPrefs(prefs.registry()); 255 const GURL url = VariationsService::GetVariationsServerURL(&prefs); 256 257 std::string value; 258 EXPECT_TRUE(net::GetValueForKeyInQuery(url, "osname", &value)); 259 EXPECT_FALSE(value.empty()); 260 } 261 262 TEST_F(VariationsServiceTest, RequestsInitiallyNotAllowed) { 263 base::MessageLoopForUI message_loop; 264 content::TestBrowserThread ui_thread(content::BrowserThread::UI, 265 &message_loop); 266 TestingPrefServiceSimple prefs; 267 VariationsService::RegisterPrefs(prefs.registry()); 268 269 // Pass ownership to TestVariationsService, but keep a weak pointer to 270 // manipulate it for this test. 271 TestRequestAllowedNotifier* test_notifier = new TestRequestAllowedNotifier; 272 TestVariationsService test_service(test_notifier, &prefs); 273 274 // Force the notifier to initially disallow requests. 275 test_notifier->SetRequestsAllowedOverride(false); 276 test_service.StartRepeatedVariationsSeedFetch(); 277 EXPECT_FALSE(test_service.fetch_attempted()); 278 279 test_notifier->NotifyObserver(); 280 EXPECT_TRUE(test_service.fetch_attempted()); 281 } 282 283 TEST_F(VariationsServiceTest, RequestsInitiallyAllowed) { 284 base::MessageLoopForUI message_loop; 285 content::TestBrowserThread ui_thread(content::BrowserThread::UI, 286 &message_loop); 287 TestingPrefServiceSimple prefs; 288 VariationsService::RegisterPrefs(prefs.registry()); 289 290 // Pass ownership to TestVariationsService, but keep a weak pointer to 291 // manipulate it for this test. 292 TestRequestAllowedNotifier* test_notifier = new TestRequestAllowedNotifier; 293 TestVariationsService test_service(test_notifier, &prefs); 294 295 test_notifier->SetRequestsAllowedOverride(true); 296 test_service.StartRepeatedVariationsSeedFetch(); 297 EXPECT_TRUE(test_service.fetch_attempted()); 298 } 299 300 TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) { 301 base::MessageLoop message_loop; 302 content::TestBrowserThread io_thread(content::BrowserThread::IO, 303 &message_loop); 304 TestingPrefServiceSimple prefs; 305 VariationsService::RegisterPrefs(prefs.registry()); 306 307 TestVariationsService service(new TestRequestAllowedNotifier, &prefs); 308 service.set_intercepts_fetch(false); 309 310 net::TestURLFetcherFactory factory; 311 service.DoActualFetch(); 312 313 net::TestURLFetcher* fetcher = factory.GetFetcherByID(0); 314 SimulateServerResponse(net::HTTP_OK, fetcher); 315 fetcher->SetResponseString(SerializeSeed(CreateTestSeed())); 316 317 EXPECT_FALSE(service.seed_stored()); 318 service.OnURLFetchComplete(fetcher); 319 EXPECT_TRUE(service.seed_stored()); 320 } 321 322 TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) { 323 const int non_ok_status_codes[] = { 324 net::HTTP_NO_CONTENT, 325 net::HTTP_NOT_MODIFIED, 326 net::HTTP_NOT_FOUND, 327 net::HTTP_INTERNAL_SERVER_ERROR, 328 net::HTTP_SERVICE_UNAVAILABLE, 329 }; 330 331 base::MessageLoop message_loop; 332 content::TestBrowserThread io_thread(content::BrowserThread::IO, 333 &message_loop); 334 TestingPrefServiceSimple prefs; 335 VariationsService::RegisterPrefs(prefs.registry()); 336 337 VariationsService service(new TestRequestAllowedNotifier, &prefs, NULL); 338 for (size_t i = 0; i < arraysize(non_ok_status_codes); ++i) { 339 net::TestURLFetcherFactory factory; 340 service.DoActualFetch(); 341 EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue()); 342 343 net::TestURLFetcher* fetcher = factory.GetFetcherByID(0); 344 SimulateServerResponse(non_ok_status_codes[i], fetcher); 345 service.OnURLFetchComplete(fetcher); 346 347 EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue()); 348 } 349 } 350 351 TEST_F(VariationsServiceTest, SeedDateUpdatedOn304Status) { 352 base::MessageLoop message_loop; 353 content::TestBrowserThread io_thread(content::BrowserThread::IO, 354 &message_loop); 355 TestingPrefServiceSimple prefs; 356 VariationsService::RegisterPrefs(prefs.registry()); 357 358 VariationsService service(new TestRequestAllowedNotifier, &prefs, NULL); 359 net::TestURLFetcherFactory factory; 360 service.DoActualFetch(); 361 EXPECT_TRUE( 362 prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue()); 363 364 net::TestURLFetcher* fetcher = factory.GetFetcherByID(0); 365 SimulateServerResponse(net::HTTP_NOT_MODIFIED, fetcher); 366 service.OnURLFetchComplete(fetcher); 367 EXPECT_FALSE( 368 prefs.FindPreference(prefs::kVariationsSeedDate)->IsDefaultValue()); 369 } 370 371 TEST_F(VariationsServiceTest, Observer) { 372 TestingPrefServiceSimple prefs; 373 VariationsService::RegisterPrefs(prefs.registry()); 374 VariationsService service(new TestRequestAllowedNotifier, &prefs, NULL); 375 376 struct { 377 int normal_count; 378 int best_effort_count; 379 int critical_count; 380 int expected_best_effort_notifications; 381 int expected_crtical_notifications; 382 } cases[] = { 383 {0, 0, 0, 0, 0}, 384 {1, 0, 0, 0, 0}, 385 {10, 0, 0, 0, 0}, 386 {0, 1, 0, 1, 0}, 387 {0, 10, 0, 1, 0}, 388 {0, 0, 1, 0, 1}, 389 {0, 0, 10, 0, 1}, 390 {0, 1, 1, 0, 1}, 391 {1, 1, 1, 0, 1}, 392 {1, 1, 0, 1, 0}, 393 {1, 0, 1, 0, 1}, 394 }; 395 396 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) { 397 TestVariationsServiceObserver observer; 398 service.AddObserver(&observer); 399 400 variations::VariationsSeedSimulator::Result result; 401 result.normal_group_change_count = cases[i].normal_count; 402 result.kill_best_effort_group_change_count = cases[i].best_effort_count; 403 result.kill_critical_group_change_count = cases[i].critical_count; 404 service.NotifyObservers(result); 405 406 EXPECT_EQ(cases[i].expected_best_effort_notifications, 407 observer.best_effort_changes_notified()) << i; 408 EXPECT_EQ(cases[i].expected_crtical_notifications, 409 observer.crticial_changes_notified()) << i; 410 411 service.RemoveObserver(&observer); 412 } 413 } 414 415 } // namespace chrome_variations 416
