Expired studies should not enable features.

components/variations/variations_seed_processor_unittest.cc

 // Copyright 2013 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/variations_seed_processor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/variations/processed_study.h"
+#include "components/variations/study_filtering.h"
 #include "components/variations/variations_associated_data.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();
@@ skipping 77 matching lines @@
 
   ~VariationsSeedProcessorTest() override {
     // Ensure that the maps are cleared between tests, since they are stored as
     // process singletons.
     testing::ClearAllVariationIDs();
     testing::ClearAllVariationParams();
 
     base::FeatureList::ClearInstanceForTesting();
   }
 
-  bool CreateTrialFromStudy(const Study* study) {
+  bool CreateTrialFromStudy(const Study& study) {
     return CreateTrialFromStudyWithFeatureList(study, &feature_list_);
   }
 
-  bool CreateTrialFromStudyWithFeatureList(const Study* study,
+  bool CreateTrialFromStudyWithFeatureList(const Study& study,
                                            base::FeatureList* feature_list) {
     ProcessedStudy processed_study;
-    if (processed_study.Init(study, false)) {
+    const bool is_expired = internal::IsStudyExpired(study, base::Time::Now());
+    if (processed_study.Init(&study, is_expired)) {
       VariationsSeedProcessor().CreateTrialFromStudy(
           processed_study, override_callback_.callback(), feature_list);
       return true;
     }
     return false;
   }
 
  protected:
   base::FeatureList feature_list_;
   TestOverrideStringCallback override_callback_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
 };
 
 TEST_F(VariationsSeedProcessorTest, AllowForceGroupAndVariationId) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);
 
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 
   VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
                                         kFlagGroup1Name);
   EXPECT_EQ(kExperimentId, id);
 }
 
 // Test that the group for kForcingFlag1 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 // Test that the group for kForcingFlag2 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup2Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest, ForceGroup_ChooseFirstGroupWithFlag) {
   // Add the flag to the command line arguments so the flag group is forced.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest, ForceGroup_DontChooseGroupWithFlag) {
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   // The two flag groups are given high probability, which would normally make
   // them very likely to be chosen. They won't be chosen since flag groups are
   // never chosen when their flag isn't present.
   Study study = CreateStudyWithFlagGroups(1, 999, 999);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kNonFlagGroupName,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest,
        NonExpiredStudyPrioritizedOverExpiredStudy) {
   VariationsSeedProcessor seed_processor;
 
   const std::string kTrialName = "A";
   const std::string kGroup1Name = "Group1";
@@ skipping 10 matching lines @@
 
   const base::Time year_ago =
       base::Time::Now() - base::TimeDelta::FromDays(365);
 
   const base::Version version("20.0.0.0");
 
   // Check that adding [expired, non-expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     base::FeatureList feature_list;
-    base::FieldTrialList field_trial_list(NULL);
+    base::FieldTrialList field_trial_list(nullptr);
     study1->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(
         seed, "en-CA", base::Time::Now(), version, Study_Channel_STABLE,
         Study_FormFactor_DESKTOP, "", "", "", override_callback_.callback(),
         &feature_list);
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 
   // Check that adding [non-expired, expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     base::FeatureList feature_list;
-    base::FieldTrialList field_trial_list(NULL);
+    base::FieldTrialList field_trial_list(nullptr);
     study1->clear_expiry_date();
     study2->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(
         seed, "en-CA", base::Time::Now(), version, Study_Channel_STABLE,
         Study_FormFactor_DESKTOP, "", "", "", override_callback_.callback(),
         &feature_list);
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 }
 
 TEST_F(VariationsSeedProcessorTest, OverrideUIStrings) {
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study;
   study.set_name("Study1");
   study.set_default_experiment_name("B");
   study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
 
   Study_Experiment* experiment1 = AddExperiment("A", 0, &study);
   Study_Experiment_OverrideUIString* override =
       experiment1->add_override_ui_string();
 
   override->set_name_hash(1234);
   override->set_value("test");
 
   Study_Experiment* experiment2 = AddExperiment("B", 1, &study);
 
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
 
   const TestOverrideStringCallback::OverrideMap& overrides =
       override_callback_.overrides();
 
   EXPECT_TRUE(overrides.empty());
 
   study.set_name("Study2");
   experiment1->set_probability_weight(1);
   experiment2->set_probability_weight(0);
 
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
 
   EXPECT_EQ(1u, overrides.size());
   TestOverrideStringCallback::OverrideMap::const_iterator it =
       overrides.find(1234);
   EXPECT_EQ(base::ASCIIToUTF16("test"), it->second);
 }
 
 TEST_F(VariationsSeedProcessorTest, OverrideUIStringsWithForcingFlag) {
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   ASSERT_EQ(kForcingFlag1, study.experiment(1).forcing_flag());
 
   study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
   Study_Experiment_OverrideUIString* override =
       study.mutable_experiment(1)->add_override_ui_string();
   override->set_name_hash(1234);
   override->set_value("test");
 
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
-  base::FieldTrialList field_trial_list(NULL);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  base::FieldTrialList field_trial_list(nullptr);
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup1Name, base::FieldTrialList::FindFullName(study.name()));
 
   const TestOverrideStringCallback::OverrideMap& overrides =
       override_callback_.overrides();
   EXPECT_EQ(1u, overrides.size());
   TestOverrideStringCallback::OverrideMap::const_iterator it =
       overrides.find(1234);
   EXPECT_EQ(base::ASCIIToUTF16("test"), it->second);
 }
 
@@ skipping 109 matching lines @@
   AddExperiment("def", 0, &study2);
   AddExperiment("xyz", 34, &study2);
   EXPECT_TRUE(processed_study.Init(&study2, false));
   EXPECT_TRUE(processed_study.all_assignments_to_one_group());
   AddExperiment("abc", 12, &study2);
   EXPECT_TRUE(processed_study.Init(&study2, false));
   EXPECT_FALSE(processed_study.all_assignments_to_one_group());
 }
 
 TEST_F(VariationsSeedProcessorTest, VariationParams) {
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study;
   study.set_name("Study1");
   study.set_default_experiment_name("B");
 
   Study_Experiment* experiment1 = AddExperiment("A", 1, &study);
   Study_Experiment_Param* param = experiment1->add_param();
   param->set_name("x");
   param->set_value("y");
 
   Study_Experiment* experiment2 = AddExperiment("B", 0, &study);
 
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ("y", GetVariationParamValue("Study1", "x"));
 
   study.set_name("Study2");
   experiment1->set_probability_weight(0);
   experiment2->set_probability_weight(1);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(std::string(), GetVariationParamValue("Study2", "x"));
 }
 
 TEST_F(VariationsSeedProcessorTest, VariationParamsWithForcingFlag) {
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   ASSERT_EQ(kForcingFlag1, study.experiment(1).forcing_flag());
   Study_Experiment_Param* param = study.mutable_experiment(1)->add_param();
   param->set_name("x");
   param->set_value("y");
 
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
-  base::FieldTrialList field_trial_list(NULL);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  base::FieldTrialList field_trial_list(nullptr);
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_EQ(kFlagGroup1Name, base::FieldTrialList::FindFullName(study.name()));
   EXPECT_EQ("y", GetVariationParamValue(study.name(), "x"));
 }
 
 TEST_F(VariationsSeedProcessorTest, StartsActive) {
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   VariationsSeed seed;
   Study* study1 = seed.add_study();
   study1->set_name("A");
   study1->set_default_experiment_name("Default");
   AddExperiment("AA", 100, study1);
   AddExperiment("Default", 0, study1);
 
   Study* study2 = seed.add_study();
   study2->set_name("B");
@@ skipping 27 matching lines @@
 
   // Now, all studies should be active.
   EXPECT_TRUE(base::FieldTrialList::IsTrialActive("A"));
   EXPECT_TRUE(base::FieldTrialList::IsTrialActive("B"));
   EXPECT_TRUE(base::FieldTrialList::IsTrialActive("C"));
 }
 
 TEST_F(VariationsSeedProcessorTest, StartsActiveWithFlag) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
 
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   EXPECT_TRUE(base::FieldTrialList::IsTrialActive(kFlagStudyName));
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest, ForcingFlagAlreadyForced) {
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
   ASSERT_EQ(kNonFlagGroupName, study.experiment(0).name());
   Study_Experiment_Param* param = study.mutable_experiment(0)->add_param();
   param->set_name("x");
   param->set_value("y");
   study.mutable_experiment(0)->set_google_web_experiment_id(kExperimentId);
 
-  base::FieldTrialList field_trial_list(NULL);
+  base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(kFlagStudyName, kNonFlagGroupName);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
-  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_TRUE(CreateTrialFromStudy(study));
   // The previously forced experiment should still hold.
   EXPECT_EQ(kNonFlagGroupName,
             base::FieldTrialList::FindFullName(study.name()));
 
   // Check that params and experiment ids correspond.
   EXPECT_EQ("y", GetVariationParamValue(study.name(), "x"));
   VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
                                         kNonFlagGroupName);
   EXPECT_EQ(kExperimentId, id);
 }
@@ skipping 19 matching lines @@
       {kFeatureOnByDefault.name, nullptr, false, true},
       {kFeatureOffByDefault.name, nullptr, true, true},
       {nullptr, kFeatureOnByDefault.name, false, false},
       {nullptr, kFeatureOffByDefault.name, false, true},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
 
-    base::FieldTrialList field_trial_list(NULL);
+    base::FieldTrialList field_trial_list(nullptr);
     base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
     Study study;
     study.set_name("Study1");
     study.set_default_experiment_name("B");
     AddExperiment("B", 0, &study);
 
     Study_Experiment* experiment = AddExperiment("A", 1, &study);
     Study_Experiment_FeatureAssociation* association =
         experiment->mutable_feature_association();
     if (test_case.enable_feature)
       association->add_enable_feature(test_case.enable_feature);
     else if (test_case.disable_feature)
       association->add_disable_feature(test_case.disable_feature);
 
-    EXPECT_TRUE(
-        CreateTrialFromStudyWithFeatureList(&study, feature_list.get()));
+    EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
     base::FeatureList::SetInstance(std::move(feature_list));
 
     // |kUnrelatedFeature| should not be affected.
     EXPECT_FALSE(base::FeatureList::IsEnabled(kUnrelatedFeature));
 
     // Before the associated feature is queried, the trial shouldn't be active.
     EXPECT_FALSE(base::FieldTrialList::IsTrialActive(study.name()));
 
     EXPECT_EQ(test_case.expected_feature_off_state,
               base::FeatureList::IsEnabled(kFeatureOffByDefault));
@@ skipping 85 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     const auto& test_case = test_cases[i];
     const int group = test_case.one_hundred_percent_group;
     SCOPED_TRACE(base::StringPrintf(
         "Test[%" PRIuS "]: %s [%s] [%s] %d", i, test_case.feature.name,
         test_case.enable_features_command_line,
         test_case.disable_features_command_line, static_cast<int>(group)));
 
-    base::FieldTrialList field_trial_list(NULL);
+    base::FieldTrialList field_trial_list(nullptr);
     base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(
         test_case.enable_features_command_line,
         test_case.disable_features_command_line);
 
     Study study;
     study.set_name("Study1");
-    study.set_default_experiment_name("Default");
+    study.set_default_experiment_name(kDefaultGroup);
     AddExperiment(kDefaultGroup, group == DEFAULT_GROUP ? 1 : 0, &study);
 
     Study_Experiment* feature_enable =
         AddExperiment(kEnabledGroup, group == ENABLE_GROUP ? 1 : 0, &study);
     feature_enable->mutable_feature_association()->add_enable_feature(
         test_case.feature.name);
 
     Study_Experiment* feature_disable =
         AddExperiment(kDisabledGroup, group == DISABLE_GROUP ? 1 : 0, &study);
     feature_disable->mutable_feature_association()->add_disable_feature(
         test_case.feature.name);
 
     AddExperiment(kForcedOnGroup, 0, &study)
         ->mutable_feature_association()
         ->set_forcing_feature_on(test_case.feature.name);
     AddExperiment(kForcedOffGroup, 0, &study)
         ->mutable_feature_association()
         ->set_forcing_feature_off(test_case.feature.name);
 
-    EXPECT_TRUE(
-        CreateTrialFromStudyWithFeatureList(&study, feature_list.get()));
+    EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
     base::FeatureList::SetInstance(std::move(feature_list));
 
     // Trial should not be activated initially, but later might get activated
     // depending on the expected values.
     EXPECT_FALSE(base::FieldTrialList::IsTrialActive(study.name()));
     EXPECT_EQ(test_case.expected_feature_state,
               base::FeatureList::IsEnabled(test_case.feature));
     EXPECT_EQ(test_case.expected_trial_activated,
               base::FieldTrialList::IsTrialActive(study.name()));
   }
 }
 
+TEST_F(VariationsSeedProcessorTest, FeaturesInExpiredStudies) {
+  struct base::Feature kDisabledFeature {
+    "kDisabledFeature", base::FEATURE_DISABLED_BY_DEFAULT
+  };
+  struct base::Feature kEnabledFeature {
+    "kEnabledFeature", base::FEATURE_ENABLED_BY_DEFAULT
+  };
+  const base::Time now = base::Time::Now();
+  const base::Time year_ago = now - base::TimeDelta::FromDays(365);
+  const base::Time year_later = now + base::TimeDelta::FromDays(365);
+
+  struct {
+    const base::Feature& feature;
+    bool study_force_feature_state;
+    base::Time expiry_date;
+    bool expected_feature_enabled;
+  } test_cases[] = {
+      {kDisabledFeature, true, year_ago, false},
+      {kDisabledFeature, true, year_later, true},
+      {kEnabledFeature, false, year_ago, true},
+      {kEnabledFeature, false, year_later, false},
+  };
+
+  for (size_t i = 0; i < arraysize(test_cases); i++) {
+    const auto& test_case = test_cases[i];
+    SCOPED_TRACE(
+        base::StringPrintf("Test[%" PRIuS "]: %s", i, test_case.feature.name));
+
+    base::FieldTrialList field_trial_list(nullptr);
+    base::FeatureList::ClearInstanceForTesting();
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->InitializeFromCommandLine(std::string(), std::string());
+
+    // Expired study with a 100% feature group and a default group that has no
+    // feature association.
+    Study study;
+    study.set_name("Study1");
+    study.set_default_experiment_name("Default");
+
+    study.set_expiry_date(TimeToProtoTime(test_case.expiry_date));
+
+    AddExperiment("Default", 0, &study);
+    Study_Experiment* feature_experiment = AddExperiment("Feature", 1, &study);
+    if (test_case.study_force_feature_state) {
+      feature_experiment->mutable_feature_association()->add_enable_feature(
+          test_case.feature.name);
+    } else {
+      feature_experiment->mutable_feature_association()->add_disable_feature(
+          test_case.feature.name);
+    }
+
+    EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
+    base::FeatureList::SetInstance(std::move(feature_list));
+
+    // Tthe feature should not be enabled, because the study is expired.
+    EXPECT_EQ(test_case.expected_feature_enabled,
+              base::FeatureList::IsEnabled(test_case.feature));
+  }
+}
+
 }  // namespace variations