Allow use of metrics url override outside of Chromecast

components/metrics/metrics_service_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 "components/metrics/metrics_service.h"
 
 #include <string>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/prefs/testing_pref_service.h"
+#include "base/strings/string16.h"
 #include "base/threading/platform_thread.h"
 #include "components/metrics/client_info.h"
 #include "components/metrics/compression_utils.h"
 #include "components/metrics/metrics_hashes.h"
 #include "components/metrics/metrics_log.h"
+#include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_state_manager.h"
+#include "components/metrics/metrics_switches.h"
+#include "components/metrics/mock_metrics_service_client.h"
+#include "components/metrics/proto/system_profile.pb.h"
 #include "components/metrics/test_metrics_service_client.h"
 #include "components/variations/metrics_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::Return;
+using ::testing::_;
+
 namespace metrics {
 
 namespace {
 
 void StoreNoClientInfoBackup(const ClientInfo& /* client_info */) {
 }
 
 scoped_ptr<ClientInfo> ReturnNoBackup() {
   return scoped_ptr<ClientInfo>();
 }
@@ skipping 48 matching lines @@
                    MetricsLog::ONGOING_LOG,
                    client,
                    local_state) {}
 
   ~TestMetricsLog() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
 };
 
+class TestMetricsLogUploader : public MetricsLogUploader {
+ public:
+  TestMetricsLogUploader(
+      const std::string& server_url,
+      const std::string& mime_type,
+      const base::Callback<void(int)>& on_upload_complete):
+    MetricsLogUploader(server_url, mime_type, on_upload_complete) {}
+
+  ~TestMetricsLogUploader() override {}
+
+  bool UploadLog(const std::string& compressed_log_data,
+                 const std::string& log_hash) override {
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestMetricsLogUploader);
+};
+
 class MetricsServiceTest : public testing::Test {
  public:
   MetricsServiceTest() : is_metrics_reporting_enabled_(false) {
     MetricsService::RegisterPrefs(testing_local_state_.registry());
     metrics_state_manager_ = MetricsStateManager::Create(
         GetLocalState(),
         base::Bind(&MetricsServiceTest::is_metrics_reporting_enabled,
                    base::Unretained(this)),
         base::Bind(&StoreNoClientInfoBackup),
         base::Bind(&ReturnNoBackup));
   }
 
   ~MetricsServiceTest() override {
     MetricsService::SetExecutionPhase(MetricsService::UNINITIALIZED_PHASE,
                                       GetLocalState());
   }
 
   MetricsStateManager* GetMetricsStateManager() {
     return metrics_state_manager_.get();
   }
 
   PrefService* GetLocalState() { return &testing_local_state_; }
 
   // Sets metrics reporting as enabled for testing.
   void EnableMetricsReporting() {
     is_metrics_reporting_enabled_ = true;
   }
 
+  void PopulateStabilityLog(MetricsServiceClient& client,
+                            bool exited_cleanly) {
+    // Record stability build time and version from previous session, so that
+    // stability metrics (including exited cleanly flag) won't be cleared.
+    testing_local_state_.SetInt64(prefs::kStabilityStatsBuildTime,
+                                  MetricsLog::GetBuildTime());
+    testing_local_state_.SetString(prefs::kStabilityStatsVersion,
+                                   client.GetVersionString());
+
+    // Set the clean exit flag, as that will otherwise cause a stabilty
+    // log to be produced, irrespective provider requests.
+    testing_local_state_.SetBoolean(
+        prefs::kStabilityExitedCleanly, exited_cleanly);
+  }
+
   // Waits until base::TimeTicks::Now() no longer equals |value|. This should
   // take between 1-15ms per the documented resolution of base::TimeTicks.
   void WaitUntilTimeChanges(const base::TimeTicks& value) {
     while (base::TimeTicks::Now() == value) {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
     }
   }
 
   // Returns true if there is a synthetic trial in the given vector that matches
   // the given trial name and trial group; returns false otherwise.
@@ skipping 79 matching lines @@
   EnableMetricsReporting();
 
   // Save an existing system profile to prefs, to correspond to what would be
   // saved from a previous session.
   TestMetricsServiceClient client;
   TestMetricsLog log("client", 1, &client, GetLocalState());
   log.RecordEnvironment(std::vector<MetricsProvider*>(),
                         std::vector<variations::ActiveGroupId>(),
                         0);
 
-  // Record stability build time and version from previous session, so that
-  // stability metrics (including exited cleanly flag) won't be cleared.
-  GetLocalState()->SetInt64(prefs::kStabilityStatsBuildTime,
-                            MetricsLog::GetBuildTime());
-  GetLocalState()->SetString(prefs::kStabilityStatsVersion,
-                             client.GetVersionString());
-
-  // Set the clean exit flag, as that will otherwise cause a stabilty
-  // log to be produced, irrespective provider requests.
-  GetLocalState()->SetBoolean(prefs::kStabilityExitedCleanly, true);
+  PopulateStabilityLog(client, true);
 
   TestMetricsService service(
       GetMetricsStateManager(), &client, GetLocalState());
   // Add a metrics provider that requests a stability log.
   TestMetricsProvider* test_provider = new TestMetricsProvider(true);
   service.RegisterMetricsProvider(
       scoped_ptr<MetricsProvider>(test_provider));
 
   service.InitializeMetricsRecordingState();
 
@@ skipping 35 matching lines @@
 
   // Set up prefs to simulate restarting after a crash.
 
   // Save an existing system profile to prefs, to correspond to what would be
   // saved from a previous session.
   TestMetricsServiceClient client;
   TestMetricsLog log("client", 1, &client, GetLocalState());
   log.RecordEnvironment(std::vector<MetricsProvider*>(),
                         std::vector<variations::ActiveGroupId>(),
                         0);
-
-  // Record stability build time and version from previous session, so that
-  // stability metrics (including exited cleanly flag) won't be cleared.
-  GetLocalState()->SetInt64(prefs::kStabilityStatsBuildTime,
-                            MetricsLog::GetBuildTime());
-  GetLocalState()->SetString(prefs::kStabilityStatsVersion,
-                             client.GetVersionString());
-
-  GetLocalState()->SetBoolean(prefs::kStabilityExitedCleanly, false);
+  PopulateStabilityLog(client, false);
 
   TestMetricsService service(
       GetMetricsStateManager(), &client, GetLocalState());
   service.InitializeMetricsRecordingState();
 
   // The initial stability log should be generated and persisted in unsent logs.
   MetricsLogManager* log_manager = service.log_manager();
   EXPECT_TRUE(log_manager->has_unsent_logs());
   EXPECT_FALSE(log_manager->has_staged_log());
 
@@ skipping 75 matching lines @@
       scoped_ptr<MetricsLog>(new MetricsLog(
           "clientID", 1, MetricsLog::ONGOING_LOG, &client, GetLocalState())));
   service.GetCurrentSyntheticFieldTrials(&synthetic_trials);
   EXPECT_EQ(3U, synthetic_trials.size());
   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial1", "Group2"));
   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial2", "Group2"));
   EXPECT_TRUE(HasSyntheticTrial(synthetic_trials, "TestTrial3", "Group3"));
   service.log_manager_.FinishCurrentLog();
 }
 
+TEST_F(MetricsServiceTest, ServerUrlOverrideSet) {
+  EnableMetricsReporting();
+
+  std::string server_url = "https://127.0.0.1/v2";
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  // This is the switch that we want to test.
+  command_line->AppendSwitchASCII(switches::kOverrideMetricsUploadUrl,
+                                  server_url);
+
+  MockMetricsServiceClient client;
+  EXPECT_CALL(client, GetRegistryBackupKey())
+    .WillOnce(Return(base::string16()));
+  EXPECT_CALL(client, GetChannel())
+    .WillRepeatedly(Return(SystemProfileProto::CHANNEL_UNKNOWN));
+  // The main expectation of this test: ensures that when the command line
+  // switch is set, the uploader is created with the correct url.
+  EXPECT_CALL(client, MockCreateUploader(server_url, _, _))
+    .WillOnce(Return(new TestMetricsLogUploader(server_url, "mime_type",
+        base::Bind(&MockMetricsServiceClient::DoNothing,
+                   base::Unretained(&client)))));
+
+  // Generate a set of logs for upload
+  TestMetricsLog log("client", 1, &client, GetLocalState());
+  log.RecordEnvironment(std::vector<MetricsProvider*>(),
+                        std::vector<variations::ActiveGroupId>(),
+                        0);
+  PopulateStabilityLog(client, true);
+
+  MetricsService service(GetMetricsStateManager(), &client, GetLocalState());
+  TestMetricsProvider* test_provider = new TestMetricsProvider(true);
+  service.RegisterMetricsProvider(
+      scoped_ptr<MetricsProvider>(test_provider));
+  service.InitializeMetricsRecordingState();
+  EXPECT_TRUE(service.log_manager()->has_unsent_logs());
+
+  service.log_manager()->StageNextLogForUpload();
+  EXPECT_TRUE(service.log_manager()->has_staged_log());
+
+  service.SendStagedLog();
+}
+
 }  // namespace metrics