//
|
// Copyright (C) 2017 The Android Open Source Project
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
//
|
|
#include "update_engine/metrics_reporter_omaha.h"
|
|
#include <memory>
|
#include <string>
|
|
#include <base/time/time.h>
|
#include <gmock/gmock.h>
|
#include <gtest/gtest.h>
|
#include <metrics/metrics_library_mock.h>
|
|
#include "update_engine/common/fake_clock.h"
|
#include "update_engine/common/fake_prefs.h"
|
#include "update_engine/fake_system_state.h"
|
|
using base::TimeDelta;
|
using testing::_;
|
using testing::AnyNumber;
|
using testing::Return;
|
|
namespace chromeos_update_engine {
|
class MetricsReporterOmahaTest : public ::testing::Test {
|
protected:
|
MetricsReporterOmahaTest() = default;
|
|
// Reset the metrics_lib_ to a mock library.
|
void SetUp() override {
|
mock_metrics_lib_ = new testing::NiceMock<MetricsLibraryMock>();
|
reporter_.metrics_lib_.reset(mock_metrics_lib_);
|
}
|
|
testing::NiceMock<MetricsLibraryMock>* mock_metrics_lib_;
|
MetricsReporterOmaha reporter_;
|
};
|
|
TEST_F(MetricsReporterOmahaTest, ReportDailyMetrics) {
|
TimeDelta age = TimeDelta::FromDays(10);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricDailyOSAgeDays, _, _, _, _))
|
.Times(1);
|
|
reporter_.ReportDailyMetrics(age);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportUpdateCheckMetrics) {
|
FakeSystemState fake_system_state;
|
FakeClock fake_clock;
|
FakePrefs fake_prefs;
|
|
// We need to execute the report twice to test the time since last report.
|
fake_system_state.set_clock(&fake_clock);
|
fake_system_state.set_prefs(&fake_prefs);
|
fake_clock.SetWallclockTime(base::Time::FromInternalValue(1000000));
|
fake_clock.SetMonotonicTime(base::Time::FromInternalValue(1000000));
|
|
metrics::CheckResult result = metrics::CheckResult::kUpdateAvailable;
|
metrics::CheckReaction reaction = metrics::CheckReaction::kIgnored;
|
metrics::DownloadErrorCode error_code =
|
metrics::DownloadErrorCode::kHttpStatus200;
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricCheckResult, static_cast<int>(result), _))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(
|
metrics::kMetricCheckReaction, static_cast<int>(reaction), _))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckDownloadErrorCode,
|
static_cast<int>(error_code)))
|
.Times(2);
|
|
// Not pinned nor rollback
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckTargetVersion, _))
|
.Times(0);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckRollbackTargetVersion, _))
|
.Times(0);
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricCheckTimeSinceLastCheckMinutes, 1, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricCheckTimeSinceLastCheckUptimeMinutes, 1, _, _, _))
|
.Times(1);
|
|
reporter_.ReportUpdateCheckMetrics(
|
&fake_system_state, result, reaction, error_code);
|
|
// Advance the clock by 1 minute and report the same metrics again.
|
fake_clock.SetWallclockTime(base::Time::FromInternalValue(61000000));
|
fake_clock.SetMonotonicTime(base::Time::FromInternalValue(61000000));
|
// Allow rollback
|
reporter_.ReportUpdateCheckMetrics(
|
&fake_system_state, result, reaction, error_code);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportUpdateCheckMetricsPinned) {
|
FakeSystemState fake_system_state;
|
|
OmahaRequestParams params(&fake_system_state);
|
params.set_target_version_prefix("10575.");
|
params.set_rollback_allowed(false);
|
fake_system_state.set_request_params(¶ms);
|
|
metrics::CheckResult result = metrics::CheckResult::kUpdateAvailable;
|
metrics::CheckReaction reaction = metrics::CheckReaction::kIgnored;
|
metrics::DownloadErrorCode error_code =
|
metrics::DownloadErrorCode::kHttpStatus200;
|
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckDownloadErrorCode, _));
|
// Target version set, but not a rollback.
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckTargetVersion, 10575))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckRollbackTargetVersion, _))
|
.Times(0);
|
|
reporter_.ReportUpdateCheckMetrics(
|
&fake_system_state, result, reaction, error_code);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportUpdateCheckMetricsRollback) {
|
FakeSystemState fake_system_state;
|
|
OmahaRequestParams params(&fake_system_state);
|
params.set_target_version_prefix("10575.");
|
params.set_rollback_allowed(true);
|
fake_system_state.set_request_params(¶ms);
|
|
metrics::CheckResult result = metrics::CheckResult::kUpdateAvailable;
|
metrics::CheckReaction reaction = metrics::CheckReaction::kIgnored;
|
metrics::DownloadErrorCode error_code =
|
metrics::DownloadErrorCode::kHttpStatus200;
|
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckDownloadErrorCode, _));
|
// Rollback.
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckTargetVersion, 10575))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricCheckRollbackTargetVersion, 10575))
|
.Times(1);
|
|
reporter_.ReportUpdateCheckMetrics(
|
&fake_system_state, result, reaction, error_code);
|
}
|
|
TEST_F(MetricsReporterOmahaTest,
|
ReportAbnormallyTerminatedUpdateAttemptMetrics) {
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricAttemptResult,
|
static_cast<int>(
|
metrics::AttemptResult::kAbnormalTermination),
|
_))
|
.Times(1);
|
|
reporter_.ReportAbnormallyTerminatedUpdateAttemptMetrics();
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportUpdateAttemptMetrics) {
|
FakeSystemState fake_system_state;
|
FakeClock fake_clock;
|
FakePrefs fake_prefs;
|
|
fake_system_state.set_clock(&fake_clock);
|
fake_system_state.set_prefs(&fake_prefs);
|
fake_clock.SetWallclockTime(base::Time::FromInternalValue(1000000));
|
fake_clock.SetMonotonicTime(base::Time::FromInternalValue(1000000));
|
|
int attempt_number = 1;
|
PayloadType payload_type = kPayloadTypeFull;
|
TimeDelta duration = TimeDelta::FromMinutes(1000);
|
TimeDelta duration_uptime = TimeDelta::FromMinutes(1000);
|
|
int64_t payload_size = 100 * kNumBytesInOneMiB;
|
|
metrics::AttemptResult attempt_result =
|
metrics::AttemptResult::kInternalError;
|
ErrorCode internal_error_code = ErrorCode::kDownloadInvalidMetadataSignature;
|
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptNumber, attempt_number, _, _, _))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricAttemptPayloadType,
|
static_cast<int>(payload_type),
|
_))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptDurationMinutes,
|
duration.InMinutes(),
|
_,
|
_,
|
_))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptDurationUptimeMinutes,
|
duration_uptime.InMinutes(),
|
_,
|
_,
|
_))
|
.Times(2);
|
|
// Check the report of attempt result.
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendEnumToUMA(
|
metrics::kMetricAttemptResult, static_cast<int>(attempt_result), _))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricAttemptInternalErrorCode,
|
static_cast<int>(internal_error_code),
|
_))
|
.Times(2);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptPayloadSizeMiB, 100, _, _, _))
|
.Times(2);
|
|
// Check the duration between two reports.
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptTimeSinceLastAttemptMinutes, 1, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricAttemptTimeSinceLastAttemptUptimeMinutes, 1, _, _, _))
|
.Times(1);
|
|
reporter_.ReportUpdateAttemptMetrics(&fake_system_state,
|
attempt_number,
|
payload_type,
|
duration,
|
duration_uptime,
|
payload_size,
|
attempt_result,
|
internal_error_code);
|
|
// Advance the clock by 1 minute and report the same metrics again.
|
fake_clock.SetWallclockTime(base::Time::FromInternalValue(61000000));
|
fake_clock.SetMonotonicTime(base::Time::FromInternalValue(61000000));
|
reporter_.ReportUpdateAttemptMetrics(&fake_system_state,
|
attempt_number,
|
payload_type,
|
duration,
|
duration_uptime,
|
payload_size,
|
attempt_result,
|
internal_error_code);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportUpdateAttemptDownloadMetrics) {
|
int64_t payload_bytes_downloaded = 200 * kNumBytesInOneMiB;
|
int64_t payload_download_speed_bps = 100 * 1000;
|
DownloadSource download_source = kDownloadSourceHttpServer;
|
metrics::DownloadErrorCode payload_download_error_code =
|
metrics::DownloadErrorCode::kDownloadError;
|
metrics::ConnectionType connection_type = metrics::ConnectionType::kCellular;
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptPayloadBytesDownloadedMiB, 200, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricAttemptPayloadDownloadSpeedKBps, 100, _, _, _))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricAttemptDownloadSource,
|
static_cast<int>(download_source),
|
_))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricAttemptDownloadErrorCode,
|
static_cast<int>(payload_download_error_code)))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricAttemptConnectionType,
|
static_cast<int>(connection_type),
|
_))
|
.Times(1);
|
|
reporter_.ReportUpdateAttemptDownloadMetrics(payload_bytes_downloaded,
|
payload_download_speed_bps,
|
download_source,
|
payload_download_error_code,
|
connection_type);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportSuccessfulUpdateMetrics) {
|
int attempt_count = 3;
|
int updates_abandoned_count = 2;
|
PayloadType payload_type = kPayloadTypeDelta;
|
int64_t payload_size = 200 * kNumBytesInOneMiB;
|
int64_t num_bytes_downloaded[kNumDownloadSources] = {};
|
// 200MiB payload downloaded from HttpsServer.
|
num_bytes_downloaded[0] = 200 * kNumBytesInOneMiB;
|
int download_overhead_percentage = 20;
|
TimeDelta total_duration = TimeDelta::FromMinutes(30);
|
TimeDelta total_duration_uptime = TimeDelta::FromMinutes(20);
|
int reboot_count = 2;
|
int url_switch_count = 2;
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdatePayloadSizeMiB, 200, _, _, _))
|
.Times(1);
|
|
// Check the report to both BytesDownloadedMiBHttpsServer and
|
// BytesDownloadedMiB
|
std::string DownloadedMiBMetric =
|
metrics::kMetricSuccessfulUpdateBytesDownloadedMiB;
|
DownloadedMiBMetric += "HttpsServer";
|
EXPECT_CALL(*mock_metrics_lib_, SendToUMA(DownloadedMiBMetric, 200, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateBytesDownloadedMiB, 200, _, _, _))
|
.Times(1);
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateDownloadSourcesUsed, 1, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdateDownloadOverheadPercentage,
|
20,
|
_,
|
_,
|
_));
|
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdateUrlSwitchCount,
|
url_switch_count,
|
_,
|
_,
|
_))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateTotalDurationMinutes, 30, _, _, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdateTotalDurationUptimeMinutes,
|
20,
|
_,
|
_,
|
_))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateRebootCount, reboot_count, _, _, _))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(
|
metrics::kMetricSuccessfulUpdatePayloadType, payload_type, _))
|
.Times(1);
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateAttemptCount, attempt_count, _, _, _))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdateUpdatesAbandonedCount,
|
updates_abandoned_count,
|
_,
|
_,
|
_))
|
.Times(1);
|
|
reporter_.ReportSuccessfulUpdateMetrics(attempt_count,
|
updates_abandoned_count,
|
payload_type,
|
payload_size,
|
num_bytes_downloaded,
|
download_overhead_percentage,
|
total_duration,
|
total_duration_uptime,
|
reboot_count,
|
url_switch_count);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportRollbackMetrics) {
|
metrics::RollbackResult result = metrics::RollbackResult::kSuccess;
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(
|
metrics::kMetricRollbackResult, static_cast<int>(result), _))
|
.Times(1);
|
|
reporter_.ReportRollbackMetrics(result);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportEnterpriseRollbackMetrics) {
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricEnterpriseRollbackSuccess, 10575))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricEnterpriseRollbackFailure, 10323))
|
.Times(1);
|
|
reporter_.ReportEnterpriseRollbackMetrics(/*success=*/true, "10575.39.2");
|
reporter_.ReportEnterpriseRollbackMetrics(/*success=*/false, "10323.67.7");
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportCertificateCheckMetrics) {
|
ServerToCheck server_to_check = ServerToCheck::kUpdate;
|
CertificateCheckResult result = CertificateCheckResult::kValid;
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricCertificateCheckUpdateCheck,
|
static_cast<int>(result),
|
_))
|
.Times(1);
|
|
reporter_.ReportCertificateCheckMetrics(server_to_check, result);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportFailedUpdateCount) {
|
int target_attempt = 3;
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricFailedUpdateCount, target_attempt, _, _, _))
|
.Times(1);
|
|
reporter_.ReportFailedUpdateCount(target_attempt);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportTimeToReboot) {
|
int time_to_reboot_minutes = 1000;
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricTimeToRebootMinutes, time_to_reboot_minutes, _, _, _))
|
.Times(1);
|
|
reporter_.ReportTimeToReboot(time_to_reboot_minutes);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportInstallDateProvisioningSource) {
|
int source = 2;
|
int max = 5;
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendEnumToUMA(metrics::kMetricInstallDateProvisioningSource, source, max))
|
.Times(1);
|
|
reporter_.ReportInstallDateProvisioningSource(source, max);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportKeyVersionMetrics) {
|
int kernel_min_version = 0x00040002;
|
int kernel_max_rollforward_version = 0xfffffffe;
|
bool kernel_max_rollforward_success = true;
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricKernelMinVersion, kernel_min_version))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendSparseToUMA(metrics::kMetricKernelMaxRollforwardVersion,
|
kernel_max_rollforward_version))
|
.Times(1);
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendBoolToUMA(metrics::kMetricKernelMaxRollforwardSetSuccess,
|
kernel_max_rollforward_success))
|
.Times(1);
|
|
reporter_.ReportKeyVersionMetrics(kernel_min_version,
|
kernel_max_rollforward_version,
|
kernel_max_rollforward_success);
|
}
|
|
TEST_F(MetricsReporterOmahaTest, ReportEnterpriseUpdateSeenToDownloadDays) {
|
constexpr int kDaysToUpdate = 10;
|
constexpr int kMinBucket = 1;
|
constexpr int kMaxBucket = 6 * 30; // approximately 6 months
|
constexpr int kNumBuckets = 50;
|
|
EXPECT_CALL(*mock_metrics_lib_,
|
SendToUMA(metrics::kMetricSuccessfulUpdateDurationFromSeenDays,
|
kDaysToUpdate,
|
kMinBucket,
|
kMaxBucket,
|
kNumBuckets))
|
.Times(1);
|
|
reporter_.ReportEnterpriseUpdateSeenToDownloadDays(
|
false /* has_time_restriction_policy */, kDaysToUpdate);
|
}
|
|
TEST_F(MetricsReporterOmahaTest,
|
ReportEnterpriseTimeRestrictedUpdateSeenToDownloadTime) {
|
const int kDaysToUpdate = 15;
|
constexpr int kMinBucket = 1;
|
constexpr int kMaxBucket = 6 * 30; // approximately 6 months
|
constexpr int kNumBuckets = 50;
|
|
EXPECT_CALL(
|
*mock_metrics_lib_,
|
SendToUMA(
|
metrics::kMetricSuccessfulUpdateDurationFromSeenTimeRestrictedDays,
|
kDaysToUpdate,
|
kMinBucket,
|
kMaxBucket,
|
kNumBuckets))
|
.Times(1);
|
|
reporter_.ReportEnterpriseUpdateSeenToDownloadDays(
|
true /* has_time_restriction_policy */, kDaysToUpdate);
|
}
|
|
} // namespace chromeos_update_engine
|
