| // Copyright 2015 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 "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h" |
| |
| #include <initializer_list> |
| #include <set> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "base/callback_helpers.h" |
| #include "base/files/file_path.h" |
| #include "base/macros.h" |
| #include "base/run_loop.h" |
| #include "base/stl_util.h" |
| #include "base/synchronization/lock.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/time/time.h" |
| #include "base/version.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/component_updater/sw_reporter_installer_win.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/safe_browsing/chrome_cleaner/mock_chrome_cleaner_controller_win.h" |
| #include "chrome/browser/safe_browsing/chrome_cleaner/srt_client_info_win.h" |
| #include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/test/base/in_process_browser_test.h" |
| #include "chrome/test/base/test_launcher_utils.h" |
| #include "components/component_updater/pref_names.h" |
| #include "components/policy/core/browser/browser_policy_connector.h" |
| #include "components/policy/core/common/mock_configuration_policy_provider.h" |
| #include "components/policy/policy_constants.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/safe_browsing/common/safe_browsing_prefs.h" |
| #include "components/variations/variations_params_manager.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace safe_browsing { |
| |
| namespace { |
| |
| using ::testing::_; |
| using ::testing::DoAll; |
| using ::testing::Eq; |
| using ::testing::InvokeWithoutArgs; |
| using ::testing::Return; |
| using ::testing::SaveArg; |
| |
| constexpr char kSRTPromptGroup[] = "SRTGroup"; |
| |
| class Waiter { |
| public: |
| Waiter() = default; |
| ~Waiter() = default; |
| |
| void Wait() { |
| while (!Done()) |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| bool Done() { |
| base::AutoLock lock(lock_); |
| return done_; |
| } |
| |
| void Signal() { |
| base::AutoLock lock(lock_); |
| done_ = true; |
| } |
| |
| private: |
| bool done_ = false; |
| base::Lock lock_; |
| }; |
| |
| // Parameters for this test: |
| // - bool: whether the policy is managed or not. |
| // - bool: if managed, whether the policy is forced on or not. |
| using ReporterRunnerPolicyTestParams = std::tuple<bool, bool>; |
| |
| enum class ReporterRunnerPolicy { |
| kNoPolicy, |
| kEnabled, |
| kDisabled, |
| }; |
| |
| class ReporterRunnerPolicyTest |
| : public InProcessBrowserTest, |
| public ::testing::WithParamInterface<ReporterRunnerPolicy> { |
| public: |
| ReporterRunnerPolicyTest() { |
| policy_ = GetParam(); |
| component_updater::SetRegisterSwReporterComponentCallbackForTesting( |
| base::BindOnce(&ReporterRunnerPolicyTest::ComponentRegistered, |
| base::Unretained(this))); |
| } |
| |
| void WaitForComponentRegistration() { waiter_.Wait(); } |
| |
| protected: |
| ReporterRunnerPolicy policy_; |
| |
| private: |
| void SetUpCommandLine(base::CommandLine* command_line) override {} |
| |
| // Make sure the component will be installed during the test. |
| void SetUpDefaultCommandLine(base::CommandLine* command_line) override { |
| base::CommandLine default_command_line(base::CommandLine::NO_PROGRAM); |
| InProcessBrowserTest::SetUpDefaultCommandLine(&default_command_line); |
| test_launcher_utils::RemoveCommandLineSwitch( |
| default_command_line, switches::kDisableComponentUpdate, command_line); |
| } |
| |
| void SetUpInProcessBrowserTestFixture() override { |
| EXPECT_CALL(policy_provider_, IsInitializationComplete(_)) |
| .WillRepeatedly(Return(true)); |
| policy::BrowserPolicyConnector::SetPolicyProviderForTesting( |
| &policy_provider_); |
| |
| // Setup polices as needed. |
| if (policy_ != ReporterRunnerPolicy::kNoPolicy) { |
| bool is_enabled = policy_ == ReporterRunnerPolicy::kEnabled; |
| policy::PolicyMap policies; |
| policies.Set(policy::key::kChromeCleanupEnabled, |
| policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER, |
| policy::POLICY_SOURCE_PLATFORM, |
| std::make_unique<base::Value>(is_enabled), nullptr); |
| policy_provider_.UpdateChromePolicy(policies); |
| } |
| } |
| |
| void ComponentRegistered() { waiter_.Signal(); } |
| |
| policy::MockConfigurationPolicyProvider policy_provider_; |
| Waiter waiter_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ReporterRunnerPolicyTest); |
| }; |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerPolicyTest, CheckComponent) { |
| WaitForComponentRegistration(); |
| |
| // If the cleaner is disabled by policy, there should be no reporter |
| // component installed. Otherwise it should be installed. |
| std::vector<std::string> component_ids = |
| g_browser_process->component_updater()->GetComponentIDs(); |
| bool sw_component_registered = base::ContainsValue( |
| component_ids, component_updater::kSwReporterComponentId); |
| ASSERT_EQ(policy_ != ReporterRunnerPolicy::kDisabled, |
| sw_component_registered); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(PolicyControl, |
| ReporterRunnerPolicyTest, |
| ::testing::Values(ReporterRunnerPolicy::kNoPolicy, |
| ReporterRunnerPolicy::kEnabled, |
| ReporterRunnerPolicy::kDisabled)); |
| |
| // The state of the the enterprise policy to use during tests. |
| enum class PolicyState { |
| kNoLogs, // Don't set the policy for logs. |
| kLogsForceEnable, // Force the logs to be enabled. |
| kLogsForceDisable, // Force the logs to be disabled. |
| }; |
| |
| // Parameters for this test: |
| // - SwReporterInvocationType invocation_type_: identifies the type of |
| // invocation being tested. |
| // - const char* old_seed_: The old "Seed" Finch parameter saved in prefs. |
| // - const char* incoming_seed_: The new "Seed" Finch parameter. |
| // - PolicyState policy_state_: The state of logs reporting enterprise policy. |
| using ReporterRunnerTestParams = |
| std::tuple<SwReporterInvocationType, const char*, const char*, PolicyState>; |
| |
| class ReporterRunnerTest |
| : public InProcessBrowserTest, |
| public SwReporterTestingDelegate, |
| public ::testing::WithParamInterface<ReporterRunnerTestParams> { |
| public: |
| ReporterRunnerTest() { |
| std::tie(invocation_type_, old_seed_, incoming_seed_, policy_state_) = |
| GetParam(); |
| } |
| |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| variations::testing::VariationParamsManager::AppendVariationParams( |
| kSRTPromptTrial, kSRTPromptGroup, {{"Seed", incoming_seed_}}, |
| command_line); |
| } |
| |
| void SetUpInProcessBrowserTestFixture() override { |
| SetSwReporterTestingDelegate(this); |
| EXPECT_CALL(policy_provider_, IsInitializationComplete(_)) |
| .WillRepeatedly(Return(true)); |
| policy::BrowserPolicyConnector::SetPolicyProviderForTesting( |
| &policy_provider_); |
| |
| switch (policy_state_) { |
| case PolicyState::kNoLogs: |
| break; |
| |
| case PolicyState::kLogsForceEnable: |
| case PolicyState::kLogsForceDisable: { |
| bool is_enabled = policy_state_ == PolicyState::kLogsForceEnable; |
| policy::PolicyMap policies; |
| policies.Set(policy::key::kChromeCleanupReportingEnabled, |
| policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER, |
| policy::POLICY_SOURCE_PLATFORM, |
| std::make_unique<base::Value>(is_enabled), nullptr); |
| policy_provider_.UpdateChromePolicy(policies); |
| EXPECT_CALL(mock_chrome_cleaner_controller_, logs_enabled(_)) |
| .WillRepeatedly(Return(is_enabled)); |
| break; |
| } |
| } |
| } |
| |
| void SetUpOnMainThread() override { |
| // SetDateInLocalState calculates a time as Now() minus an offset. Move the |
| // simulated clock ahead far enough that this calculation won't underflow. |
| FastForwardBy( |
| base::TimeDelta::FromDays(kDaysBetweenSuccessfulSwReporterRuns * 2)); |
| |
| ClearLastTimeSentReport(); |
| |
| chrome::FindLastActive()->profile()->GetPrefs()->SetString( |
| prefs::kSwReporterPromptSeed, old_seed_); |
| } |
| |
| void TearDownInProcessBrowserTestFixture() override { |
| SetSwReporterTestingDelegate(nullptr); |
| } |
| |
| // Records that the reporter was launched with the parameters given in |
| // |invocation|. |
| int LaunchReporter(const SwReporterInvocation& invocation) override { |
| ++reporter_launch_count_; |
| reporter_launch_parameters_.push_back(invocation); |
| if (first_launch_callback_) |
| std::move(first_launch_callback_).Run(); |
| return exit_code_to_report_; |
| } |
| |
| // Returns the test's idea of the current time. |
| base::Time Now() const override { return now_; } |
| |
| ChromeCleanerController* GetCleanerController() override { |
| return &mock_chrome_cleaner_controller_; |
| } |
| |
| void CreateChromeCleanerDialogController() override { |
| dialog_controller_created_ = true; |
| } |
| |
| void FastForwardBy(base::TimeDelta delta) { now_ += delta; } |
| |
| // Returns a task runner to use when launching the reporter (which is |
| // normally a blocking action). |
| base::TaskRunner* BlockingTaskRunner() const override { |
| // Use the test's main task runner so that we don't need to pump another |
| // message loop. Since the test calls LaunchReporter instead of actually |
| // doing a blocking reporter launch, it doesn't matter that the task runner |
| // doesn't have the MayBlock trait. |
| return base::ThreadTaskRunnerHandle::Get().get(); |
| } |
| |
| void ResetReporterRuns(int exit_code_to_report) { |
| exit_code_to_report_ = exit_code_to_report; |
| reporter_launch_count_ = 0; |
| reporter_launch_parameters_.clear(); |
| dialog_controller_created_ = false; |
| } |
| |
| SwReporterInvocation CreateInvocation(const base::FilePath& exe_path) { |
| return SwReporterInvocation(base::CommandLine(exe_path)) |
| .WithSupportedBehaviours( |
| SwReporterInvocation::BEHAVIOURS_ENABLED_BY_DEFAULT); |
| } |
| |
| SwReporterInvocationSequence CreateInvocationSequence( |
| const SwReporterInvocationSequence::Queue& container) { |
| SwReporterInvocationSequence sequence(base::Version("1.2.3")); |
| sequence.mutable_container() = container; |
| return sequence; |
| } |
| |
| // Schedules a single reporter to run. |
| void RunSingleReporterAndWait(int exit_code_to_report, |
| SwReporterInvocationResult expected_result) { |
| RunReporterQueueAndWait(exit_code_to_report, expected_result, |
| SwReporterInvocationSequence::Queue( |
| {CreateInvocation(base::FilePath())})); |
| } |
| |
| // Schedules a queue of reporters to run. |
| void RunReporterQueueAndWait( |
| int exit_code_to_report, |
| SwReporterInvocationResult expected_result, |
| const SwReporterInvocationSequence::Queue& container) { |
| ResetReporterRuns(exit_code_to_report); |
| |
| ON_CALL(mock_chrome_cleaner_controller_, state()) |
| .WillByDefault(Return(ChromeCleanerController::State::kIdle)); |
| |
| if (expected_result != SwReporterInvocationResult::kNotScheduled) { |
| EXPECT_CALL(mock_chrome_cleaner_controller_, OnReporterSequenceStarted()) |
| .Times(1); |
| } |
| |
| Waiter on_sequence_done; |
| EXPECT_CALL(mock_chrome_cleaner_controller_, |
| OnReporterSequenceDone(Eq(expected_result))) |
| .WillOnce(InvokeWithoutArgs(&on_sequence_done, &Waiter::Signal)); |
| auto invocations = CreateInvocationSequence(container); |
| MaybeStartSwReporter(invocation_type_, std::move(invocations)); |
| on_sequence_done.Wait(); |
| } |
| |
| // Sets |path| in the local state to a date corresponding to |days| days ago. |
| void SetDateInLocalState(const std::string& path, int days) { |
| PrefService* local_state = g_browser_process->local_state(); |
| local_state->SetInt64( |
| path, (Now() - base::TimeDelta::FromDays(days)).ToInternalValue()); |
| } |
| |
| // Sets local state for last time the software reporter ran to |days| days |
| // ago. |
| void SetDaysSinceLastTriggered(int days) { |
| SetDateInLocalState(prefs::kSwReporterLastTimeTriggered, days); |
| } |
| |
| // Sets local state for last time the software reporter sent logs to |days| |
| // days ago. |
| void SetLastTimeSentReport(int days) { |
| SetDateInLocalState(prefs::kSwReporterLastTimeSentReport, days); |
| } |
| |
| // Clears local state for last time the software reporter sent logs. This |
| // prevents potential false positives that could arise from state not |
| // properly cleaned between successive tests. |
| void ClearLastTimeSentReport() { |
| PrefService* local_state = g_browser_process->local_state(); |
| local_state->ClearPref(prefs::kSwReporterLastTimeSentReport); |
| } |
| |
| // Retrieves the timestamp of the last time the software reporter sent logs. |
| int64_t GetLastTimeSentReport() { |
| const PrefService* local_state = g_browser_process->local_state(); |
| DCHECK(local_state->HasPrefPath(prefs::kSwReporterLastTimeSentReport)); |
| return local_state->GetInt64(prefs::kSwReporterLastTimeSentReport); |
| } |
| |
| void EnableSBExtendedReporting() { |
| Browser* browser = chrome::FindLastActive(); |
| DCHECK(browser); |
| Profile* profile = browser->profile(); |
| SetExtendedReportingPref(profile->GetPrefs(), true); |
| } |
| |
| // Expects that the reporter has been launched |expected_launch_count| times, |
| // and TriggerPrompt will be called if and only if |expect_prompt| is true. |
| void ExpectNumReporterLaunches(int expected_launch_count, |
| bool expect_prompt) { |
| EXPECT_EQ(expected_launch_count, reporter_launch_count_); |
| EXPECT_EQ(expect_prompt, dialog_controller_created_); |
| } |
| |
| // Expects that the reporter has been launched once with each path in |
| // |expected_launch_paths|, and TriggerPrompt will be called if and only |
| // if |expect_prompt| is true. |
| void ExpectReporterLaunches( |
| const std::vector<base::FilePath>& expected_launch_paths, |
| bool expect_prompt) { |
| ExpectNumReporterLaunches(expected_launch_paths.size(), expect_prompt); |
| EXPECT_EQ(expected_launch_paths.size(), reporter_launch_parameters_.size()); |
| for (size_t i = 0; i < expected_launch_paths.size() && |
| i < reporter_launch_parameters_.size(); |
| ++i) { |
| EXPECT_EQ(expected_launch_paths[i], |
| reporter_launch_parameters_[i].command_line().GetProgram()); |
| } |
| } |
| |
| void ExpectLastTimeSentReportNotSet() { |
| PrefService* local_state = g_browser_process->local_state(); |
| EXPECT_FALSE( |
| local_state->HasPrefPath(prefs::kSwReporterLastTimeSentReport)); |
| } |
| |
| void ExpectLastReportSentInTheLastHour() { |
| const PrefService* local_state = g_browser_process->local_state(); |
| const base::Time now = Now(); |
| const base::Time last_time_sent_logs = base::Time::FromInternalValue( |
| local_state->GetInt64(prefs::kSwReporterLastTimeSentReport)); |
| |
| // Checks if the last time sent logs is set as no more than one hour ago, |
| // which should be enough time if the execution does not fail. |
| EXPECT_LT(now - base::TimeDelta::FromHours(1), last_time_sent_logs); |
| EXPECT_GE(now, last_time_sent_logs); |
| } |
| |
| // Returns true if it is expected that the test will enable logging. |
| bool ExpectLogging(bool expect_logging_by_default) { |
| bool expect_logging = expect_logging_by_default; |
| if (policy_state_ == PolicyState::kLogsForceDisable || |
| invocation_type_ == |
| SwReporterInvocationType::kUserInitiatedWithLogsDisallowed) { |
| expect_logging = false; |
| } else if (invocation_type_ == |
| SwReporterInvocationType::kUserInitiatedWithLogsAllowed) { |
| expect_logging = true; |
| } |
| return expect_logging; |
| } |
| |
| // Expects |invocation|'s command line to contain all the switches required |
| // for reporter logging if and only if |expect_switches| is true. |
| void ExpectLoggingSwitches(const SwReporterInvocation& invocation, |
| bool expect_switches) { |
| static const std::set<std::string> logging_switches{ |
| chrome_cleaner::kExtendedSafeBrowsingEnabledSwitch, |
| chrome_cleaner::kChromeVersionSwitch, |
| chrome_cleaner::kChromeChannelSwitch}; |
| |
| const base::CommandLine::SwitchMap& invocation_switches = |
| invocation.command_line().GetSwitches(); |
| // Checks if switches that enable logging on the reporter are present on |
| // the invocation if and only if logging is allowed. |
| for (const std::string& logging_switch : logging_switches) { |
| EXPECT_EQ(expect_switches, invocation_switches.find(logging_switch) != |
| invocation_switches.end()); |
| } |
| } |
| |
| void ExpectReporterLoggingHappenedInTheLastHour( |
| const SwReporterInvocation& invocation, |
| bool expect_logging) { |
| ExpectLoggingSwitches(invocation, expect_logging); |
| if (expect_logging) |
| ExpectLastReportSentInTheLastHour(); |
| } |
| |
| void FutureExpectReporterLoggingHappenedInTheLastHour( |
| base::OnceCallback<const SwReporterInvocation&()> get_invocation, |
| bool expect_logging) { |
| ExpectReporterLoggingHappenedInTheLastHour(std::move(get_invocation).Run(), |
| expect_logging); |
| } |
| |
| void ExpectNoReporterLoggingWithLastTimeSentReportNotSet( |
| const SwReporterInvocation& invocation) { |
| ExpectLoggingSwitches(invocation, false); |
| ExpectLastTimeSentReportNotSet(); |
| } |
| |
| void ExpectNoReporterLoggingWithLastTimeSentReportSet( |
| const SwReporterInvocation& invocation, |
| int64_t last_time_sent_logs) { |
| ExpectLoggingSwitches(invocation, false); |
| EXPECT_EQ(last_time_sent_logs, GetLastTimeSentReport()); |
| } |
| |
| void FutureExpectNoReporterLoggingWithLastTimeSentReportSet( |
| base::OnceCallback<const SwReporterInvocation&()> get_invocation, |
| int64_t last_time_sent_logs) { |
| ExpectNoReporterLoggingWithLastTimeSentReportSet( |
| std::move(get_invocation).Run(), last_time_sent_logs); |
| } |
| |
| void ExpectReporterLoggingBehavior(const SwReporterInvocation& invocation, |
| bool expect_logging_by_default, |
| int64_t last_time_sent_logs) { |
| bool expect_logging = ExpectLogging(expect_logging_by_default); |
| if (expect_logging) { |
| ExpectReporterLoggingHappenedInTheLastHour(invocation, expect_logging); |
| } else if (last_time_sent_logs == -1) { |
| ExpectNoReporterLoggingWithLastTimeSentReportNotSet(invocation); |
| } else { |
| ExpectNoReporterLoggingWithLastTimeSentReportSet(invocation, |
| last_time_sent_logs); |
| } |
| } |
| |
| bool LogsDisabledByUser() { |
| return invocation_type_ == |
| SwReporterInvocationType::kUserInitiatedWithLogsDisallowed; |
| } |
| |
| void ExpectResultOnSequenceDone(SwReporterInvocationResult expected_result, |
| base::OnceClosure closure, |
| SwReporterInvocationResult result) { |
| EXPECT_EQ(expected_result, result); |
| std::move(closure).Run(); |
| } |
| |
| OnReporterSequenceDone ExpectResultOnSequenceDoneCallback( |
| SwReporterInvocationResult expected_result, |
| base::OnceClosure closure) { |
| return base::BindOnce(&ReporterRunnerTest::ExpectResultOnSequenceDone, |
| base::Unretained(this), expected_result, |
| base::Passed(&closure)); |
| } |
| |
| bool PromptDialogShouldBeShown(SwReporterInvocationType invocation_type) { |
| return !IsUserInitiated(invocation_type) && |
| (incoming_seed_.empty() || (incoming_seed_ != old_seed_)); |
| } |
| |
| // Tests that a sequence of type |invocation_type1|, once scheduled, will not |
| // allow a sequence of type |invocation_type2| be scheduled. |
| void TestSequenceNotScheduled(SwReporterInvocationType invocation_type1, |
| SwReporterInvocationType invocation_type2) { |
| const base::FilePath path1(L"path1"); |
| const base::FilePath path2(L"path2"); |
| |
| ResetReporterRuns(chrome_cleaner::kSwReporterNothingFound); |
| |
| ON_CALL(mock_chrome_cleaner_controller_, state()) |
| .WillByDefault(Return(ChromeCleanerController::State::kIdle)); |
| EXPECT_CALL(mock_chrome_cleaner_controller_, OnReporterSequenceStarted()) |
| .Times(1); |
| |
| // Launch two sequences that will be run in the following order: |
| // - The first sequence (of type |invocation_type1|) starts and waits to |
| // proceed; |
| // - The second sequence (of type |invocation_type2|) is scheduled and this |
| // test is blocked until all sequences complete; |
| // - The second sequence can't be scheduled and its invocation will not |
| // run, because the first sequence is already running; it will then be |
| // deleted and will release the first sequence that is waiting to |
| // proceed; |
| // - The first sequence, once unblocked, will finish and unblock this test; |
| // - At the end, check if only the invocation in the first sequence (path1) |
| // was run. |
| Waiter first_sequence_done; |
| Waiter second_sequence_done; |
| |
| EXPECT_CALL( |
| mock_chrome_cleaner_controller_, |
| OnReporterSequenceDone(Eq(SwReporterInvocationResult::kNothingFound))) |
| .WillOnce( |
| DoAll(InvokeWithoutArgs(&second_sequence_done, &Waiter::Wait), |
| InvokeWithoutArgs(&first_sequence_done, &Waiter::Signal))); |
| |
| SwReporterInvocationSequence::Queue invocations1({CreateInvocation(path1)}); |
| MaybeStartSwReporter(invocation_type1, |
| CreateInvocationSequence(invocations1)); |
| |
| EXPECT_CALL( |
| mock_chrome_cleaner_controller_, |
| OnReporterSequenceDone(Eq(SwReporterInvocationResult::kNotScheduled))) |
| .WillOnce(InvokeWithoutArgs(&second_sequence_done, &Waiter::Signal)); |
| |
| SwReporterInvocationSequence::Queue invocations2({CreateInvocation(path2)}); |
| MaybeStartSwReporter(invocation_type2, |
| CreateInvocationSequence(invocations2)); |
| |
| first_sequence_done.Wait(); |
| |
| ExpectReporterLaunches({path1}, /*expect_prompt=*/false); |
| } |
| |
| base::Time now_; |
| |
| // Test parameters. |
| SwReporterInvocationType invocation_type_; |
| std::string old_seed_; |
| std::string incoming_seed_; |
| PolicyState policy_state_; |
| |
| bool dialog_controller_created_ = false; |
| int reporter_launch_count_ = 0; |
| std::vector<SwReporterInvocation> reporter_launch_parameters_; |
| int exit_code_to_report_ = kReporterNotLaunchedExitCode; |
| |
| // Using NiceMock to suppress warnings about uninteresting calls. |
| ::testing::NiceMock<policy::MockConfigurationPolicyProvider> policy_provider_; |
| |
| // Using NiceMock to suppress warnings about uninteresting calls to state(). |
| ::testing::NiceMock<MockChromeCleanerController> |
| mock_chrome_cleaner_controller_; |
| |
| // A callback to invoke when the first reporter of a queue is launched. This |
| // can be used to perform actions in the middle of a queue of reporters which |
| // all launch on the same mock clock tick. |
| base::OnceClosure first_launch_callback_; |
| |
| base::test::ScopedFeatureList scoped_feature_list_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(ReporterRunnerTest); |
| }; |
| |
| } // namespace |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, NothingFound) { |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, CleanupNeeded) { |
| bool cleanup_offered = |
| IsUserInitiated(invocation_type_) || |
| (incoming_seed_.empty() || (incoming_seed_ != old_seed_)); |
| |
| SwReporterInvocation scan_invocation = CreateInvocation(base::FilePath()); |
| if (cleanup_offered) { |
| EXPECT_CALL(mock_chrome_cleaner_controller_, Scan(_)) |
| .WillOnce(SaveArg<0>(&scan_invocation)); |
| } |
| |
| RunSingleReporterAndWait( |
| chrome_cleaner::kSwReporterCleanupNeeded, |
| cleanup_offered ? SwReporterInvocationResult::kCleanupToBeOffered |
| : SwReporterInvocationResult::kCleanupNotOffered); |
| ExpectNumReporterLaunches( |
| /*expected_launch_count=*/1, |
| /*expect_prompt=*/PromptDialogShouldBeShown(invocation_type_)); |
| |
| if (cleanup_offered) { |
| EXPECT_EQ(invocation_type_ == |
| SwReporterInvocationType::kUserInitiatedWithLogsAllowed, |
| scan_invocation.cleaner_logs_upload_enabled()); |
| EXPECT_EQ(invocation_type_ == SwReporterInvocationType::kPeriodicRun |
| ? chrome_cleaner::ChromePromptValue::kPrompted |
| : chrome_cleaner::ChromePromptValue::kUserInitiated, |
| scan_invocation.chrome_prompt()); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, RanRecently) { |
| constexpr int kDaysLeft = 1; |
| SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns - kDaysLeft); |
| if (IsUserInitiated(invocation_type_)) { |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| } else { |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNotScheduled); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/0, |
| /*expect_prompt=*/false); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, FailureToLaunch) { |
| RunSingleReporterAndWait(kReporterNotLaunchedExitCode, |
| SwReporterInvocationResult::kProcessFailedToLaunch); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, GeneralFailure) { |
| constexpr int kFailureExitCode = 1; |
| RunSingleReporterAndWait(kFailureExitCode, |
| SwReporterInvocationResult::kGeneralFailure); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, MultipleLaunches) { |
| constexpr int kAFewDays = 3; |
| |
| const base::FilePath path1(L"path1"); |
| const base::FilePath path2(L"path2"); |
| |
| SwReporterInvocationSequence::Queue invocations( |
| {CreateInvocation(path1), CreateInvocation(path2)}); |
| |
| { |
| SCOPED_TRACE("Launch 2 times"); |
| SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns); |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| } |
| |
| // Schedule a launch with 2 invocations, then another with the same 2. |
| { |
| SCOPED_TRACE("Launch 2 times with retry"); |
| FastForwardBy( |
| base::TimeDelta::FromDays(kDaysBetweenSuccessfulSwReporterRuns)); |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| |
| if (IsUserInitiated(invocation_type_)) { |
| // If user initiated, the second invocation sequence should run again. |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| } else { |
| // For periodic runs, the second invocation sequence shouldn't run again, |
| // since the first sequence has just finished. |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNotScheduled, |
| invocations); |
| ExpectReporterLaunches({}, /*expect_prompt=*/false); |
| } |
| } |
| |
| { |
| SCOPED_TRACE("Attempt to launch after a few days"); |
| FastForwardBy(base::TimeDelta::FromDays(kAFewDays)); |
| if (IsUserInitiated(invocation_type_)) { |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| } else { |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNotScheduled, |
| invocations); |
| ExpectReporterLaunches({}, /*expect_prompt=*/false); |
| } |
| |
| FastForwardBy(base::TimeDelta::FromDays( |
| kDaysBetweenSuccessfulSwReporterRuns - kAFewDays)); |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| } |
| |
| // Second launch should not occur after a failure. |
| { |
| SCOPED_TRACE("Launch multiple times with failure"); |
| FastForwardBy( |
| base::TimeDelta::FromDays(kDaysBetweenSuccessfulSwReporterRuns)); |
| RunReporterQueueAndWait(kReporterNotLaunchedExitCode, |
| SwReporterInvocationResult::kProcessFailedToLaunch, |
| invocations); |
| ExpectReporterLaunches({path1}, /*expect_prompt=*/false); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, |
| ReporterLogging_NoSBExtendedReporting) { |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| ExpectReporterLoggingBehavior(reporter_launch_parameters_.front(), |
| /*expect_logging_by_default=*/false, |
| /*last_time_sent_logs=*/-1); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, ReporterLogging_EnabledFirstRun) { |
| EnableSBExtendedReporting(); |
| // Note: don't set last time sent logs in the local state. |
| // SBER is enabled and there is no record in the local state of the last time |
| // logs have been sent, so we should send logs in this run. |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| ExpectReporterLoggingBehavior(reporter_launch_parameters_.front(), |
| /*expect_logging_by_default=*/true, |
| /*last_time_sent_logs=*/-1); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, |
| ReporterLogging_EnabledNoRecentLogging) { |
| // SBER is enabled and last time logs were sent was more than |
| // |kDaysBetweenReporterLogsSent| day ago, so we should send logs in this run. |
| EnableSBExtendedReporting(); |
| SetLastTimeSentReport(kDaysBetweenReporterLogsSent + 3); |
| int64_t last_time_sent_logs = GetLastTimeSentReport(); |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| ExpectReporterLoggingBehavior(reporter_launch_parameters_.front(), |
| /*expect_logging_by_default=*/true, |
| last_time_sent_logs); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, |
| ReporterLogging_EnabledRecentlyLogged) { |
| // SBER is enabled, but logs have been sent less than |
| // |kDaysBetweenReporterLogsSent| day ago, so we shouldn't send any logs in |
| // this run. |
| EnableSBExtendedReporting(); |
| SetLastTimeSentReport(kDaysBetweenReporterLogsSent - 1); |
| int64_t last_time_sent_logs = GetLastTimeSentReport(); |
| RunSingleReporterAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound); |
| ExpectNumReporterLaunches(/*expected_launch_count=*/1, |
| /*expect_prompt=*/false); |
| ExpectReporterLoggingBehavior(reporter_launch_parameters_.front(), |
| /*expect_logging_by_default=*/false, |
| last_time_sent_logs); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, ReporterLogging_MultipleLaunches) { |
| EnableSBExtendedReporting(); |
| SetLastTimeSentReport(kDaysBetweenReporterLogsSent + 3); |
| int64_t last_time_sent_logs = GetLastTimeSentReport(); |
| |
| const base::FilePath path1(L"path1"); |
| const base::FilePath path2(L"path2"); |
| |
| SwReporterInvocationSequence::Queue invocations( |
| {CreateInvocation(path1), CreateInvocation(path2)}); |
| |
| auto get_first_invocation = base::BindOnce( |
| [](const std::vector<SwReporterInvocation>* params) |
| -> const SwReporterInvocation& { return params->front(); }, |
| &reporter_launch_parameters_); |
| if (LogsDisabledByUser()) { |
| first_launch_callback_ = base::BindOnce( |
| &ReporterRunnerTest:: |
| FutureExpectNoReporterLoggingWithLastTimeSentReportSet, |
| base::Unretained(this), base::Passed(&get_first_invocation), |
| last_time_sent_logs); |
| } else { |
| bool expect_logging = ExpectLogging(true); |
| first_launch_callback_ = base::BindOnce( |
| &ReporterRunnerTest::FutureExpectReporterLoggingHappenedInTheLastHour, |
| base::Unretained(this), base::Passed(&get_first_invocation), |
| expect_logging); |
| } |
| |
| RunReporterQueueAndWait(chrome_cleaner::kSwReporterNothingFound, |
| SwReporterInvocationResult::kNothingFound, |
| invocations); |
| |
| // SBER is enabled and last time logs were sent was more than |
| // |kDaysBetweenReporterLogsSent| day ago, so we should send logs in this run. |
| { |
| SCOPED_TRACE("first launch"); |
| ExpectReporterLaunches({path1, path2}, /*expect_prompt=*/false); |
| } |
| |
| // Logs should also be sent for the next run, even though LastTimeSentReport |
| // is now recent, because the run is part of the same set of invocations. |
| { |
| SCOPED_TRACE("second launch"); |
| ExpectReporterLoggingBehavior(reporter_launch_parameters_[1], |
| /*expect_logging_by_default=*/true, |
| last_time_sent_logs); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, |
| PeriodicRunsNotScheduledIfAlreadyRunning) { |
| TestSequenceNotScheduled(invocation_type_, |
| SwReporterInvocationType::kPeriodicRun); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(ReporterRunnerTest, |
| UserInitiatedRunsNotScheduledIfAlreadyRunning) { |
| // No need to test for periodic runs, since the corresponding test cases are |
| // already exercised by PeriodicRunsNotScheduledIfAlreadyRunning. |
| if (!IsUserInitiated(invocation_type_)) |
| return; |
| |
| TestSequenceNotScheduled( |
| invocation_type_, |
| SwReporterInvocationType::kUserInitiatedWithLogsDisallowed); |
| } |
| |
| // Make the invocation type test parameter printable. |
| std::ostream& operator<<(std::ostream& out, |
| SwReporterInvocationType invocation_type) { |
| switch (invocation_type) { |
| case SwReporterInvocationType::kUnspecified: |
| return out << "Unspecified"; |
| case SwReporterInvocationType::kPeriodicRun: |
| return out << "PeriodicRun"; |
| case SwReporterInvocationType::kUserInitiatedWithLogsDisallowed: |
| return out << "UserInitiatedWithLogsDisallowed"; |
| case SwReporterInvocationType::kUserInitiatedWithLogsAllowed: |
| return out << "UserInitiatedWithLogsAllowed"; |
| default: |
| NOTREACHED(); |
| return out << "UnknownSwReporterInvocationType"; |
| } |
| } |
| |
| // Make the invocation type test parameter printable. |
| std::ostream& operator<<(std::ostream& out, PolicyState policy_state) { |
| switch (policy_state) { |
| case PolicyState::kNoLogs: |
| return out << "NoLogs"; |
| case PolicyState::kLogsForceEnable: |
| return out << "LogsEnabled"; |
| case PolicyState::kLogsForceDisable: |
| return out << "LogsDisabled"; |
| default: |
| NOTREACHED(); |
| return out << "UnknownPolicyState"; |
| } |
| } |
| |
| // ::testing::PrintToStringParamName does not format tuples as a valid test |
| // name, so this functor can be used to get each element in the tuple |
| // explicitly and format them using the above operator<< overrides. |
| struct ReporterRunTestParamsToString { |
| std::string operator()( |
| const ::testing::TestParamInfo<ReporterRunnerTestParams>& info) const { |
| std::ostringstream param_name; |
| param_name << std::get<0>(info.param) << "_"; |
| const std::string old_seed(std::get<1>(info.param)); |
| param_name << (old_seed.empty() ? "EmptySeed" : old_seed) << "_"; |
| const std::string incoming_seed(std::get<2>(info.param)); |
| param_name << (incoming_seed.empty() ? "EmptySeed" : incoming_seed) << "_"; |
| param_name << std::get<3>(info.param); |
| return param_name.str(); |
| } |
| }; |
| |
| // Tests without an enterprise policy set. |
| INSTANTIATE_TEST_SUITE_P( |
| NoEnterprisePolicy, |
| ReporterRunnerTest, |
| ::testing::Combine( |
| ::testing::Values( |
| SwReporterInvocationType::kPeriodicRun, |
| SwReporterInvocationType::kUserInitiatedWithLogsDisallowed, |
| SwReporterInvocationType::kUserInitiatedWithLogsAllowed), |
| ::testing::Values("", "Seed1"), // old_seed_ |
| ::testing::Values("", "Seed1", "Seed2"), // incoming_seed_ |
| ::testing::Values(PolicyState::kNoLogs)), |
| ReporterRunTestParamsToString()); |
| |
| // Tests with enterprise policies forcing reporting to be either enabled |
| // or disabled. |
| INSTANTIATE_TEST_SUITE_P( |
| EnterprisePolicy, |
| ReporterRunnerTest, |
| ::testing::Combine( |
| ::testing::Values( |
| SwReporterInvocationType::kPeriodicRun, |
| SwReporterInvocationType::kUserInitiatedWithLogsDisallowed, |
| SwReporterInvocationType::kUserInitiatedWithLogsAllowed), |
| ::testing::Values("Seed1"), // old_seed_ |
| ::testing::Values("Seed2"), // incoming_seed_ |
| ::testing::Values(PolicyState::kLogsForceEnable, |
| PolicyState::kLogsForceDisable)), |
| ReporterRunTestParamsToString()); |
| |
| } // namespace safe_browsing |
