Support VariationsRestrictParameter in VariationsService for Chrome OS

chrome/browser/metrics/variations/variations_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 <vector>
 
 #include "base/base64.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/metrics/proto/study.pb.h"
 #include "chrome/browser/metrics/variations/resource_request_allowed_notifier_test_util.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
+#endif
+
 namespace chrome_variations {
 
 namespace {
 
 // A test class used to validate expected functionality in VariationsService.
 class TestVariationsService : public VariationsService {
  public:
   TestVariationsService(TestRequestAllowedNotifier* test_notifier,
                         PrefService* local_state)
       : VariationsService(test_notifier, local_state),
@@ skipping 59 matching lines @@
 void SimulateServerResponse(int response_code, net::TestURLFetcher* fetcher) {
   ASSERT_TRUE(fetcher);
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders("date:Wed, 13 Feb 2013 00:25:24 GMT\0\0"));
   fetcher->set_response_headers(headers);
   fetcher->set_response_code(response_code);
 }
 
 }  // namespace
 
-TEST(VariationsServiceTest, CheckStudyChannel) {
+class VariationsServiceTest : public testing::Test {
+ protected:
+  VariationsServiceTest() {}
+
+ private:
+#if defined(OS_CHROMEOS)
+  // Not used directly. Initializes CrosSettings for testing.
+  chromeos::ScopedTestCrosSettings scoped_test_cros_settings;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(VariationsServiceTest);
+};
+
+TEST_F(VariationsServiceTest, CheckStudyChannel) {
   const chrome::VersionInfo::Channel channels[] = {
     chrome::VersionInfo::CHANNEL_CANARY,
     chrome::VersionInfo::CHANNEL_DEV,
     chrome::VersionInfo::CHANNEL_BETA,
     chrome::VersionInfo::CHANNEL_STABLE,
   };
   const Study_Channel study_channels[] = {
     Study_Channel_CANARY,
     Study_Channel_DEV,
     Study_Channel_BETA,
@@ skipping 32 matching lines @@
     }
 
     if (i < arraysize(study_channels)) {
       const int index = arraysize(study_channels) - i - 1;
       filter.add_channel(study_channels[index]);
       channel_added[index] = true;
     }
   }
 }
 
-TEST(VariationsServiceTest, CheckStudyLocale) {
+TEST_F(VariationsServiceTest, CheckStudyLocale) {
   struct {
     const char* filter_locales;
     bool en_us_result;
     bool en_ca_result;
     bool fr_result;
   } test_cases[] = {
     {"en-US", true, false, false},
     {"en-US,en-CA,fr", true, true, true},
     {"en-US,en-CA,en-GB", true, true, false},
     {"en-GB,en-CA,en-US", true, true, false},
@@ skipping 10 matching lines @@
       filter.add_locale(filter_locales[j]);
     EXPECT_EQ(test_cases[i].en_us_result,
               VariationsService::CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               VariationsService::CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
               VariationsService::CheckStudyLocale(filter, "fr"));
   }
 }
 
-TEST(VariationsServiceTest, CheckStudyPlatform) {
+TEST_F(VariationsServiceTest, CheckStudyPlatform) {
   const Study_Platform platforms[] = {
     Study_Platform_PLATFORM_WINDOWS,
     Study_Platform_PLATFORM_MAC,
     Study_Platform_PLATFORM_LINUX,
     Study_Platform_PLATFORM_CHROMEOS,
     Study_Platform_PLATFORM_ANDROID,
     Study_Platform_PLATFORM_IOS,
   };
   ASSERT_EQ(Study_Platform_Platform_ARRAYSIZE,
             static_cast<int>(arraysize(platforms)));
@@ skipping 29 matching lines @@
     }
 
     if (i < arraysize(platforms)) {
       const int index = arraysize(platforms) - i - 1;
       filter.add_platform(platforms[index]);
       platform_added[index] = true;
     }
   }
 }
 
-TEST(VariationsServiceTest, CheckStudyVersion) {
+TEST_F(VariationsServiceTest, CheckStudyVersion) {
   const struct {
     const char* min_version;
     const char* version;
     bool expected_result;
   } min_test_cases[] = {
     { "1.2.2", "1.2.3", true },
     { "1.2.3", "1.2.3", true },
     { "1.2.4", "1.2.3", false },
     { "1.3.2", "1.2.3", false },
     { "2.1.2", "1.2.3", false },
@@ skipping 66 matching lines @@
       if (!max_test_cases[j].expected_result) {
         const bool result =
             VariationsService::CheckStudyVersion(filter,
                                                  max_test_cases[j].version);
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
     }
   }
 }
 
-TEST(VariationsServiceTest, CheckStudyStartDate) {
+TEST_F(VariationsServiceTest, CheckStudyStartDate) {
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time start_date;
     bool expected_result;
   } start_test_cases[] = {
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study_Filter filter;
 
   // Start date not set should result in true.
   EXPECT_TRUE(VariationsService::CheckStudyStartDate(filter, now));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(start_test_cases); ++i) {
     filter.set_start_date(TimeToProtoTime(start_test_cases[i].start_date));
     const bool result = VariationsService::CheckStudyStartDate(filter, now);
     EXPECT_EQ(start_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
-TEST(VariationsServiceTest, IsStudyExpired) {
+TEST_F(VariationsServiceTest, IsStudyExpired) {
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time expiry_date;
     bool expected_result;
   } expiry_test_cases[] = {
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study study;
 
   // Expiry date not set should result in false.
   EXPECT_FALSE(VariationsService::IsStudyExpired(study, now));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(expiry_test_cases); ++i) {
     study.set_expiry_date(TimeToProtoTime(expiry_test_cases[i].expiry_date));
     const bool result = VariationsService::IsStudyExpired(study, now);
     EXPECT_EQ(expiry_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
-TEST(VariationsServiceTest, VariationsURLIsValid) {
+#if !defined(OS_CHROMEOS)
+TEST_F(VariationsServiceTest, VariationsURLIsValid) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   const std::string default_variations_url =
       VariationsService::GetDefaultVariationsServerURLForTesting();
 
   EXPECT_EQ(default_variations_url,
             VariationsService::GetVariationsServerURL(&prefs).spec());
 
   prefs.SetString(prefs::kVariationsRestrictParameter, "restricted");
   EXPECT_EQ(default_variations_url + "?restrict=restricted",
             VariationsService::GetVariationsServerURL(&prefs).spec());
 }
+#else
+class VariationsServiceTestChromeOS : public VariationsServiceTest {
+ protected:
+  VariationsServiceTestChromeOS() {}
 
-TEST(VariationsServiceTest, LoadSeed) {
+  virtual void SetUp() OVERRIDE {
+    cros_settings_ = chromeos::CrosSettings::Get();
+    DCHECK(cros_settings_ != NULL);
+    // Remove the real DeviceSettingsProvider and replace it with a stub that
+    // allows modifications in a test.
+    device_settings_provider_ = cros_settings_->GetProvider(
+        chromeos::kReportDeviceVersionInfo);
+    EXPECT_TRUE(device_settings_provider_ != NULL);
+    EXPECT_TRUE(cros_settings_->RemoveSettingsProvider(
+        device_settings_provider_));
+    cros_settings_->AddSettingsProvider(&stub_settings_provider_);
+  }
+
+  virtual void TearDown() OVERRIDE {
+    // Restore the real DeviceSettingsProvider.
+    EXPECT_TRUE(
+        cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
+    cros_settings_->AddSettingsProvider(device_settings_provider_);
+  }
+
+  chromeos::CrosSettings* cros_settings_;
+
+ private:
+  chromeos::StubCrosSettingsProvider stub_settings_provider_;
+  chromeos::CrosSettingsProvider* device_settings_provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(VariationsServiceTestChromeOS);
+};
+
+TEST_F(VariationsServiceTestChromeOS, VariationsURLIsValid) {
+  TestingPrefServiceSimple prefs;
+  VariationsService::RegisterPrefs(prefs.registry());
+  const std::string default_variations_url =
+      VariationsService::GetDefaultVariationsServerURLForTesting();
+
+  EXPECT_EQ(default_variations_url,
+            VariationsService::GetVariationsServerURL(&prefs).spec());
+
+  cros_settings_->SetString(chromeos::kVariationsRestrictParameter,
+                           "restricted");
+  EXPECT_EQ(default_variations_url + "?restrict=restricted",
+            VariationsService::GetVariationsServerURL(&prefs).spec());
+}
+#endif
+
+TEST_F(VariationsServiceTest, LoadSeed) {
   // Store good seed data to test if loading from prefs works.
   const TrialsSeed seed = CreateTestSeed();
   const std::string base64_seed = SerializeSeedBase64(seed);
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   prefs.SetString(prefs::kVariationsSeed, base64_seed);
 
   TestVariationsService variations_service(new TestRequestAllowedNotifier,
                                            &prefs);
@@ skipping 11 matching lines @@
   prefs.SetString(prefs::kVariationsSeed, "this should fail");
   EXPECT_FALSE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   EXPECT_FALSE(variations_service.LoadTrialsSeedFromPref(&prefs, &loaded_seed));
   EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
   // Check that having no seed in prefs results in a return value of false.
   prefs.ClearPref(prefs::kVariationsSeed);
   EXPECT_FALSE(variations_service.LoadTrialsSeedFromPref(&prefs, &loaded_seed));
 }
 
-TEST(VariationsServiceTest, StoreSeed) {
+TEST_F(VariationsServiceTest, StoreSeed) {
   const base::Time now = base::Time::Now();
   const TrialsSeed seed = CreateTestSeed();
   const std::string serialized_seed = SerializeSeed(seed);
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService variations_service(new TestRequestAllowedNotifier,
                                            &prefs);
 
   EXPECT_TRUE(variations_service.StoreSeedData(serialized_seed, now, &prefs));
   // Make sure the pref was actually set.
   EXPECT_FALSE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
   std::string loaded_serialized_seed = prefs.GetString(prefs::kVariationsSeed);
   std::string decoded_serialized_seed;
   ASSERT_TRUE(base::Base64Decode(loaded_serialized_seed,
                                  &decoded_serialized_seed));
   // Make sure the stored seed from pref is the same as the seed we created.
   EXPECT_EQ(serialized_seed, decoded_serialized_seed);
 
   // Check if trying to store a bad seed leaves the pref unchanged.
   prefs.ClearPref(prefs::kVariationsSeed);
   EXPECT_FALSE(variations_service.StoreSeedData("should fail", now, &prefs));
   EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 }
 
-TEST(VariationsServiceTest, ValidateStudy) {
+TEST_F(VariationsServiceTest, ValidateStudy) {
   Study study;
   study.set_default_experiment_name("def");
 
   Study_Experiment* experiment = study.add_experiment();
   experiment->set_name("abc");
   experiment->set_probability_weight(100);
 
   Study_Experiment* default_group = study.add_experiment();
   default_group->set_name("def");
   default_group->set_probability_weight(200);
@@ skipping 53 matching lines @@
       &total_probability);
   ASSERT_TRUE(valid);
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 }
 
-TEST(VariationsServiceTest, RequestsInitiallyNotAllowed) {
+TEST_F(VariationsServiceTest, RequestsInitiallyNotAllowed) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   TestRequestAllowedNotifier* test_notifier = new TestRequestAllowedNotifier;
   TestVariationsService test_service(test_notifier, &prefs);
 
   // Force the notifier to initially disallow requests.
   test_notifier->SetRequestsAllowedOverride(false);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_FALSE(test_service.fetch_attempted());
 
   test_notifier->NotifyObserver();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
-TEST(VariationsServiceTest, RequestsInitiallyAllowed) {
+TEST_F(VariationsServiceTest, RequestsInitiallyAllowed) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   TestRequestAllowedNotifier* test_notifier = new TestRequestAllowedNotifier;
   TestVariationsService test_service(test_notifier, &prefs);
 
   test_notifier->SetRequestsAllowedOverride(true);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
-TEST(VariationsServiceTest, SeedStoredWhenOKStatus) {
+TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   MessageLoop message_loop;
   content::TestBrowserThread io_thread(content::BrowserThread::IO,
                                        &message_loop);
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   VariationsService variations_service(new TestRequestAllowedNotifier, &prefs);
 
   net::TestURLFetcherFactory factory;
   variations_service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   SimulateServerResponse(net::HTTP_OK, fetcher);
   const TrialsSeed seed = CreateTestSeed();
   fetcher->SetResponseString(SerializeSeed(seed));
 
   EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   variations_service.OnURLFetchComplete(fetcher);
   EXPECT_FALSE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   EXPECT_EQ(SerializeSeedBase64(seed), prefs.GetString(prefs::kVariationsSeed));
 }
 
-TEST(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
+TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
   const int non_ok_status_codes[] = {
     net::HTTP_NO_CONTENT,
     net::HTTP_NOT_MODIFIED,
     net::HTTP_NOT_FOUND,
     net::HTTP_INTERNAL_SERVER_ERROR,
     net::HTTP_SERVICE_UNAVAILABLE,
   };
 
   MessageLoop message_loop;
   content::TestBrowserThread io_thread(content::BrowserThread::IO,
                                        &message_loop);
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   VariationsService variations_service(new TestRequestAllowedNotifier, &prefs);
   for (size_t i = 0; i < arraysize(non_ok_status_codes); ++i) {
     net::TestURLFetcherFactory factory;
     variations_service.DoActualFetch();
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
     net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
     SimulateServerResponse(non_ok_status_codes[i], fetcher);
     variations_service.OnURLFetchComplete(fetcher);
 
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   }
 }
 
 }  // namespace chrome_variations