components/variations/variations_associated_data_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/variations/variations_associated_data.h"
   6
   7 #include "base/metrics/field_trial.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace variations {
  11
  12 namespace {
  13
  14 const VariationID TEST_VALUE_A = 3300200;
  15 const VariationID TEST_VALUE_B = 3300201;
  16
  17 // Convenience helper to retrieve the variations::VariationID for a FieldTrial.
  18 // Note that this will do the group assignment in |trial| if not already done.
  19 VariationID GetIDForTrial(IDCollectionKey key, base::FieldTrial* trial) {
  20   return GetGoogleVariationID(key, trial->trial_name(), trial->group_name());
  21 }
  22
  23 // Tests whether a field trial is active (i.e. group() has been called on it).
  24 bool IsFieldTrialActive(const std::string& trial_name) {
  25   base::FieldTrial::ActiveGroups active_groups;
  26   base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
  27   for (size_t i = 0; i < active_groups.size(); ++i) {
  28     if (active_groups[i].trial_name == trial_name)
  29       return true;
  30   }
  31   return false;
  32 }
  33
  34 // Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date.
  35 scoped_refptr<base::FieldTrial> CreateFieldTrial(
  36     const std::string& trial_name,
  37     int total_probability,
  38     const std::string& default_group_name,
  39     int* default_group_number) {
  40   return base::FieldTrialList::FactoryGetFieldTrial(
  41       trial_name, total_probability, default_group_name,
  42       base::FieldTrialList::kNoExpirationYear, 1, 1,
  43       base::FieldTrial::SESSION_RANDOMIZED, default_group_number);
  44 }
  45
  46 }  // namespace
  47
  48 class VariationsAssociatedDataTest : public ::testing::Test {
  49  public:
  50   VariationsAssociatedDataTest() : field_trial_list_(NULL) {
  51   }
  52
  53   ~VariationsAssociatedDataTest() override {
  54     // Ensure that the maps are cleared between tests, since they are stored as
  55     // process singletons.
  56     testing::ClearAllVariationIDs();
  57     testing::ClearAllVariationParams();
  58   }
  59
  60  private:
  61   base::FieldTrialList field_trial_list_;
  62
  63   DISALLOW_COPY_AND_ASSIGN(VariationsAssociatedDataTest);
  64 };
  65
  66 // Test that if the trial is immediately disabled, GetGoogleVariationID just
  67 // returns the empty ID.
  68 TEST_F(VariationsAssociatedDataTest, DisableImmediately) {
  69   int default_group_number = -1;
  70   scoped_refptr<base::FieldTrial> trial(
  71       CreateFieldTrial("trial", 100, "default", &default_group_number));
  72
  73   ASSERT_EQ(default_group_number, trial->group());
  74   ASSERT_EQ(EMPTY_ID, GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial.get()));
  75 }
  76
  77 // Test that successfully associating the FieldTrial with some ID, and then
  78 // disabling the FieldTrial actually makes GetGoogleVariationID correctly
  79 // return the empty ID.
  80 TEST_F(VariationsAssociatedDataTest, DisableAfterInitialization) {
  81   const std::string default_name = "default";
  82   const std::string non_default_name = "non_default";
  83
  84   scoped_refptr<base::FieldTrial> trial(
  85       CreateFieldTrial("trial", 100, default_name, NULL));
  86
  87   trial->AppendGroup(non_default_name, 100);
  88   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial->trial_name(),
  89       default_name, TEST_VALUE_A);
  90   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial->trial_name(),
  91       non_default_name, TEST_VALUE_B);
  92   trial->Disable();
  93   ASSERT_EQ(default_name, trial->group_name());
  94   ASSERT_EQ(TEST_VALUE_A, GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial.get()));
  95 }
  96
  97 // Test various successful association cases.
  98 TEST_F(VariationsAssociatedDataTest, AssociateGoogleVariationID) {
  99   const std::string default_name1 = "default";
 100   scoped_refptr<base::FieldTrial> trial_true(
 101       CreateFieldTrial("d1", 10, default_name1, NULL));
 102   const std::string winner = "TheWinner";
 103   int winner_group = trial_true->AppendGroup(winner, 10);
 104
 105   // Set GoogleVariationIDs so we can verify that they were chosen correctly.
 106   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(),
 107       default_name1, TEST_VALUE_A);
 108   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(),
 109       winner, TEST_VALUE_B);
 110
 111   EXPECT_EQ(winner_group, trial_true->group());
 112   EXPECT_EQ(winner, trial_true->group_name());
 113   EXPECT_EQ(TEST_VALUE_B,
 114             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get()));
 115
 116   const std::string default_name2 = "default2";
 117   scoped_refptr<base::FieldTrial> trial_false(
 118       CreateFieldTrial("d2", 10, default_name2, NULL));
 119   const std::string loser = "ALoser";
 120   const int loser_group = trial_false->AppendGroup(loser, 0);
 121
 122   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_false->trial_name(),
 123       default_name2, TEST_VALUE_A);
 124   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_false->trial_name(),
 125       loser, TEST_VALUE_B);
 126
 127   EXPECT_NE(loser_group, trial_false->group());
 128   EXPECT_EQ(TEST_VALUE_A,
 129             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_false.get()));
 130 }
 131
 132 // Test that not associating a FieldTrial with any IDs ensure that the empty ID
 133 // will be returned.
 134 TEST_F(VariationsAssociatedDataTest, NoAssociation) {
 135   const std::string default_name = "default";
 136   scoped_refptr<base::FieldTrial> no_id_trial(
 137       CreateFieldTrial("d3", 10, default_name, NULL));
 138
 139   const std::string winner = "TheWinner";
 140   const int winner_group = no_id_trial->AppendGroup(winner, 10);
 141
 142   // Ensure that despite the fact that a normal winner is elected, it does not
 143   // have a valid VariationID associated with it.
 144   EXPECT_EQ(winner_group, no_id_trial->group());
 145   EXPECT_EQ(winner, no_id_trial->group_name());
 146   EXPECT_EQ(EMPTY_ID, GetIDForTrial(GOOGLE_WEB_PROPERTIES, no_id_trial.get()));
 147 }
 148
 149 // Ensure that the AssociateGoogleVariationIDForce works as expected.
 150 TEST_F(VariationsAssociatedDataTest, ForceAssociation) {
 151   EXPECT_EQ(EMPTY_ID,
 152             GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group"));
 153   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group",
 154                              TEST_VALUE_A);
 155   EXPECT_EQ(TEST_VALUE_A,
 156             GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group"));
 157   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group",
 158                              TEST_VALUE_B);
 159   EXPECT_EQ(TEST_VALUE_A,
 160             GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group"));
 161   AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES, "trial", "group",
 162                                   TEST_VALUE_B);
 163   EXPECT_EQ(TEST_VALUE_B,
 164             GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, "trial", "group"));
 165 }
 166
 167 // Ensure that two collections can coexist without affecting each other.
 168 TEST_F(VariationsAssociatedDataTest, CollectionsCoexist) {
 169   const std::string default_name = "default";
 170   int default_group_number = -1;
 171   scoped_refptr<base::FieldTrial> trial_true(
 172       CreateFieldTrial("d1", 10, default_name, &default_group_number));
 173   ASSERT_EQ(default_group_number, trial_true->group());
 174   ASSERT_EQ(default_name, trial_true->group_name());
 175
 176   EXPECT_EQ(EMPTY_ID,
 177             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get()));
 178   EXPECT_EQ(EMPTY_ID,
 179             GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get()));
 180   EXPECT_EQ(EMPTY_ID,
 181             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 182   EXPECT_EQ(EMPTY_ID,
 183             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 184
 185   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES, trial_true->trial_name(),
 186       default_name, TEST_VALUE_A);
 187   EXPECT_EQ(TEST_VALUE_A,
 188             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get()));
 189   EXPECT_EQ(EMPTY_ID,
 190             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 191   EXPECT_EQ(EMPTY_ID,
 192             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 193
 194   AssociateGoogleVariationID(GOOGLE_UPDATE_SERVICE, trial_true->trial_name(),
 195       default_name, TEST_VALUE_A);
 196   EXPECT_EQ(TEST_VALUE_A,
 197             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get()));
 198   EXPECT_EQ(TEST_VALUE_A,
 199             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 200   EXPECT_EQ(EMPTY_ID,
 201             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 202
 203   AssociateGoogleVariationID(CHROME_SYNC_SERVICE, trial_true->trial_name(),
 204       default_name, TEST_VALUE_A);
 205   EXPECT_EQ(TEST_VALUE_A,
 206             GetIDForTrial(GOOGLE_WEB_PROPERTIES, trial_true.get()));
 207   EXPECT_EQ(TEST_VALUE_A,
 208             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 209   EXPECT_EQ(TEST_VALUE_A,
 210             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 211
 212   trial_true = CreateFieldTrial("d2", 10, default_name, &default_group_number);
 213   ASSERT_EQ(default_group_number, trial_true->group());
 214   ASSERT_EQ(default_name, trial_true->group_name());
 215
 216   AssociateGoogleVariationID(GOOGLE_WEB_PROPERTIES_TRIGGER,
 217                              trial_true->trial_name(), default_name,
 218                              TEST_VALUE_A);
 219   EXPECT_EQ(TEST_VALUE_A,
 220             GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get()));
 221   EXPECT_EQ(EMPTY_ID,
 222             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 223   EXPECT_EQ(EMPTY_ID,
 224             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 225
 226   AssociateGoogleVariationID(GOOGLE_UPDATE_SERVICE, trial_true->trial_name(),
 227                              default_name, TEST_VALUE_A);
 228   EXPECT_EQ(TEST_VALUE_A,
 229             GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get()));
 230   EXPECT_EQ(TEST_VALUE_A,
 231             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 232   EXPECT_EQ(EMPTY_ID,
 233             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 234
 235   AssociateGoogleVariationID(CHROME_SYNC_SERVICE, trial_true->trial_name(),
 236       default_name, TEST_VALUE_A);
 237   EXPECT_EQ(TEST_VALUE_A,
 238             GetIDForTrial(GOOGLE_WEB_PROPERTIES_TRIGGER, trial_true.get()));
 239   EXPECT_EQ(TEST_VALUE_A,
 240             GetIDForTrial(GOOGLE_UPDATE_SERVICE, trial_true.get()));
 241   EXPECT_EQ(TEST_VALUE_A,
 242             GetIDForTrial(CHROME_SYNC_SERVICE, trial_true.get()));
 243 }
 244
 245 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams) {
 246   const std::string kTrialName = "AssociateVariationParams";
 247
 248   {
 249     std::map<std::string, std::string> params;
 250     params["a"] = "10";
 251     params["b"] = "test";
 252     ASSERT_TRUE(AssociateVariationParams(kTrialName, "A", params));
 253   }
 254   {
 255     std::map<std::string, std::string> params;
 256     params["a"] = "5";
 257     ASSERT_TRUE(AssociateVariationParams(kTrialName, "B", params));
 258   }
 259
 260   base::FieldTrialList::CreateFieldTrial(kTrialName, "B");
 261   EXPECT_EQ("5", GetVariationParamValue(kTrialName, "a"));
 262   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "b"));
 263   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x"));
 264
 265   std::map<std::string, std::string> params;
 266   EXPECT_TRUE(GetVariationParams(kTrialName, &params));
 267   EXPECT_EQ(1U, params.size());
 268   EXPECT_EQ("5", params["a"]);
 269 }
 270
 271 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams_Fail) {
 272   const std::string kTrialName = "AssociateVariationParams_Fail";
 273   const std::string kGroupName = "A";
 274
 275   std::map<std::string, std::string> params;
 276   params["a"] = "10";
 277   ASSERT_TRUE(AssociateVariationParams(kTrialName, kGroupName, params));
 278   params["a"] = "1";
 279   params["b"] = "2";
 280   ASSERT_FALSE(AssociateVariationParams(kTrialName, kGroupName, params));
 281
 282   base::FieldTrialList::CreateFieldTrial(kTrialName, kGroupName);
 283   EXPECT_EQ("10", GetVariationParamValue(kTrialName, "a"));
 284   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "b"));
 285 }
 286
 287 TEST_F(VariationsAssociatedDataTest, AssociateVariationParams_TrialActiveFail) {
 288   const std::string kTrialName = "AssociateVariationParams_TrialActiveFail";
 289   base::FieldTrialList::CreateFieldTrial(kTrialName, "A");
 290   ASSERT_EQ("A", base::FieldTrialList::FindFullName(kTrialName));
 291
 292   std::map<std::string, std::string> params;
 293   params["a"] = "10";
 294   EXPECT_FALSE(AssociateVariationParams(kTrialName, "B", params));
 295   EXPECT_FALSE(AssociateVariationParams(kTrialName, "A", params));
 296 }
 297
 298 TEST_F(VariationsAssociatedDataTest,
 299        AssociateVariationParams_DoesntActivateTrial) {
 300   const std::string kTrialName = "AssociateVariationParams_DoesntActivateTrial";
 301
 302   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 303   scoped_refptr<base::FieldTrial> trial(
 304       CreateFieldTrial(kTrialName, 100, "A", NULL));
 305   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 306
 307   std::map<std::string, std::string> params;
 308   params["a"] = "10";
 309   EXPECT_TRUE(AssociateVariationParams(kTrialName, "A", params));
 310   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 311 }
 312
 313 TEST_F(VariationsAssociatedDataTest, GetVariationParams_NoTrial) {
 314   const std::string kTrialName = "GetVariationParams_NoParams";
 315
 316   std::map<std::string, std::string> params;
 317   EXPECT_FALSE(GetVariationParams(kTrialName, &params));
 318   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x"));
 319   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "y"));
 320 }
 321
 322 TEST_F(VariationsAssociatedDataTest, GetVariationParams_NoParams) {
 323   const std::string kTrialName = "GetVariationParams_NoParams";
 324
 325   base::FieldTrialList::CreateFieldTrial(kTrialName, "A");
 326
 327   std::map<std::string, std::string> params;
 328   EXPECT_FALSE(GetVariationParams(kTrialName, &params));
 329   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x"));
 330   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "y"));
 331 }
 332
 333 TEST_F(VariationsAssociatedDataTest, GetVariationParams_ActivatesTrial) {
 334   const std::string kTrialName = "GetVariationParams_ActivatesTrial";
 335
 336   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 337   scoped_refptr<base::FieldTrial> trial(
 338       CreateFieldTrial(kTrialName, 100, "A", NULL));
 339   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 340
 341   std::map<std::string, std::string> params;
 342   EXPECT_FALSE(GetVariationParams(kTrialName, &params));
 343   ASSERT_TRUE(IsFieldTrialActive(kTrialName));
 344 }
 345
 346 TEST_F(VariationsAssociatedDataTest, GetVariationParamValue_ActivatesTrial) {
 347   const std::string kTrialName = "GetVariationParamValue_ActivatesTrial";
 348
 349   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 350   scoped_refptr<base::FieldTrial> trial(
 351       CreateFieldTrial(kTrialName, 100, "A", NULL));
 352   ASSERT_FALSE(IsFieldTrialActive(kTrialName));
 353
 354   std::map<std::string, std::string> params;
 355   EXPECT_EQ(std::string(), GetVariationParamValue(kTrialName, "x"));
 356   ASSERT_TRUE(IsFieldTrialActive(kTrialName));
 357 }
 358
 359 }  // namespace variations