[Variations] Refactor all state used for study filtering into a container struct.

components/variations/study_filtering_unittest.cc

 // Copyright 2014 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 "components/variations/study_filtering.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
+#include "components/variations/client_filterable_state.h"
 #include "components/variations/processed_study.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace variations {
 
 namespace {
 
 // Converts |time| to Study proto format.
 int64_t TimeToProtoTime(const base::Time& time) {
   return (time - base::Time::UnixEpoch()).InSeconds();
 }
 
 // Adds an experiment to |study| with the specified |name| and |probability|.
-Study_Experiment* AddExperiment(const std::string& name, int probability,
-                                Study* study) {
-  Study_Experiment* experiment = study->add_experiment();
+Study::Experiment* AddExperiment(const std::string& name,
+                                 int probability,
+                                 Study* study) {
+  Study::Experiment* experiment = study->add_experiment();
   experiment->set_name(name);
   experiment->set_probability_weight(probability);
   return experiment;
 }
 
 }  // namespace
 
 TEST(VariationsStudyFilteringTest, CheckStudyChannel) {
-  const Study_Channel channels[] = {
-    Study_Channel_CANARY,
-    Study_Channel_DEV,
-    Study_Channel_BETA,
-    Study_Channel_STABLE,
+  const Study::Channel channels[] = {
+      Study::CANARY, Study::DEV, Study::BETA, Study::STABLE,
   };
   bool channel_added[arraysize(channels)] = { 0 };
 
-  Study_Filter filter;
+  Study::Filter filter;
 
   // Check in the forwarded order. The loop cond is <= arraysize(channels)
   // instead of < so that the result of adding the last channel gets checked.
   for (size_t i = 0; i <= arraysize(channels); ++i) {
     for (size_t j = 0; j < arraysize(channels); ++j) {
       const bool expected = channel_added[j] || filter.channel_size() == 0;
       const bool result = internal::CheckStudyChannel(filter, channels[j]);
       EXPECT_EQ(expected, result) << "Case " << i << "," << j << " failed!";
     }
 
@@ skipping 15 matching lines @@
 
     if (i < arraysize(channels)) {
       const int index = arraysize(channels) - i - 1;
       filter.add_channel(channels[index]);
       channel_added[index] = true;
     }
   }
 }
 
 TEST(VariationsStudyFilteringTest, CheckStudyFormFactor) {
-  const Study_FormFactor form_factors[] = {
-    Study_FormFactor_DESKTOP,
-    Study_FormFactor_PHONE,
-    Study_FormFactor_TABLET,
-    Study_FormFactor_KIOSK,
+  const Study::FormFactor form_factors[] = {
+      Study::DESKTOP, Study::PHONE, Study::TABLET, Study::KIOSK,
   };
 
-  ASSERT_EQ(Study_FormFactor_FormFactor_ARRAYSIZE,
+  ASSERT_EQ(Study::FormFactor_ARRAYSIZE,
             static_cast<int>(arraysize(form_factors)));
 
   bool form_factor_added[arraysize(form_factors)] = { 0 };
-  Study_Filter filter;
+  Study::Filter filter;
 
   for (size_t i = 0; i <= arraysize(form_factors); ++i) {
     for (size_t j = 0; j < arraysize(form_factors); ++j) {
       const bool expected = form_factor_added[j] ||
                             filter.form_factor_size() == 0;
       const bool result = internal::CheckStudyFormFactor(filter,
                                                          form_factors[j]);
       EXPECT_EQ(expected, result) << "form_factor: case " << i << "," << j
                                   << " failed!";
     }
@@ skipping 84 matching lines @@
       {"", "", true, true, true},
       {"", "en-US", false, true, true},
       {"", "en-US,en-CA,fr", false, false, false},
       {"", "en-US,en-CA,en-GB", false, false, true},
       {"", "en-GB,en-CA,en-US", false, false, true},
       {"", "ja,kr,vi", true, true, true},
       {"", "fr-CA", true, true, true},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    Study_Filter filter;
+    Study::Filter filter;
     for (const std::string& locale : base::SplitString(
              test_cases[i].filter_locales, ",",
              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_locale(locale);
     for (const std::string& exclude_locale :
          base::SplitString(test_cases[i].exclude_locales, ",",
                            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_exclude_locale(exclude_locale);
     EXPECT_EQ(test_cases[i].en_us_result,
               internal::CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               internal::CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
               internal::CheckStudyLocale(filter, "fr"));
   }
 }
 
 TEST(VariationsStudyFilteringTest, 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,
+  const Study::Platform platforms[] = {
+      Study::PLATFORM_WINDOWS,  Study::PLATFORM_MAC,     Study::PLATFORM_LINUX,
+      Study::PLATFORM_CHROMEOS, Study::PLATFORM_ANDROID, Study::PLATFORM_IOS,
   };
-  ASSERT_EQ(Study_Platform_Platform_ARRAYSIZE,
-            static_cast<int>(arraysize(platforms)));
+  ASSERT_EQ(Study::Platform_ARRAYSIZE, static_cast<int>(arraysize(platforms)));
   bool platform_added[arraysize(platforms)] = { 0 };
 
-  Study_Filter filter;
+  Study::Filter filter;
 
   // Check in the forwarded order. The loop cond is <= arraysize(platforms)
   // instead of < so that the result of adding the last channel gets checked.
   for (size_t i = 0; i <= arraysize(platforms); ++i) {
     for (size_t j = 0; j < arraysize(platforms); ++j) {
       const bool expected = platform_added[j] || filter.platform_size() == 0;
       const bool result = internal::CheckStudyPlatform(filter, platforms[j]);
       EXPECT_EQ(expected, result) << "Case " << i << "," << j << " failed!";
     }
 
@@ skipping 28 matching lines @@
     const base::Time start_date;
     bool expected_result;
   } start_test_cases[] = {
       {now - delta, true},
       // Note, the proto start_date is truncated to seconds, but the reference
       // date isn't.
       {now, true},
       {now + delta, false},
   };
 
-  Study_Filter filter;
+  Study::Filter filter;
 
   // Start date not set should result in true.
   EXPECT_TRUE(internal::CheckStudyStartDate(filter, now));
 
   for (size_t i = 0; i < arraysize(start_test_cases); ++i) {
     filter.set_start_date(TimeToProtoTime(start_test_cases[i].start_date));
     const bool result = internal::CheckStudyStartDate(filter, now);
     EXPECT_EQ(start_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
 TEST(VariationsStudyFilteringTest, CheckStudyEndDate) {
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time end_date;
     bool expected_result;
   } start_test_cases[] = {
       {now - delta, false}, {now + delta, true},
   };
 
-  Study_Filter filter;
+  Study::Filter filter;
 
   // End date not set should result in true.
   EXPECT_TRUE(internal::CheckStudyEndDate(filter, now));
 
   for (size_t i = 0; i < arraysize(start_test_cases); ++i) {
     filter.set_end_date(TimeToProtoTime(start_test_cases[i].end_date));
     const bool result = internal::CheckStudyEndDate(filter, now);
     EXPECT_EQ(start_test_cases[i].expected_result, result) << "Case " << i
                                                            << " failed!";
   }
@@ skipping 34 matching lines @@
     { "2.1.*", "2.3.4", false },
     { "2.*", "2.3.4", true },
     { "2.3.*", "2.3.4", true },
     { "2.3.4.*", "2.3.4", true },
     { "2.3.4.0.*", "2.3.4", true },
     { "2.4.*", "2.3.4", true },
     { "1.3.*", "2.3.4", false },
     { "1.*", "2.3.4", false },
   };
 
-  Study_Filter filter;
+  Study::Filter filter;
 
   // Min/max version not set should result in true.
   EXPECT_TRUE(internal::CheckStudyVersion(filter, base::Version("1.2.3")));
 
   for (size_t i = 0; i < arraysize(min_test_cases); ++i) {
     filter.set_min_version(min_test_cases[i].min_version);
     const bool result = internal::CheckStudyVersion(
         filter, base::Version(min_test_cases[i].version));
     EXPECT_EQ(min_test_cases[i].expected_result, result) <<
         "Min. version case " << i << " failed!";
@@ skipping 63 matching lines @@
     // Substring, so still invalid.
     {"", "apple,pear,orange", "fancy INTEL SNapple device", false},
     // Empty.
     {"", "apple,pear,orange", "", true},
 
     // Not testing when both are set as it should never occur and should be
     // considered undefined.
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    Study_Filter filter;
+    Study::Filter filter;
     for (const std::string& cur : base::SplitString(
              test_cases[i].hardware_class, ",",
              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_hardware_class(cur);
 
     for (const std::string& cur : base::SplitString(
              test_cases[i].exclude_hardware_class, ",",
              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_exclude_hardware_class(cur);
 
@@ skipping 29 matching lines @@
       {"", "br,ca,us", "in", true},
       // Empty, which is what would happen if no country was returned from the
       // server.
       {"", "br,ca,us", "", true},
 
       // Not testing when both are set as it should never occur and should be
       // considered undefined.
   };
 
   for (const auto& test : test_cases) {
-    Study_Filter filter;
+    Study::Filter filter;
     for (const std::string& country : base::SplitString(
              test.country, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_country(country);
 
     for (const std::string& exclude_country : base::SplitString(
              test.exclude_country, ",",
              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       filter.add_exclude_country(exclude_country);
 
     EXPECT_EQ(test.expected_result,
@@ skipping 17 matching lines @@
   *study2 = *study1;
   study2->mutable_experiment(0)->set_name("Bam");
   ASSERT_EQ(seed.study(0).name(), seed.study(1).name());
 
   Study* study3 = seed.add_study();
   study3->set_name(kTrial3Name);
   study3->set_default_experiment_name("Default");
   AddExperiment("A", 10, study3);
   AddExperiment("Default", 25, study3);
 
+  ClientFilterableState client_state;
+  client_state.locale = "en-CA";
+  client_state.reference_date = base::Time::Now();
+  client_state.version = base::Version("20.0.0.0");
+  client_state.channel = Study::STABLE;
+  client_state.form_factor = Study::DESKTOP;
+  client_state.platform = Study::PLATFORM_ANDROID;
+
   std::vector<ProcessedStudy> processed_studies;
-  FilterAndValidateStudies(seed, "en-CA", base::Time::Now(),
-                           base::Version("20.0.0.0"), Study_Channel_STABLE,
-                           Study_FormFactor_DESKTOP, "", "", "",
-                           &processed_studies);
+  FilterAndValidateStudies(seed, client_state, &processed_studies);
 
   // Check that only the first kTrial1Name study was kept.
   ASSERT_EQ(2U, processed_studies.size());
   EXPECT_EQ(kTrial1Name, processed_studies[0].study()->name());
   EXPECT_EQ(kGroup1Name, processed_studies[0].study()->experiment(0).name());
   EXPECT_EQ(kTrial3Name, processed_studies[1].study()->name());
 }
 
 TEST(VariationsStudyFilteringTest, FilterAndValidateStudiesWithCountry) {
   const char kSessionCountry[] = "ca";
   const char kPermanentCountry[] = "us";
 
   struct {
-    Study_Consistency consistency;
+    Study::Consistency consistency;
     const char* filter_country;
     const char* filter_exclude_country;
     bool expect_study_kept;
   } test_cases[] = {
       // Country-agnostic studies should be kept regardless of country.
-      {Study_Consistency_SESSION, nullptr, nullptr, true},
-      {Study_Consistency_PERMANENT, nullptr, nullptr, true},
+      {Study::SESSION, nullptr, nullptr, true},
+      {Study::PERMANENT, nullptr, nullptr, true},
 
       // Session-consistency studies should obey the country code in the seed.
-      {Study_Consistency_SESSION, kSessionCountry, nullptr, true},
-      {Study_Consistency_SESSION, nullptr, kSessionCountry, false},
-      {Study_Consistency_SESSION, kPermanentCountry, nullptr, false},
-      {Study_Consistency_SESSION, nullptr, kPermanentCountry, true},
+      {Study::SESSION, kSessionCountry, nullptr, true},
+      {Study::SESSION, nullptr, kSessionCountry, false},
+      {Study::SESSION, kPermanentCountry, nullptr, false},
+      {Study::SESSION, nullptr, kPermanentCountry, true},
 
       // Permanent-consistency studies should obey the permanent-consistency
       // country code.
-      {Study_Consistency_PERMANENT, kPermanentCountry, nullptr, true},
-      {Study_Consistency_PERMANENT, nullptr, kPermanentCountry, false},
-      {Study_Consistency_PERMANENT, kSessionCountry, nullptr, false},
-      {Study_Consistency_PERMANENT, nullptr, kSessionCountry, true},
+      {Study::PERMANENT, kPermanentCountry, nullptr, true},
+      {Study::PERMANENT, nullptr, kPermanentCountry, false},
+      {Study::PERMANENT, kSessionCountry, nullptr, false},
+      {Study::PERMANENT, nullptr, kSessionCountry, true},
   };
 
   for (const auto& test : test_cases) {
     VariationsSeed seed;
     Study* study = seed.add_study();
     study->set_name("study");
     study->set_default_experiment_name("Default");
     AddExperiment("Default", 100, study);
     study->set_consistency(test.consistency);
     if (test.filter_country)
       study->mutable_filter()->add_country(test.filter_country);
     if (test.filter_exclude_country)
       study->mutable_filter()->add_exclude_country(test.filter_exclude_country);
 
+    ClientFilterableState client_state;
+    client_state.locale = "en-CA";
+    client_state.reference_date = base::Time::Now();
+    client_state.version = base::Version("20.0.0.0");
+    client_state.channel = Study::STABLE;
+    client_state.form_factor = Study::DESKTOP;
+    client_state.platform = Study::PLATFORM_ANDROID;
+    client_state.session_consistency_country = kSessionCountry;
+    client_state.permanent_consistency_country = kPermanentCountry;
+
     std::vector<ProcessedStudy> processed_studies;
-    FilterAndValidateStudies(seed, "en-CA", base::Time::Now(),
-                             base::Version("20.0.0.0"), Study_Channel_STABLE,
-                             Study_FormFactor_DESKTOP, "", kSessionCountry,
-                             kPermanentCountry, &processed_studies);
+    FilterAndValidateStudies(seed, client_state, &processed_studies);
 
     EXPECT_EQ(test.expect_study_kept, !processed_studies.empty());
   }
 }
 
+TEST(VariationsStudyFilteringTest, GetClientCountryForStudy_Session) {
+  ClientFilterableState client_state;
+  client_state.session_consistency_country = "session_country";
+  client_state.permanent_consistency_country = "permanent_country";
+
+  Study study;
+  study.set_consistency(Study::SESSION);
+  EXPECT_EQ("session_country",
+            internal::GetClientCountryForStudy(study, client_state));
+}
+
+TEST(VariationsStudyFilteringTest, GetClientCountryForStudy_Permanent) {
+  ClientFilterableState client_state;
+  client_state.session_consistency_country = "session_country";
+  client_state.permanent_consistency_country = "permanent_country";
+
+  Study study;
+  study.set_consistency(Study::PERMANENT);
+  EXPECT_EQ("permanent_country",
+            internal::GetClientCountryForStudy(study, client_state));
+}
+
 TEST(VariationsStudyFilteringTest, 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(internal::IsStudyExpired(study, now));
 
   for (size_t i = 0; i < arraysize(expiry_test_cases); ++i) {
     study.set_expiry_date(TimeToProtoTime(expiry_test_cases[i].expiry_date));
     const bool result = internal::IsStudyExpired(study, now);
     EXPECT_EQ(expiry_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
 TEST(VariationsStudyFilteringTest, ValidateStudy) {
   Study study;
   study.set_default_experiment_name("def");
   AddExperiment("abc", 100, &study);
-  Study_Experiment* default_group = AddExperiment("def", 200, &study);
+  Study::Experiment* default_group = AddExperiment("def", 200, &study);
 
   ProcessedStudy processed_study;
   EXPECT_TRUE(processed_study.Init(&study, false));
   EXPECT_EQ(300, processed_study.total_probability());
 
   // Min version checks.
   study.mutable_filter()->set_min_version("1.2.3.*");
   EXPECT_TRUE(processed_study.Init(&study, false));
   study.mutable_filter()->set_min_version("1.*.3");
   EXPECT_FALSE(processed_study.Init(&study, false));
@@ skipping 14 matching lines @@
 
   study.set_default_experiment_name("xyz");
   EXPECT_FALSE(processed_study.Init(&study, false));
 
   study.set_default_experiment_name("def");
   default_group->clear_name();
   EXPECT_FALSE(processed_study.Init(&study, false));
 
   default_group->set_name("def");
   EXPECT_TRUE(processed_study.Init(&study, false));
-  Study_Experiment* repeated_group = study.add_experiment();
+  Study::Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   EXPECT_FALSE(processed_study.Init(&study, false));
 }
 
 }  // namespace variations