Make VariationsService simulate received seeds.

chrome/browser/metrics/variations/variations_seed_store_unittest.cc

 // Copyright 2014 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 "chrome/browser/metrics/variations/variations_seed_store.h"
 
 #include "base/base64.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/common/pref_names.h"
 #include "components/variations/proto/study.pb.h"
 #include "components/variations/proto/variations_seed.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_variations {
 
 namespace {
 
 class TestVariationsSeedStore : public VariationsSeedStore {
  public:
   explicit TestVariationsSeedStore(PrefService* local_state)
       : VariationsSeedStore(local_state) {}
   virtual ~TestVariationsSeedStore() {}
 
+  bool StoreSeedForTesting(const std::string& seed_data) {
+    return StoreSeedData(seed_data, std::string(), base::Time::Now(), NULL);
+  }
+
   virtual VariationsSeedStore::VerifySignatureResult VerifySeedSignature(
       const std::string& seed_bytes,
       const std::string& base64_seed_signature) OVERRIDE {
     return VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_ENUM_SIZE;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestVariationsSeedStore);
 };
 
@@ skipping 78 matching lines @@
   EXPECT_TRUE(PrefHasDefaultValue(prefs, prefs::kVariationsSeed));
   EXPECT_TRUE(PrefHasDefaultValue(prefs, prefs::kVariationsSeedDate));
   EXPECT_TRUE(PrefHasDefaultValue(prefs, prefs::kVariationsSeedSignature));
 
   // Check that having no seed in prefs results in a return value of false.
   prefs.ClearPref(prefs::kVariationsSeed);
   EXPECT_FALSE(seed_store.LoadSeed(&loaded_seed));
 }
 
 TEST(VariationsSeedStoreTest, StoreSeedData) {
-  const base::Time now = base::Time::Now();
   const VariationsSeed seed = CreateTestSeed();
   const std::string serialized_seed = SerializeSeed(seed);
 
   TestingPrefServiceSimple prefs;
   VariationsSeedStore::RegisterPrefs(prefs.registry());
 
   TestVariationsSeedStore seed_store(&prefs);
 
-  EXPECT_TRUE(seed_store.StoreSeedData(serialized_seed, std::string(), now));
+  EXPECT_TRUE(seed_store.StoreSeedForTesting(serialized_seed));
   // Make sure the pref was actually set.
   EXPECT_FALSE(PrefHasDefaultValue(prefs, prefs::kVariationsSeed));
 
   std::string loaded_serialized_seed = prefs.GetString(prefs::kVariationsSeed);
   std::string decoded_serialized_seed;
   ASSERT_TRUE(base::Base64Decode(loaded_serialized_seed,
                                  &decoded_serialized_seed));
   // Make sure the stored seed from pref is the same as the seed we created.
   EXPECT_EQ(serialized_seed, decoded_serialized_seed);
 
   // Check if trying to store a bad seed leaves the pref unchanged.
   prefs.ClearPref(prefs::kVariationsSeed);
-  EXPECT_FALSE(seed_store.StoreSeedData("should fail", std::string(), now));
+  EXPECT_FALSE(seed_store.StoreSeedForTesting("should fail"));
   EXPECT_TRUE(PrefHasDefaultValue(prefs, prefs::kVariationsSeed));
 }
 
+TEST(VariationsSeedStoreTest, StoreSeedData_ParsedSeed) {
+  const VariationsSeed seed = CreateTestSeed();
+  const std::string serialized_seed = SerializeSeed(seed);
+
+  TestingPrefServiceSimple prefs;
+  VariationsSeedStore::RegisterPrefs(prefs.registry());
+  TestVariationsSeedStore seed_store(&prefs);
+
+  VariationsSeed parsed_seed;
+  EXPECT_TRUE(seed_store.StoreSeedData(serialized_seed, std::string(),
+                                       base::Time::Now(), &parsed_seed));
+  EXPECT_EQ(serialized_seed, SerializeSeed(parsed_seed));
+}
+
 TEST(VariationsSeedStoreTest, VerifySeedSignature) {
   // The below seed and signature pair were generated using the server's
   // private key.
   const std::string base64_seed_data =
       "CigxZDI5NDY0ZmIzZDc4ZmYxNTU2ZTViNTUxYzY0NDdjYmM3NGU1ZmQwEr0BCh9VTUEtVW5p"
       "Zm9ybWl0eS1UcmlhbC0xMC1QZXJjZW50GICckqUFOAFCB2RlZmF1bHRKCwoHZGVmYXVsdBAB"
       "SgwKCGdyb3VwXzAxEAFKDAoIZ3JvdXBfMDIQAUoMCghncm91cF8wMxABSgwKCGdyb3VwXzA0"
       "EAFKDAoIZ3JvdXBfMDUQAUoMCghncm91cF8wNhABSgwKCGdyb3VwXzA3EAFKDAoIZ3JvdXBf"
       "MDgQAUoMCghncm91cF8wORAB";
   const std::string base64_seed_signature =
@@ skipping 29 matching lines @@
   EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_INVALID_SIGNATURE,
             seed_store.VerifySeedSignature(seed_data, base64_seed_data));
 
   // Using a different seed should not match the signature.
   seed_data[0] = 'x';
   EXPECT_EQ(VariationsSeedStore::VARIATIONS_SEED_SIGNATURE_INVALID_SEED,
             seed_store.VerifySeedSignature(seed_data, base64_seed_signature));
 }
 
 }  // namespace chrome_variations