Refactor VariationsSeedProcessor to add ProcessedStudy struct.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
+#include "components/variations/processed_study.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_variations {
 
 namespace {
 
 // Converts |time| to Study proto format.
 int64 TimeToProtoTime(const base::Time& time) {
   return (time - base::Time::UnixEpoch()).InSeconds();
@@ skipping 310 matching lines @@
       if (!max_test_cases[j].expected_result) {
         const bool result =
             seed_processor.CheckStudyVersion(
                 filter, Version(max_test_cases[j].version));
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
     }
   }
 }
 
+TEST_F(VariationsSeedProcessorTest, FilterAndValidateStudies) {
+  const std::string kTrial1Name = "A";
+  const std::string kGroup1Name = "Group1";
+  const std::string kTrial3Name = "B";
+
+  VariationsSeed seed;
+  Study* study1 = seed.add_study();
+  study1->set_name(kTrial1Name);
+  study1->set_default_experiment_name("Default");
+  AddExperiment(kGroup1Name, 100, study1);
+  AddExperiment("Default", 0, study1);
+
+  Study* study2 = seed.add_study();
+  *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);
+
+  std::vector<ProcessedStudy> processed_studies;
+  VariationsSeedProcessor().FilterAndValidateStudies(
+      seed, "en-CA", base::Time::Now(), base::Version("20.0.0.0"),
+      Study_Channel_STABLE, &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 that the group for kForcingFlag1 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag1) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 // Test that the group for kForcingFlag2 is forced.
 TEST_F(VariationsSeedProcessorTest, ForceGroupWithFlag2) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
 
   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.
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag2);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
-  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest, ForceGroup_DontChooseGroupWithFlag) {
   base::FieldTrialList field_trial_list(NULL);
 
   // 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);
-  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 1 + 999 + 999, false));
   EXPECT_EQ(kNonFlagGroupName,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 TEST_F(VariationsSeedProcessorTest, IsStudyExpired) {
   VariationsSeedProcessor seed_processor;
 
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
@@ skipping 140 matching lines @@
   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);
 
-  seed_processor.CreateTrialFromStudy(study, false);
+  seed_processor.CreateTrialFromStudy(ProcessedStudy(&study, 1, false));
   EXPECT_EQ("y", GetVariationParamValue("Study1", "x"));
 
   study.set_name("Study2");
   experiment1->set_probability_weight(0);
   experiment2->set_probability_weight(1);
-  seed_processor.CreateTrialFromStudy(study, false);
+  seed_processor.CreateTrialFromStudy(ProcessedStudy(&study, 1, false));
   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");
 
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
   base::FieldTrialList field_trial_list(NULL);
-  VariationsSeedProcessor().CreateTrialFromStudy(study, false);
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
   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);
 
   VariationsSeed seed;
   Study* study1 = seed.add_study();
   study1->set_name("A");
@@ skipping 30 matching lines @@
   EXPECT_EQ("BB", base::FieldTrialList::FindFullName("B"));
   EXPECT_EQ("CC", base::FieldTrialList::FindFullName("C"));
 
   // Now, all studies should be active.
   EXPECT_TRUE(IsFieldTrialActive("A"));
   EXPECT_TRUE(IsFieldTrialActive("B"));
   EXPECT_TRUE(IsFieldTrialActive("C"));
 }
 
 }  // namespace chrome_variations