Metrics for feature engagement tracker.

components/feature_engagement_tracker/internal/chrome_variations_configuration_unittest.cc

 // Copyright 2017 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/feature_engagement_tracker/internal/chrome_variations_configuration.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_param_associator.h"
 #include "base/metrics/field_trial_params.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "components/feature_engagement_tracker/internal/configuration.h"
+#include "components/feature_engagement_tracker/internal/stats.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace feature_engagement_tracker {
 
 namespace {
 
 const base::Feature kTestFeatureFoo{"test_foo",
                                     base::FEATURE_DISABLED_BY_DEFAULT};
 const base::Feature kTestFeatureBar{"test_bar",
                                     base::FEATURE_DISABLED_BY_DEFAULT};
 const base::Feature kTestFeatureQux{"test_qux",
                                     base::FEATURE_DISABLED_BY_DEFAULT};
 
 const char kFooTrialName[] = "FooTrial";
 const char kBarTrialName[] = "BarTrial";
 const char kQuxTrialName[] = "QuxTrial";
 const char kGroupName[] = "Group1";
+const char kConfigParseEventName[] = "InProductHelp.Config.ParsingEvent";
 
 class ChromeVariationsConfigurationTest : public ::testing::Test {
  public:
   ChromeVariationsConfigurationTest() : field_trials_(nullptr) {
     base::FieldTrial* foo_trial =
         base::FieldTrialList::CreateFieldTrial(kFooTrialName, kGroupName);
     base::FieldTrial* bar_trial =
         base::FieldTrialList::CreateFieldTrial(kBarTrialName, kGroupName);
     base::FieldTrial* qux_trial =
         base::FieldTrialList::CreateFieldTrial(kQuxTrialName, kGroupName);
@@ skipping 61 matching lines @@
 
 }  // namespace
 
 TEST_F(ChromeVariationsConfigurationTest,
        DisabledFeatureShouldHaveInvalidConfig) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitWithFeatures({}, {kTestFeatureFoo});
 
   FeatureVector features;
   features.push_back(&kTestFeatureFoo);
+  base::HistogramTester histogram_tester;
 
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo_config = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo_config.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_NO_FIELD_TRIAL), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 1);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, ParseSingleFeature) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] =
       "name:page_download_started;comparator:any;window:0;storage:360";
   foo_params["event_trigger"] =
       "name:opened_chrome_home;comparator:any;window:0;storage:360";
   foo_params["event_1"] =
       "name:user_has_seen_dino;comparator:>=1;window:120;storage:180";
   foo_params["event_2"] =
       "name:user_opened_app_menu;comparator:<=0;window:120;storage:180";
   foo_params["event_3"] =
       "name:user_opened_downloads_home;comparator:any;window:0;storage:360";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_TRUE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::SUCCESS), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 1);
 
   FeatureConfig expected_foo;
   expected_foo.valid = true;
   expected_foo.used =
       EventConfig("page_download_started", Comparator(ANY, 0), 0, 360);
   expected_foo.trigger =
       EventConfig("opened_chrome_home", Comparator(ANY, 0), 0, 360);
   expected_foo.event_configs.insert(EventConfig(
       "user_has_seen_dino", Comparator(GREATER_THAN_OR_EQUAL, 1), 120, 180));
   expected_foo.event_configs.insert(EventConfig(
       "user_opened_app_menu", Comparator(LESS_THAN_OR_EQUAL, 0), 120, 180));
   expected_foo.event_configs.insert(
       EventConfig("user_opened_downloads_home", Comparator(ANY, 0), 0, 360));
   EXPECT_EQ(expected_foo, foo);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, MissingUsedIsInvalid) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_USED_EVENT_MISSING),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 2);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, MissingTriggerIsInvalid) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:0;storage:360";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(
+          stats::ConfigParsingEvent::FAILURE_TRIGGER_EVENT_MISSING),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 2);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, OnlyTriggerAndUsedIsValid) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:0;storage:360";
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_TRUE(foo.valid);
 
   FeatureConfig expected_foo;
   expected_foo.valid = true;
   expected_foo.used = EventConfig("eu", Comparator(ANY, 0), 0, 360);
   expected_foo.trigger = EventConfig("et", Comparator(ANY, 0), 0, 360);
   EXPECT_EQ(expected_foo, foo);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::SUCCESS), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 1);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, WhitespaceIsValid) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] =
       " name : eu ; comparator : any ; window : 1 ; storage : 320 ";
   foo_params["event_trigger"] =
       " name:et;comparator : any ;window: 2;storage:330 ";
   foo_params["event_0"] = "name:e0;comparator: <1 ;window:3\n;storage:340";
   foo_params["event_1"] = "name:e1;comparator:  > 2 ;window:4;\rstorage:350";
@@ skipping 121 matching lines @@
 }
 
 TEST_F(ChromeVariationsConfigurationTest,
        InvalidSessionRateCausesInvalidConfig) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:1;storage:360";
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   foo_params["session_rate"] = "bogus value";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_SESSION_RATE_PARSE),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 2);
 }
 
 TEST_F(ChromeVariationsConfigurationTest,
        InvalidAvailabilityCausesInvalidConfig) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:0;storage:360";
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   foo_params["availability"] = "bogus value";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_AVAILABILITY_PARSE),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 2);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, InvalidUsedCausesInvalidConfig) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "bogus value";
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_USED_EVENT_PARSE), 1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_USED_EVENT_MISSING),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 3);
 }
 
 TEST_F(ChromeVariationsConfigurationTest, InvalidTriggerCausesInvalidConfig) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:0;storage:360";
   foo_params["event_trigger"] = "bogus value";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
+  base::HistogramTester histogram_tester;
   std::vector<const base::Feature*> features = {&kTestFeatureFoo};
   configuration_.ParseFeatureConfigs(features);
 
   FeatureConfig foo = configuration_.GetFeatureConfig(kTestFeatureFoo);
   EXPECT_FALSE(foo.valid);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE_TRIGGER_EVENT_PARSE),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(
+          stats::ConfigParsingEvent::FAILURE_TRIGGER_EVENT_MISSING),
+      1);
+  histogram_tester.ExpectBucketCount(
+      kConfigParseEventName,
+      static_cast<int>(stats::ConfigParsingEvent::FAILURE), 1);
+  histogram_tester.ExpectTotalCount(kConfigParseEventName, 3);
 }
 
 TEST_F(ChromeVariationsConfigurationTest,
        InvalidEventConfigCausesInvalidConfig) {
   std::map<std::string, std::string> foo_params;
   foo_params["event_used"] = "name:eu;comparator:any;window:0;storage:360";
   foo_params["event_trigger"] = "name:et;comparator:any;window:0;storage:360";
   foo_params["event_used_0"] = "bogus value";
   SetFeatureParams(kTestFeatureFoo, foo_params);
 
@@ skipping 137 matching lines @@
   expected_qux.event_configs.insert(
       EventConfig("q4", Comparator(EQUAL, 14), 24, 34));
   expected_qux.event_configs.insert(
       EventConfig("q5", Comparator(NOT_EQUAL, 15), 25, 35));
   expected_qux.session_rate = Comparator(NOT_EQUAL, 13);
   expected_qux.availability = Comparator(EQUAL, 0);
   EXPECT_EQ(expected_qux, qux);
 }
 
 }  // namespace feature_engagement_tracker