| // Copyright 2019 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/enterprise/browser/reporting/report_uploader.h" |
| |
| #include <array> |
| #include <utility> |
| |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/task_environment.h" |
| #include "base/test/test_future.h" |
| #include "build/build_config.h" |
| #include "components/enterprise/browser/reporting/report_request.h" |
| #include "components/enterprise/browser/reporting/report_type.h" |
| #include "components/policy/core/common/cloud/cloud_policy_constants.h" |
| #include "components/policy/core/common/cloud/mock_cloud_policy_client.h" |
| #include "device_management_backend.pb.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using ::testing::_; |
| using ::testing::Eq; |
| using ::testing::InSequence; |
| using ::testing::Property; |
| using ::testing::WithArgs; |
| |
| namespace em = enterprise_management; |
| |
| namespace enterprise_reporting { |
| namespace { |
| constexpr const auto kBrowserVersionNames = |
| std::to_array<const char*>({"name1", "name2"}); |
| constexpr char kResponseMetricsName[] = "Enterprise.CloudReportingResponse"; |
| |
| // Returns a function that schedules a callback it is passed as second parameter |
| // with the given result. Useful to test `UploadReport` function. |
| auto ScheduleResponse(policy::CloudPolicyClient::Result result) { |
| return [result](auto /*report*/, auto callback) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), result)); |
| }; |
| } |
| |
| // Returns a function that schedules a callback it is passed as second parameter |
| // with the given result. Useful to test `UploadReport` function. |
| auto ScheduleProfileResponse(policy::CloudPolicyClient::Result result) { |
| return [result](bool /*use_cookies*/, auto /*report*/, auto callback) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), result)); |
| }; |
| } |
| |
| } // namespace |
| |
| class ReportUploaderTest : public ::testing::Test { |
| protected: |
| // Different CloudPolicyClient functions will be used in test cases based |
| // on the current operation system. They share same retry and error handling |
| // behaviors provided by ReportUploader. |
| #if BUILDFLAG(IS_CHROMEOS) |
| #define UploadReport UploadChromeOsUserReport |
| #else |
| #define UploadReport UploadChromeDesktopReport |
| #endif |
| |
| ReportUploaderTest() |
| : task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME) { |
| CreateUploader(0); |
| } |
| |
| ReportUploaderTest(const ReportUploaderTest&) = delete; |
| ReportUploaderTest& operator=(const ReportUploaderTest&) = delete; |
| |
| ~ReportUploaderTest() override = default; |
| |
| void UploadReportAndSetExpectation( |
| int number_of_request, |
| ReportUploader::ReportStatus expected_status) { |
| DCHECK_LE(number_of_request, 2) |
| << "Please update kBrowserVersionNames above."; |
| ReportRequestQueue requests; |
| for (int i = 0; i < number_of_request; i++) { |
| auto request = std::make_unique<ReportRequest>(GetReportType()); |
| em::BrowserReport* browser_report; |
| switch (GetReportType()) { |
| case ReportType::kFull: |
| case ReportType::kBrowserVersion: |
| browser_report = |
| request->GetDeviceReportRequest().mutable_browser_report(); |
| break; |
| case ReportType::kProfileReport: |
| browser_report = |
| request->GetChromeProfileReportRequest().mutable_browser_report(); |
| break; |
| } |
| browser_report->set_browser_version(kBrowserVersionNames[i]); |
| requests.push(std::move(request)); |
| } |
| has_responded_ = false; |
| uploader_->SetRequestAndUpload( |
| ReportGenerationConfig(ReportTrigger::kTriggerNone, GetReportType(), |
| SecuritySignalsMode::kNoSignals, use_cookies_), |
| std::move(requests), |
| base::BindOnce(&ReportUploaderTest::OnReportUploaded, |
| base::Unretained(this), expected_status)); |
| } |
| |
| virtual ReportType GetReportType() { return ReportType::kFull; } |
| |
| void OnReportUploaded(ReportUploader::ReportStatus expected_status, |
| ReportUploader::ReportStatus actuall_status) { |
| EXPECT_EQ(expected_status, actuall_status); |
| has_responded_ = true; |
| } |
| |
| void CreateUploader(int retry_count) { |
| uploader_ = std::make_unique<ReportUploader>(&client_, retry_count); |
| } |
| |
| // Forwards to send next request and get response. |
| void RunNextTask() { |
| task_environment_.FastForwardBy( |
| task_environment_.NextMainThreadPendingTaskDelay()); |
| } |
| |
| // Verifies the retried is delayed properly. |
| void VerifyRequestDelay(int delay_seconds) { |
| if (delay_seconds == 0) { |
| EXPECT_EQ(base::TimeDelta(), |
| task_environment_.NextMainThreadPendingTaskDelay()); |
| return; |
| } |
| EXPECT_GE(base::Seconds(delay_seconds), |
| task_environment_.NextMainThreadPendingTaskDelay()); |
| EXPECT_LE(base::Seconds(static_cast<int>(delay_seconds * 0.9)), |
| task_environment_.NextMainThreadPendingTaskDelay()); |
| } |
| |
| base::test::TaskEnvironment task_environment_; |
| |
| std::unique_ptr<ReportUploader> uploader_; |
| ::testing::StrictMock<policy::MockCloudPolicyClient> client_; |
| bool has_responded_ = false; |
| bool use_cookies_ = false; |
| base::HistogramTester histogram_tester_; |
| }; |
| |
| class ReportUploaderTestWithTransientError |
| : public ReportUploaderTest, |
| public ::testing::WithParamInterface<policy::DeviceManagementStatus> {}; |
| |
| class ReportUploaderTestWithProfileReportType : public ReportUploaderTest { |
| public: |
| ReportType GetReportType() override { return ReportType::kProfileReport; } |
| }; |
| |
| class ReportUploaderTestWithReportType |
| : public ReportUploaderTest, |
| public ::testing::WithParamInterface<ReportType> { |
| public: |
| ReportType GetReportType() override { return GetParam(); } |
| }; |
| |
| // TODO(crbug.com/40483507) This death test does not work on Android. |
| #if defined(GTEST_HAS_DEATH_TEST) && !BUILDFLAG(IS_ANDROID) |
| TEST_F(ReportUploaderTest, NotRegisteredCrashes) { |
| CreateUploader(/* retry_count = */ 1); |
| EXPECT_CALL(client_, UploadReport) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::CloudPolicyClient::NotRegistered()))); |
| ReportRequestQueue requests; |
| requests.push(std::make_unique<ReportRequest>(GetReportType())); |
| base::test::TestFuture<ReportUploader::ReportStatus> future; |
| uploader_->SetRequestAndUpload( |
| ReportGenerationConfig(ReportTrigger::kTriggerNone, GetReportType(), |
| SecuritySignalsMode::kNoSignals, use_cookies_), |
| std::move(requests), future.GetCallback()); |
| ASSERT_DEATH(std::ignore = future.Get(), ""); |
| } |
| #endif // defined(GTEST_HAS_DEATH_TEST) && !BUILDFLAG(IS_ANDROID) |
| |
| TEST_F(ReportUploaderTest, PersistentError) { |
| CreateUploader(/* retry_count = */ 1); |
| EXPECT_CALL(client_, UploadReport) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_SERVICE_DEVICE_NOT_FOUND))); |
| UploadReportAndSetExpectation(/*number_of_request=*/2, |
| ReportUploader::kPersistentError); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kOtherError, 1); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| TEST_F(ReportUploaderTest, RequestTooBigError) { |
| CreateUploader(/* *retry_count = */ 2); |
| EXPECT_CALL(client_, UploadReport) |
| .Times(2) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_REQUEST_TOO_LARGE))) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_REQUEST_TOO_LARGE))); |
| UploadReportAndSetExpectation(/*number_of_request=*/2, |
| ReportUploader::kSuccess); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kRequestTooLargeError, |
| 2); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| TEST_F(ReportUploaderTest, RetryAndSuccess) { |
| EXPECT_CALL(client_, UploadReport) |
| .Times(2) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))) |
| .WillOnce(ScheduleResponse( |
| policy::CloudPolicyClient::Result(policy::DM_STATUS_SUCCESS))); |
| CreateUploader(/* retry_count = */ 1); |
| UploadReportAndSetExpectation(/*number_of_request=*/1, |
| ReportUploader::kSuccess); |
| RunNextTask(); |
| |
| // No response, request is retried. |
| EXPECT_FALSE(has_responded_); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| histogram_tester_.ExpectTotalCount(kResponseMetricsName, 2); |
| histogram_tester_.ExpectBucketCount(kResponseMetricsName, |
| ReportResponseMetricsStatus::kSuccess, 1); |
| histogram_tester_.ExpectBucketCount( |
| kResponseMetricsName, ReportResponseMetricsStatus::kTemporaryServerError, |
| 1); |
| } |
| |
| TEST_F(ReportUploaderTest, RetryAndFailedWithPersistentError) { |
| EXPECT_CALL(client_, UploadReport) |
| .Times(1) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))); |
| CreateUploader(/* retry_count = */ 1); |
| UploadReportAndSetExpectation(/*number_of_request=*/1, |
| ReportUploader::kPersistentError); |
| RunNextTask(); |
| |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kTemporaryServerError, |
| 1); |
| |
| // No response, request is retried. |
| EXPECT_FALSE(has_responded_); |
| // Error is changed. |
| EXPECT_CALL(client_, UploadReport) |
| .Times(1) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_SERVICE_DEVICE_NOT_FOUND))); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| histogram_tester_.ExpectTotalCount(kResponseMetricsName, 2); |
| histogram_tester_.ExpectBucketCount( |
| kResponseMetricsName, ReportResponseMetricsStatus::kOtherError, 1); |
| } |
| |
| TEST_F(ReportUploaderTest, RetryAndFailedWithTransientError) { |
| EXPECT_CALL(client_, UploadReport) |
| .Times(2) |
| .WillRepeatedly(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))); |
| CreateUploader(/* retry_count = */ 1); |
| UploadReportAndSetExpectation(/*number_of_request=*/1, |
| ReportUploader::kTransientError); |
| RunNextTask(); |
| |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kTemporaryServerError, |
| 1); |
| |
| // No response, request is retried. |
| EXPECT_FALSE(has_responded_); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kTemporaryServerError, |
| 2); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| TEST_F(ReportUploaderTest, MultipleReports) { |
| { |
| InSequence s; |
| // First report |
| EXPECT_CALL( |
| client_, |
| UploadReport( |
| Pointee(Property( |
| &ReportRequest::DeviceReportRequestProto::browser_report, |
| Property(&em::BrowserReport::browser_version, |
| Eq(kBrowserVersionNames[0])))), |
| _)) |
| .Times(3) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))) |
| .WillOnce(ScheduleResponse( |
| policy::CloudPolicyClient::Result(policy::DM_STATUS_SUCCESS))); |
| // Second report |
| EXPECT_CALL( |
| client_, |
| UploadReport( |
| Pointee(Property( |
| &ReportRequest::DeviceReportRequestProto::browser_report, |
| Property(&em::BrowserReport::browser_version, |
| Eq(kBrowserVersionNames[1])))), |
| _)) |
| .Times(2) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))) |
| .WillOnce(ScheduleResponse(policy::CloudPolicyClient::Result( |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE))); |
| } |
| CreateUploader(/* retry_count = */ 2); |
| UploadReportAndSetExpectation(/*number_of_request=*/2, |
| ReportUploader::kTransientError); |
| |
| // The first request has no delay. |
| VerifyRequestDelay(0); |
| RunNextTask(); |
| |
| // The first retry is delayed between 54 to 60 seconds. |
| VerifyRequestDelay(60); |
| RunNextTask(); |
| |
| // The second retry is delayed between 108 to 120 seconds. |
| VerifyRequestDelay(120); |
| RunNextTask(); |
| |
| // Request is succeeded, send the next request And its first retry is delayed |
| // between 108 to 120 seconds because there were 2 failures. |
| VerifyRequestDelay(120); |
| RunNextTask(); |
| |
| // And we failed again, reach maximum retries count. |
| EXPECT_TRUE(has_responded_); |
| |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| TEST_F(ReportUploaderTestWithProfileReportType, ProfileReportWithCookies) { |
| use_cookies_ = true; |
| |
| EXPECT_CALL(client_, UploadChromeProfileReport(/*use_cookies=*/true, _, _)) |
| .WillOnce(ScheduleProfileResponse( |
| policy::CloudPolicyClient::Result(policy::DM_STATUS_SUCCESS))); |
| |
| UploadReportAndSetExpectation(/*number_of_request=*/1, |
| ReportUploader::kSuccess); |
| |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| } |
| |
| // Verified three DM server error that is transient. |
| TEST_P(ReportUploaderTestWithTransientError, WithoutRetry) { |
| EXPECT_CALL(client_, UploadReport) |
| .WillOnce( |
| ScheduleResponse(policy::CloudPolicyClient::Result(GetParam()))); |
| UploadReportAndSetExpectation(/*number_of_request=*/2, |
| ReportUploader::kTransientError); |
| task_environment_.FastForwardBy(base::TimeDelta()); |
| EXPECT_TRUE(has_responded_); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| All, |
| ReportUploaderTestWithTransientError, |
| ::testing::Values(policy::DM_STATUS_REQUEST_FAILED, |
| policy::DM_STATUS_TEMPORARY_UNAVAILABLE, |
| policy::DM_STATUS_SERVICE_TOO_MANY_REQUESTS)); |
| |
| TEST_P(ReportUploaderTestWithReportType, Success) { |
| switch (GetReportType()) { |
| case ReportType::kFull: |
| case ReportType::kBrowserVersion: |
| EXPECT_CALL(client_, UploadReport) |
| .WillOnce(ScheduleResponse( |
| policy::CloudPolicyClient::Result(policy::DM_STATUS_SUCCESS))); |
| break; |
| case ReportType::kProfileReport: |
| EXPECT_CALL(client_, UploadChromeProfileReport(use_cookies_, _, _)) |
| .WillOnce(ScheduleProfileResponse( |
| policy::CloudPolicyClient::Result(policy::DM_STATUS_SUCCESS))); |
| break; |
| } |
| |
| UploadReportAndSetExpectation(/*number_of_request=*/1, |
| ReportUploader::kSuccess); |
| RunNextTask(); |
| EXPECT_TRUE(has_responded_); |
| histogram_tester_.ExpectUniqueSample( |
| kResponseMetricsName, ReportResponseMetricsStatus::kSuccess, 1); |
| ::testing::Mock::VerifyAndClearExpectations(&client_); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| ReportUploaderTestWithReportType, |
| ::testing::Values(ReportType::kFull, |
| ReportType::kBrowserVersion, |
| ReportType::kProfileReport)); |
| |
| } // namespace enterprise_reporting |
