Unit test for NULL values in preference validation delegate.

chrome/browser/safe_browsing/preference_validation_delegate_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/safe_browsing/preference_validation_delegate.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 65 matching lines @@
   }
 
   const std::string kPrefPath_;
   IncidentVector incidents_;
   scoped_ptr<base::Value> null_value_;
   base::DictionaryValue dict_value_;
   std::vector<std::string> invalid_keys_;
   scoped_ptr<TrackedPreferenceValidationDelegate> instance_;
 };
 
+// Tests that a NULL value results in an incident with no value.
+TEST_F(PreferenceValidationDelegateTest, NullValue) {
+  instance_->OnAtomicPreferenceValidation(kPrefPath_,
+                                          NULL,
+                                          PrefHashStoreTransaction::CLEARED,
+                                          TrackedPreferenceHelper::DONT_RESET);
+  safe_browsing::ClientIncidentReport_IncidentData* incident =
+      incidents_.back();
+  EXPECT_FALSE(incident->tracked_preference().has_atomic_value());

[gab, 2014/06/16 22:33:27]

Optional: instead of returning no serialized value, you may want to return a
special string which you'll know means it was NULL server-side.

This may help in case you somehow start getting reports where the value is
somehow missing; you'd then be able to differentiate NULL values from broken
uploads.

[grt (UTC plus 2), 2014/06/17 02:05:33]

value_state() indicates that it was cleared. i've added this to the test.

+}
+
 // Tests that all supported value types can be stringified into an incident. The
 // parameters for the test are the type of value to test and the expected value
 // string.
 class PreferenceValidationDelegateValues
     : public PreferenceValidationDelegateTest,
       public testing::WithParamInterface<
           std::tr1::tuple<base::Value::Type, const char*> > {
  protected:
   virtual void SetUp() OVERRIDE {
     PreferenceValidationDelegateTest::SetUp();
@@ skipping 33 matching lines @@
   }
 
   base::Value::Type value_type_;
   const char* expected_value_;
 };
 
 TEST_P(PreferenceValidationDelegateValues, Value) {
   instance_->OnAtomicPreferenceValidation(kPrefPath_,
                                           MakeValue(value_type_).get(),
                                           PrefHashStoreTransaction::CLEARED,
                                           TrackedPreferenceHelper::DONT_RESET);

[mattm, 2014/06/16 19:52:15]

add:
ASSERT_EQ(1U, incidents_.size())

[grt (UTC plus 2), 2014/06/17 02:05:33]

Done.

   safe_browsing::ClientIncidentReport_IncidentData* incident =
       incidents_.back();
   EXPECT_EQ(std::string(expected_value_),
             incident->tracked_preference().atomic_value());
 }
 
 INSTANTIATE_TEST_CASE_P(
     Values,
     PreferenceValidationDelegateValues,
     testing::Values(
@@ skipping 57 matching lines @@
     reset_action_ = std::tr1::get<1>(GetParam());
   }
 
   PrefHashStoreTransaction::ValueState value_state_;
   TrackedPreferenceHelper::ResetAction reset_action_;
 };
 
 TEST_P(PreferenceValidationDelegateWithIncident, Atomic) {
   instance_->OnAtomicPreferenceValidation(
       kPrefPath_, null_value_.get(), value_state_, reset_action_);
   EXPECT_EQ(1U, incidents_.size());

[mattm, 2014/06/16 19:52:15]

Should be ASSERT_EQ (same below)

[grt (UTC plus 2), 2014/06/17 02:05:32]

Done.

   safe_browsing::ClientIncidentReport_IncidentData* incident =
       incidents_.back();
   EXPECT_TRUE(incident->has_tracked_preference());
   const safe_browsing::
       ClientIncidentReport_IncidentData_TrackedPreferenceIncident& tp_incident =
           incident->tracked_preference();
   EXPECT_EQ(kPrefPath_, tp_incident.path());
   EXPECT_EQ(0, tp_incident.split_key_size());
   EXPECT_TRUE(tp_incident.has_atomic_value());
   EXPECT_EQ(std::string("null"), tp_incident.atomic_value());
@@ skipping 21 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     WithIncident,
     PreferenceValidationDelegateWithIncident,
     testing::Combine(
         testing::Values(PrefHashStoreTransaction::CLEARED,
                         PrefHashStoreTransaction::WEAK_LEGACY,
                         PrefHashStoreTransaction::CHANGED,
                         PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE),
         testing::Values(TrackedPreferenceHelper::WANTED_RESET,
                         TrackedPreferenceHelper::DO_RESET)));