src/chrome/browser/metrics/variations/variations_http_header_provider_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 "chrome/browser/metrics/variations/variations_http_header_provider.h"
   6
   7 #include <string>
   8
   9 #include "base/base64.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/metrics/field_trial.h"
  12 #include "base/run_loop.h"
  13 #include "chrome/common/metrics/proto/chrome_experiments.pb.h"
  14 #include "components/variations/entropy_provider.h"
  15 #include "components/variations/variations_associated_data.h"
  16 #include "net/http/http_request_headers.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "url/gurl.h"
  19
  20 namespace chrome_variations {
  21
  22 namespace {
  23
  24 // Decodes the variations header and extracts the variation ids.
  25 bool ExtractVariationIds(const std::string& variations,
  26                          std::set<VariationID>* variation_ids,
  27                          std::set<VariationID>* trigger_ids) {
  28   std::string serialized_proto;
  29   if (!base::Base64Decode(variations, &serialized_proto))
  30     return false;
  31   metrics::ChromeVariations proto;
  32   if (!proto.ParseFromString(serialized_proto))
  33     return false;
  34   for (int i = 0; i < proto.variation_id_size(); ++i)
  35     variation_ids->insert(proto.variation_id(i));
  36   for (int i = 0; i < proto.trigger_variation_id_size(); ++i)
  37     trigger_ids->insert(proto.trigger_variation_id(i));
  38   return true;
  39 }
  40
  41 scoped_refptr<base::FieldTrial> CreateTrialAndAssociateId(
  42     const std::string& trial_name,
  43     const std::string& default_group_name,
  44     IDCollectionKey key,
  45     VariationID id) {
  46   scoped_refptr<base::FieldTrial> trial(
  47       base::FieldTrialList::CreateFieldTrial(trial_name, default_group_name));
  48
  49   chrome_variations::AssociateGoogleVariationID(key, trial->trial_name(),
  50                                                 trial->group_name(), id);
  51
  52   return trial;
  53 }
  54
  55 }  // namespace
  56
  57 class VariationsHttpHeaderProviderTest : public ::testing::Test {
  58  public:
  59   VariationsHttpHeaderProviderTest() {}
  60
  61   virtual ~VariationsHttpHeaderProviderTest() {}
  62
  63   virtual void TearDown() OVERRIDE {
  64     testing::ClearAllVariationIDs();
  65   }
  66 };
  67
  68 TEST_F(VariationsHttpHeaderProviderTest, ShouldAppendHeaders) {
  69   struct {
  70     const char* url;
  71     bool should_append_headers;
  72   } cases[] = {
  73     { "http://google.com", true },
  74     { "http://www.google.com", true },
  75     { "http://m.google.com", true },
  76     { "http://google.ca", true },
  77     { "https://google.ca", true },
  78     { "http://google.co.uk", true },
  79     { "http://google.co.uk:8080/", true },
  80     { "http://www.google.co.uk:8080/", true },
  81     { "http://google", false },
  82
  83     { "http://youtube.com", true },
  84     { "http://www.youtube.com", true },
  85     { "http://www.youtube.ca", true },
  86     { "http://www.youtube.co.uk:8080/", true },
  87     { "https://www.youtube.com", true },
  88     { "http://youtube", false },
  89
  90     { "http://www.yahoo.com", false },
  91
  92     { "http://ad.doubleclick.net", true },
  93     { "https://a.b.c.doubleclick.net", true },
  94     { "https://a.b.c.doubleclick.net:8081", true },
  95     { "http://www.doubleclick.com", false },
  96     { "http://www.doubleclick.net.com", false },
  97     { "https://www.doubleclick.net.com", false },
  98
  99     { "http://ad.googlesyndication.com", true },
 100     { "https://a.b.c.googlesyndication.com", true },
 101     { "https://a.b.c.googlesyndication.com:8080", true },
 102     { "http://www.doubleclick.edu", false },
 103     { "http://www.googlesyndication.com.edu", false },
 104     { "https://www.googlesyndication.com.com", false },
 105
 106     { "http://www.googleadservices.com", true },
 107     { "http://www.googleadservices.com:8080", true },
 108     { "https://www.googleadservices.com", true },
 109     { "https://www.internal.googleadservices.com", false },
 110     { "https://www2.googleadservices.com", false },
 111     { "https://www.googleadservices.org", false },
 112     { "https://www.googleadservices.com.co.uk", false },
 113   };
 114
 115   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 116     const GURL url(cases[i].url);
 117     EXPECT_EQ(cases[i].should_append_headers,
 118               VariationsHttpHeaderProvider::ShouldAppendHeaders(url)) << url;
 119   }
 120 }
 121
 122 TEST_F(VariationsHttpHeaderProviderTest, SetDefaultVariationIds_Valid) {
 123   base::MessageLoop loop;
 124   VariationsHttpHeaderProvider provider;
 125   GURL url("http://www.google.com");
 126   net::HttpRequestHeaders headers;
 127   std::string variations;
 128
 129   // Valid experiment ids.
 130   EXPECT_TRUE(provider.SetDefaultVariationIds("12,456,t789"));
 131   provider.InitVariationIDsCacheIfNeeded();
 132   provider.AppendHeaders(url, false, false, &headers);
 133   EXPECT_TRUE(headers.HasHeader("X-Client-Data"));
 134   headers.GetHeader("X-Client-Data", &variations);
 135   std::set<VariationID> variation_ids;
 136   std::set<VariationID> trigger_ids;
 137   ASSERT_TRUE(ExtractVariationIds(variations, &variation_ids, &trigger_ids));
 138   EXPECT_TRUE(variation_ids.find(12) != variation_ids.end());
 139   EXPECT_TRUE(variation_ids.find(456) != variation_ids.end());
 140   EXPECT_TRUE(trigger_ids.find(789) != trigger_ids.end());
 141   EXPECT_FALSE(variation_ids.find(789) != variation_ids.end());
 142 }
 143
 144 TEST_F(VariationsHttpHeaderProviderTest, SetDefaultVariationIds_Invalid) {
 145   base::MessageLoop loop;
 146   VariationsHttpHeaderProvider provider;
 147   GURL url("http://www.google.com");
 148   net::HttpRequestHeaders headers;
 149
 150   // Invalid experiment ids.
 151   EXPECT_FALSE(provider.SetDefaultVariationIds("abcd12,456"));
 152   provider.InitVariationIDsCacheIfNeeded();
 153   provider.AppendHeaders(url, false, false, &headers);
 154   EXPECT_FALSE(headers.HasHeader("X-Client-Data"));
 155
 156   // Invalid trigger experiment id
 157   EXPECT_FALSE(provider.SetDefaultVariationIds("12,tabc456"));
 158   provider.InitVariationIDsCacheIfNeeded();
 159   provider.AppendHeaders(url, false, false, &headers);
 160   EXPECT_FALSE(headers.HasHeader("X-Client-Data"));
 161 }
 162
 163 TEST_F(VariationsHttpHeaderProviderTest, OnFieldTrialGroupFinalized) {
 164   base::MessageLoop loop;
 165   base::FieldTrialList field_trial_list(
 166       new metrics::SHA1EntropyProvider("test"));
 167   VariationsHttpHeaderProvider provider;
 168   provider.InitVariationIDsCacheIfNeeded();
 169
 170   const std::string default_name = "default";
 171   scoped_refptr<base::FieldTrial> trial_1(CreateTrialAndAssociateId(
 172       "t1", default_name, GOOGLE_WEB_PROPERTIES, 123));
 173
 174   ASSERT_EQ(default_name, trial_1->group_name());
 175
 176   scoped_refptr<base::FieldTrial> trial_2(CreateTrialAndAssociateId(
 177       "t2", default_name, GOOGLE_WEB_PROPERTIES_TRIGGER, 456));
 178
 179   ASSERT_EQ(default_name, trial_2->group_name());
 180
 181   // Run the message loop to make sure OnFieldTrialGroupFinalized is called for
 182   // the two field trials.
 183   base::RunLoop().RunUntilIdle();
 184
 185   GURL url("http://www.google.com");
 186   net::HttpRequestHeaders headers;
 187   provider.AppendHeaders(url, false, false, &headers);
 188   std::string variations;
 189   headers.GetHeader("X-Client-Data", &variations);
 190
 191   std::set<VariationID> variation_ids;
 192   std::set<VariationID> trigger_ids;
 193   ASSERT_TRUE(ExtractVariationIds(variations, &variation_ids, &trigger_ids));
 194   EXPECT_TRUE(variation_ids.find(123) != variation_ids.end());
 195   EXPECT_TRUE(trigger_ids.find(456) != trigger_ids.end());
 196 }
 197
 198 }  // namespace chrome_variations