Allow variation id with forcing flag for special setup & unit tests.

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"
@@ skipping 11 matching lines @@
 }
 
 // Constants for testing associating command line flags with trial groups.
 const char kFlagStudyName[] = "flag_test_trial";
 const char kFlagGroup1Name[] = "flag_group1";
 const char kFlagGroup2Name[] = "flag_group2";
 const char kNonFlagGroupName[] = "non_flag_group";
 const char kForcingFlag1[] = "flag_test1";
 const char kForcingFlag2[] = "flag_test2";
 
+const VariationID kExperimentId = 123;
+
 // 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();
   experiment->set_name(name);
   experiment->set_probability_weight(probability);
   return experiment;
 }
 
 // Populates |study| with test data used for testing associating command line
@@ skipping 41 matching lines @@
     // Ensure that the maps are cleared between tests, since they are stored as
     // process singletons.
     testing::ClearAllVariationIDs();
     testing::ClearAllVariationParams();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
 };
 
+TEST_F(VariationsSeedProcessorTest,
+    AllowForceGroupAndVariationIdWithoutCommandLine) {
+  base::FieldTrialList field_trial_list(NULL);
+
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);
+  study.mutable_filter()->add_channel(Study_Channel_DEV);
+  study.mutable_filter()->add_channel(Study_Channel_CANARY);
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_ANDROID);
+
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
+
+  EXPECT_EQ(kNonFlagGroupName,
+            base::FieldTrialList::FindFullName(kFlagStudyName));
+
+  VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
+                                        kFlagGroup1Name);
+  EXPECT_EQ(kExperimentId, id);
+}
+
+TEST_F(VariationsSeedProcessorTest,
+    AllowForceGroupAndVariationIdWithCommandLine) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
+
+  base::FieldTrialList field_trial_list(NULL);
+
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);
+  study.mutable_filter()->add_channel(Study_Channel_DEV);
+  study.mutable_filter()->add_channel(Study_Channel_CANARY);
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_ANDROID);
+
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
+
+  EXPECT_EQ(kFlagGroup1Name,
+            base::FieldTrialList::FindFullName(kFlagStudyName));
+
+  VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
+                                        kFlagGroup1Name);
+  EXPECT_EQ(kExperimentId, id);
+}
+
 TEST_F(VariationsSeedProcessorTest, CheckStudyChannel) {
   VariationsSeedProcessor seed_processor;
 
   const Study_Channel channels[] = {
     Study_Channel_CANARY,
     Study_Channel_DEV,
     Study_Channel_BETA,
     Study_Channel_STABLE,
   };
   bool channel_added[arraysize(channels)] = { 0 };
@@ skipping 314 matching lines @@
       seed, "en-CA", base::Time::Now(), base::Version("20.0.0.0"),
       Study_Channel_STABLE, Study_FormFactor_DESKTOP, &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_F(VariationsSeedProcessorTest,
+    ForbidForceGroupWithVariationIdWithoutCommandLine) {
+  base::FieldTrialList field_trial_list(NULL);
+
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);
+  // Add windows platform makes forcing_flag and variation Id incompatible.
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_WINDOWS);
+
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
+
+  EXPECT_EQ(kNonFlagGroupName,
+            base::FieldTrialList::FindFullName(kFlagStudyName));
+  VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
+                                        kFlagGroup1Name);
+  EXPECT_EQ(0, id);
+}
+
+TEST_F(VariationsSeedProcessorTest,
+    ForbidForceGroupWithVariationIdWithCommandLine) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
+
+  base::FieldTrialList field_trial_list(NULL);
+
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  study.mutable_experiment(1)->set_google_web_experiment_id(kExperimentId);
+  // Add windows platform makes forcing_flag and variation Id incompatible.
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_WINDOWS);
+
+  VariationsSeedProcessor().CreateTrialFromStudy(
+      ProcessedStudy(&study, 100, false));
+
+  EXPECT_EQ(kFlagGroup1Name,
+            base::FieldTrialList::FindFullName(kFlagStudyName));
+  VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, kFlagStudyName,
+                                        kFlagGroup1Name);
+  EXPECT_EQ(0, id);
+}
+
 // 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(
       ProcessedStudy(&study, 100, false));
 
@@ skipping 64 matching lines @@
 
   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 = seed_processor.IsStudyExpired(study, now);
     EXPECT_EQ(expiry_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
 TEST_F(VariationsSeedProcessorTest,
        NonExpiredStudyPrioritizedOverExpiredStudy) {

[yao, 2013/11/13 23:41:43]

This test is not declared in variation_seed_processor.h. I wonder why is this? 

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

Only tests that need to call private APIs need to be declared. (The declaration
allows tests to call private functions that they otherwise wouldn't be allowed
to call.)

[yao, 2013/11/14 20:51:12]

Ic, thanks:) 

On 2013/11/14 16:54:15, Alexei Svitkine wrote:

   VariationsSeedProcessor seed_processor;
 
   const std::string kTrialName = "A";
   const std::string kGroup1Name = "Group1";
 
   VariationsSeed seed;
   Study* study1 = seed.add_study();
   study1->set_name(kTrialName);
   study1->set_default_experiment_name("Default");
   AddExperiment(kGroup1Name, 100, study1);
@@ skipping 24 matching lines @@
     base::FieldTrialList field_trial_list(NULL);
     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);
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 }
 
+TEST_F(VariationsSeedProcessorTest, TestAllowVariationIdWithForcingFlag) {
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  bool allowBoth = VariationsSeedProcessor().
+    AllowVariationIdWithForcingFlag(study);
+  EXPECT_FALSE(allowBoth);
+
+  study.mutable_filter()->add_channel(Study_Channel_DEV);
+  allowBoth = VariationsSeedProcessor().
+    AllowVariationIdWithForcingFlag(study);
+  EXPECT_FALSE(allowBoth);
+
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_ANDROID);
+  allowBoth = VariationsSeedProcessor().
+    AllowVariationIdWithForcingFlag(study);
+  EXPECT_TRUE(allowBoth);
+
+  study.mutable_filter()->add_channel(Study_Channel_CANARY);
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_IOS);
+  allowBoth = VariationsSeedProcessor().
+    AllowVariationIdWithForcingFlag(study);
+  EXPECT_TRUE(allowBoth);
+
+  study.mutable_filter()->add_platform(Study_Platform_PLATFORM_WINDOWS);
+  allowBoth = VariationsSeedProcessor().
+    AllowVariationIdWithForcingFlag(study);
+  EXPECT_FALSE(allowBoth);
+}
+
 TEST_F(VariationsSeedProcessorTest, ValidateStudy) {
   VariationsSeedProcessor seed_processor;
 
   Study study;
   study.set_default_experiment_name("def");
   AddExperiment("abc", 100, &study);
   Study_Experiment* default_group = AddExperiment("def", 200, &study);
 
   base::FieldTrial::Probability total_probability = 0;
   bool valid = seed_processor.ValidateStudyAndComputeTotalProbability(
@@ skipping 90 matching lines @@
   param->set_value("y");
 
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
   base::FieldTrialList field_trial_list(NULL);
   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) {

[yao, 2013/11/13 23:41:43]

This one as well. 

   base::FieldTrialList field_trial_list(NULL);
 
   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();
@@ skipping 26 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