Tests for cloud policy UMA metrics.

chrome/browser/policy/enterprise_metrics_browsertest.cc

+// Copyright (c) 2011 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 "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "chrome/browser/chromeos/login/enterprise_enrollment_screen.h"
+#include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/chromeos/login/wizard_in_process_browser_test.h"
+#include "chrome/browser/policy/enterprise_metrics.h"
+#include "chrome/common/net/gaia/gaia_constants.h"
+#include "content/common/test_url_fetcher_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace {
+
+void assert_handler(const std::string& str) {
+  LOG(INFO) << "Previous failure was expected, ignoring.";
+}
+
+}  // namespace
+
+class EnterpriseMetricsBrowserTest : public WizardInProcessBrowserTest {
+ protected:
+  EnterpriseMetricsBrowserTest()
+      : WizardInProcessBrowserTest(
+            WizardController::kEnterpriseEnrollmentScreenName) {}
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    WizardInProcessBrowserTest::SetUpOnMainThread();
+
+    ASSERT_TRUE(controller() != NULL);
+
+    // Use mock URLFetchers.
+    URLFetcher::set_factory(&factory_);
+
+    screen_ = controller()->GetEnterpriseEnrollmentScreen();
+
+    ASSERT_TRUE(screen_ != NULL);
+    ASSERT_EQ(controller()->current_screen(), screen_);
+  }
+
+  virtual void CleanUpOnMainThread() OVERRIDE {
+    WizardInProcessBrowserTest::CleanUpOnMainThread();
+
+    // Check that no other counters were sampled.
+    base::Histogram::SampleSet samples;
+    GetSampleSet(&samples);
+    EXPECT_EQ(1, samples.TotalCount());
+  }
+
+  // This is used to let expected NOTREACHED paths go on instead of making
+  // the test fail. It will also let CHECKs and DCHECKs pass, but that should be
+  // tested elsewhere.
+  void ExpectNOTREACHED() {
+    logging::SetLogAssertHandler(assert_handler);
+  }
+
+  void ExpectSample(int sample) {
+    ASSERT_GE(sample, 0);
+    ASSERT_LT(sample, policy::kMetricEnrollmentSize);
+
+    base::Histogram::SampleSet samples;
+    GetSampleSet(&samples);
+    EXPECT_EQ(1, samples.counts(sample));
+  }
+
+  EnterpriseEnrollmentScreen* screen_;
+
+ private:
+  void GetSampleSet(base::Histogram::SampleSet* set) {
+    base::Histogram* histogram = NULL;
+    EXPECT_TRUE(base::StatisticsRecorder::FindHistogram(
+        policy::kMetricEnrollment, &histogram));
+    ASSERT_TRUE(histogram != NULL);
+    histogram->SnapshotSample(set);
+  }
+
+  TestURLFetcherFactory factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(EnterpriseMetricsBrowserTest);
+};
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, EnrollmentStart) {
+  std::string empty;
+  screen_->Authenticate(empty, empty, empty, empty);
+  ExpectSample(policy::kMetricEnrollmentStarted);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, EnrollmentCancelled) {
+  screen_->CancelEnrollment();
+  ExpectSample(policy::kMetricEnrollmentCancelled);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthTokenWrongService) {
+  ExpectNOTREACHED();
+  screen_->OnIssueAuthTokenSuccess(std::string(), std::string());
+  ExpectSample(policy::kMetricEnrollmentOtherFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest,
+                       AuthTokenCloudPolicyNotReady) {
+  ExpectNOTREACHED();
+  screen_->OnIssueAuthTokenSuccess(GaiaConstants::kDeviceManagementService,
+                                   std::string());
+  ExpectSample(policy::kMetricEnrollmentOtherFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthTokenFailure) {
+  ExpectNOTREACHED();
+  GoogleServiceAuthError error(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
+  screen_->OnIssueAuthTokenFailure(std::string(), error);
+  ExpectSample(policy::kMetricEnrollmentOtherFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, OnPolicyBadToken) {
+  screen_->OnPolicyStateChanged(policy::CloudPolicySubsystem::BAD_GAIA_TOKEN,
+                                policy::CloudPolicySubsystem::NO_DETAILS);
+  ExpectSample(policy::kMetricEnrollmentPolicyFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, OnPolicyNetworkError) {
+  screen_->OnPolicyStateChanged(policy::CloudPolicySubsystem::NETWORK_ERROR,
+                                policy::CloudPolicySubsystem::NO_DETAILS);
+  ExpectSample(policy::kMetricEnrollmentPolicyFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, OnPolicyUnmanaged) {
+  screen_->OnPolicyStateChanged(policy::CloudPolicySubsystem::UNMANAGED,
+                                policy::CloudPolicySubsystem::NO_DETAILS);
+  ExpectSample(policy::kMetricEnrollmentNotSupported);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, EnrollmentOK) {
+  screen_->OnPolicyStateChanged(policy::CloudPolicySubsystem::SUCCESS,
+                                policy::CloudPolicySubsystem::NO_DETAILS);
+  ExpectSample(policy::kMetricEnrollmentOK);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthErrorConnection) {
+  GoogleServiceAuthError error(GoogleServiceAuthError::CONNECTION_FAILED);
+  screen_->OnClientLoginFailure(error);
+  ExpectSample(policy::kMetricEnrollmentNetworkFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthErrorLoginFailed) {
+  GoogleServiceAuthError error(GoogleServiceAuthError::TWO_FACTOR);
+  screen_->OnClientLoginFailure(error);
+  ExpectSample(policy::kMetricEnrollmentLoginFailed);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthErrorAccountDisabled) {
+  GoogleServiceAuthError error(GoogleServiceAuthError::ACCOUNT_DISABLED);
+  screen_->OnClientLoginFailure(error);
+  ExpectSample(policy::kMetricEnrollmentNotSupported);
+}
+
+IN_PROC_BROWSER_TEST_F(EnterpriseMetricsBrowserTest, AuthErrorUnexpected) {
+  GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
+  screen_->OnClientLoginFailure(error);
+  ExpectSample(policy::kMetricEnrollmentNetworkFailed);
+}
+
+}  // namespace chromeos