chrome/chrome_cleaner/components/system_report_component_unittest.cc

// Copyright 2018 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/chrome_cleaner/components/system_report_component.h"

#include <shlobj.h>
#include <string>
#include <vector>

#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/lazy_instance.h"
#include "base/path_service.h"
#include "base/strings/string16.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/scoped_command_line.h"
#include "base/test/scoped_path_override.h"
#include "base/test/test_reg_util_win.h"
#include "base/test/test_timeouts.h"
#include "base/win/registry.h"
#include "chrome/chrome_cleaner/constants/chrome_cleaner_switches.h"
#include "chrome/chrome_cleaner/constants/uws_id.h"
#include "chrome/chrome_cleaner/logging/cleaner_logging_service.h"
#include "chrome/chrome_cleaner/logging/logging_service_api.h"
#include "chrome/chrome_cleaner/logging/proto/chrome_cleaner_report.pb.h"
#include "chrome/chrome_cleaner/os/disk_util.h"
#include "chrome/chrome_cleaner/os/file_path_sanitization.h"
#include "chrome/chrome_cleaner/os/pre_fetched_paths.h"
#include "chrome/chrome_cleaner/os/registry_util.h"
#include "chrome/chrome_cleaner/parsers/json_parser/test_json_parser.h"
#include "chrome/chrome_cleaner/parsers/parser_utils/command_line_arguments_sanitizer.h"
#include "chrome/chrome_cleaner/parsers/shortcut_parser/broker/fake_shortcut_parser.h"
#include "chrome/chrome_cleaner/test/test_extensions.h"
#include "chrome/chrome_cleaner/test/test_file_util.h"
#include "chrome/chrome_cleaner/test/test_pup_data.h"
#include "chrome/chrome_cleaner/test/test_util.h"
#include "components/chrome_cleaner/public/constants/constants.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace chrome_cleaner {
namespace {

using google::protobuf::RepeatedPtrField;
using InstalledExtension =
    ChromeCleanerReport::SystemReport::InstalledExtension;
using base::WaitableEvent;

const int kExtensionIdLength = 32;

const wchar_t kRunKeyPath[] =
    L"software\\microsoft\\windows\\currentversion\\run";
const wchar_t kRunTestName[] = L"test_chrome_cleanup_tool";
const wchar_t kRunTestValue[] = L"chrome_cleanup_tool.exe";

const wchar_t kNameServerKeyPath[] =
    L"system\\currentcontrolset\\services\\tcpip\\parameters\\interfaces\\"
    L"fishy";
const wchar_t kNameServerName[] = L"nameserver";
const wchar_t kNameServerValue[] = L"8.8.4.4";
const wchar_t kFakeProgramFolder[] = L"FakeProgram";
const char kFakeProgram[] = "FakeProgram";
const wchar_t kFakeAppDataProgramFolder[] = L"FakeAppDataProgram";
const char kFakeAppDataProgram[] = "FakeAppDataProgram";

const char kExtensionPoliciesNonExistent[] =
    "software\\policies\\google\\chrome\\";

struct ReportTestData {
  HKEY hkey;
  const wchar_t* key_path;
  const wchar_t* name;
  const wchar_t* value;
};

const ReportTestData kExtensionPolicyEmpty{
    HKEY_LOCAL_MACHINE, kChromePoliciesWhitelistKeyPath, L"test1", L""};

constexpr base::char16 kTestingExtensionId1[] =
    L"ababababcdcdcdcdefefefefghghghgh";
constexpr base::char16 kTestingExtensionId1WithUpdateUrl[] =
    L"ababababcdcdcdcdefefefefghghghgh;https://clients2.google.com/service/"
    L"update2/crx";
constexpr base::char16 kTestingExtensionId2[] =
    L"aaaabbbbccccddddeeeeffffgggghhhh";
constexpr base::char16 kTestingExtensionId2WithUpdateUrl[] =
    L"aaaabbbbccccddddeeeeffffgggghhhh;https://clients2.google.com/service/"
    L"update2/crx";

const ReportTestData extension_policies[] = {
    {HKEY_LOCAL_MACHINE, kChromePoliciesWhitelistKeyPath, L"test1",
     kTestingExtensionId1},
    {HKEY_CURRENT_USER, kChromePoliciesWhitelistKeyPath, L"test2",
     kTestingExtensionId1},
    {HKEY_LOCAL_MACHINE, kChromePoliciesForcelistKeyPath, L"test3",
     kTestingExtensionId2WithUpdateUrl},
    {HKEY_CURRENT_USER, kChromePoliciesForcelistKeyPath, L"test4",
     kTestingExtensionId2WithUpdateUrl},
    {HKEY_LOCAL_MACHINE, kChromiumPoliciesWhitelistKeyPath, L"test5",
     kTestingExtensionId1},
    {HKEY_CURRENT_USER, kChromiumPoliciesWhitelistKeyPath, L"test6",
     kTestingExtensionId1},
    {HKEY_LOCAL_MACHINE, kChromiumPoliciesForcelistKeyPath, L"test7",
     kTestingExtensionId2WithUpdateUrl},
    {HKEY_CURRENT_USER, kChromiumPoliciesForcelistKeyPath, L"test8",
     kTestingExtensionId2WithUpdateUrl},
};

const ReportTestData extension_forcelist_policies[] = {
    {HKEY_LOCAL_MACHINE, kChromePoliciesForcelistKeyPath, L"test1",
     kTestingExtensionId1WithUpdateUrl},
    {HKEY_CURRENT_USER, kChromePoliciesForcelistKeyPath, L"test2",
     kTestingExtensionId2WithUpdateUrl},
};

const UwSId kFakePupId = 42;

const wchar_t kFakeChromeFolderForTests[] =
    L"google\\chrome\\application\\42.12.34.56";

const char kDefaultExtensionsJsonForTests[] = R"(
    {
      "ababababcdcdcdcdefefefefghghghgh" : {
        "external_update_url": "https://clients2.google.com/service/update2/crx"
      },
      "aaaabbbbccccddddeeeeffffgggghhhh" : {
        "external_update_url": "https://clients2.google.com/service/update2/crx"
      }
    })";
// Don't include the null-terminator in the length.
const int kDefaultExtensionsJsonForTestsSize =
    sizeof(kDefaultExtensionsJsonForTests) - 1;

// ExtensionSettings that has two force_installed extensions and two not.
const wchar_t kExtensionSettingsJson[] =
    LR"(
    {
      "ababababcdcdcdcdefefefefghghghgh": {
        "installation_mode": "force_installed",
        "update_url":"https://clients2.google.com/service/update2/crx"
      },
      "aaaabbbbccccddddeeeeffffgggghhhh": {
        "installation_mode": "force_installed",
        "update_url":"https://clients2.google.com/service/update2/crx"
      },
      "extensionwithinstallmodeblockeda": {
        "installation_mode": "blocked",
        "update_url":"https://clients2.google.com/service/update2/crx"
      },
      "extensionwithnosettingsabcdefghi": {}
    })";

const ReportTestData extension_settings_entry = {
    HKEY_LOCAL_MACHINE, kChromePoliciesKeyPath, L"ExtensionSettings",
    kExtensionSettingsJson};

const wchar_t kChromeExePathForTests[] = L"google\\chrome\\application";
const wchar_t kMasterPreferencesFileNameForTests[] = L"master_preferences";
const char kMasterPreferencesJsonForTests[] = R"(
    {
      "homepage": "http://dev.chromium.org/",
      "extensions": {
        "settings": {
          "ababababcdcdcdcdefefefefghghghgh": {
            "location": 1,
            "manifest": {
              "name": "Test extension"
            }
          },
          "aaaabbbbccccddddeeeeffffgggghhhh": {
            "location": 1,
            "manifest": {
              "name": "Another one"
            }
          }
        }
      }
    })";

const char kSanitizedLnkPath[] = "CSIDL_PROFILE\\appdata\\roaming";
typedef std::map<base::string16, std::vector<base::string16>>
    ExtensionIdToFileNamesMap;

class SystemReportComponentTest : public testing::Test {
 public:
  SystemReportComponentTest() : component_(&json_parser_, &shortcut_parser_) {}

  void SetUp() override {
    cleaner_logging_service_ = CleanerLoggingService::GetInstance();
    cleaner_logging_service_->Initialize(nullptr);
    cleaner_logging_service_->EnableUploads(true, /*registry_logger=*/nullptr);
    LoggingServiceAPI::SetInstanceForTesting(cleaner_logging_service_);
    registry_override_.OverrideRegistry(HKEY_CURRENT_USER);
    registry_override_.OverrideRegistry(HKEY_LOCAL_MACHINE);

    base::PathService::Get(CsidlToPathServiceKey(CSIDL_APPDATA),
                           &appdata_file_path_);

    ASSERT_TRUE(fake_user_data_.CreateUniqueTempDir());

    extension_id_to_filenames_map_[kTestingExtensionId1] = {L"file1.test",
                                                            L"file2.test"};
    ASSERT_TRUE(CreateProfileWithExtensionAndFiles(
        fake_user_data_.GetPath().Append(L"Profile 1"), kTestingExtensionId1,
        extension_id_to_filenames_map_[kTestingExtensionId1]));

    extension_id_to_filenames_map_[kTestingExtensionId2] = {L"file1.test"};
    ASSERT_TRUE(CreateProfileWithExtensionAndFiles(
        fake_user_data_.GetPath().Append(L"Profile 2"), kTestingExtensionId2,
        extension_id_to_filenames_map_[kTestingExtensionId2]));

    component_.SetUserDataPathForTesting(fake_user_data_.GetPath());
  }

  void TearDown() override {
    LoggingServiceAPI::SetInstanceForTesting(nullptr);
    cleaner_logging_service_->Terminate();
  }

  ChromeCleanerReport GetChromeCleanerReport() {
    ChromeCleanerReport report;
    CHECK(report.ParseFromString(cleaner_logging_service_->RawReportContent()));
    return report;
  }

  TestJsonParser json_parser_;
  FakeShortcutParser shortcut_parser_;
  SystemReportComponent component_;
  CleanerLoggingService* cleaner_logging_service_ = nullptr;
  registry_util::RegistryOverrideManager registry_override_;
  base::FilePath appdata_file_path_;
  base::ScopedTempDir fake_user_data_;
  ExtensionIdToFileNamesMap extension_id_to_filenames_map_;
};

template <typename Component>
bool SomeComponentContainsPath(const RepeatedPtrField<Component>& components,
                               const base::FilePath& path) {
  const std::string name = path.BaseName().MaybeAsASCII();
  const std::string sanitized_path = base::UTF16ToUTF8(SanitizePath(path));
  for (const auto component : components) {
    if (component.name() == name &&
        component.file_information().path() == sanitized_path) {
      return true;
    }
  }
  return false;
}

bool InstalledProgramCollected(
    const RepeatedPtrField<ChromeCleanerReport::SystemReport::InstalledProgram>&
        programs,
    const std::string& folder_name) {
  const std::string lower_case_folder_name = base::ToLowerASCII(folder_name);
  for (const auto& program : programs) {
    if (program.folder_information().path().find(lower_case_folder_name) !=
        std::string::npos) {
      return true;
    }
  }
  return false;
}

bool RegistryEntryCollected(
    const RepeatedPtrField<RegistryValue>& registry_values,
    const std::string& key_path,
    const std::string& value_name,
    const std::string& data) {
  for (const auto& registry_value : registry_values) {
    if (StringContainsCaseInsensitive(registry_value.key_path(), key_path) &&
        registry_value.value_name() == value_name &&
        registry_value.data() == data) {
      return true;
    }
  }
  return false;
}

bool RegistryKeyCollected(
    const RepeatedPtrField<RegistryValue>& registry_values,
    const std::string& key_path) {
  for (const auto& registry_value : registry_values) {
    if (StringContainsCaseInsensitive(registry_value.key_path(), key_path))
      return true;
  }
  return false;
}

// Returns whether |extension_files| contains the expected file information
// of |extension_id|.
::testing::AssertionResult ExtensionsReportedWithExpectedFiles(
    const RepeatedPtrField<InstalledExtension>& reported_extensions,
    const ExtensionIdToFileNamesMap& extension_id_to_filenames_map) {
  for (const auto& installed_extension : reported_extensions) {
    const RepeatedPtrField<FileInformation> extension_files =
        installed_extension.extension_files();

    std::unordered_set<base::string16> expected_files(
        extension_id_to_filenames_map
            .at(base::UTF8ToUTF16(installed_extension.extension_id()))
            .begin(),
        extension_id_to_filenames_map
            .at(base::UTF8ToUTF16(installed_extension.extension_id()))
            .end());

    if (static_cast<size_t>(extension_files.size()) != expected_files.size())
      return ::testing::AssertionFailure()
             << "Different number of files than expected for extension "
             << installed_extension.extension_id();

    for (const auto& file : extension_files) {
      base::string16 file_name =
          base::FilePath(base::UTF8ToUTF16(file.path())).BaseName().value();

      if (expected_files.find(file_name) == expected_files.end())
        return ::testing::AssertionFailure()
               << "file : " << file_name << " not reported for extension "
               << installed_extension.extension_id();
    }
  }
  return ::testing::AssertionSuccess();
}

// Returns whether |reported_extensions| contains an entry for an extension with
// |extension_id| and |install_method|.
bool InstalledExtensionReported(
    const RepeatedPtrField<InstalledExtension>& reported_extensions,
    const std::wstring& extension_id,
    ExtensionInstallMethod install_method) {
  for (const auto& installed_extension : reported_extensions) {
    if (installed_extension.extension_id() == base::WideToUTF8(extension_id) &&
        installed_extension.install_method() == install_method) {
      return true;
    }
  }
  return false;
}

}  // namespace

TEST_F(SystemReportComponentTest, PreScan_NoDetailedReport) {
  component_.PreScan();
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostScanNoUwS_DetailedReport) {
  std::vector<UwSId> found_pups;
  component_.PostScan(found_pups);
  EXPECT_TRUE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostScanNonRemovalableUwS_DetailedReport) {
  TestPUPData test_pup_data;
  test_pup_data.AddPUP(kFakePupId, PUPData::FLAGS_NONE, nullptr,
                       PUPData::kMaxFilesToRemoveSmallUwS);
  std::vector<UwSId> found_pups;
  found_pups.push_back(kFakePupId);
  component_.PostScan(found_pups);
  EXPECT_TRUE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostScanRemovalableUwS_NoDetailedReport) {
  TestPUPData test_pup_data;
  test_pup_data.AddPUP(kFakePupId, PUPData::FLAGS_ACTION_REMOVE, nullptr,
                       PUPData::kMaxFilesToRemoveSmallUwS);
  std::vector<UwSId> found_pups;
  found_pups.push_back(kFakePupId);
  component_.PostScan(found_pups);
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PreCleanup_NoDetailedReport) {
  component_.PreCleanup();
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostCleanup_DetailedReport) {
  component_.PostCleanup(RESULT_CODE_SUCCESS, nullptr);
  EXPECT_TRUE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostCleanup_canceled_NoDetailedReport) {
  component_.PostCleanup(RESULT_CODE_CANCELED, nullptr);
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, PostValidation_NoDetailedReport) {
  component_.PostValidation(RESULT_CODE_SUCCESS);
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, OnClose_NoDetailedReport) {
  component_.OnClose(RESULT_CODE_SUCCESS);
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, DisableUploads) {
  cleaner_logging_service_->EnableUploads(false, nullptr);

  component_.CreateFullSystemReport();
  EXPECT_FALSE(component_.created_report());
}

TEST_F(SystemReportComponentTest, NoRepeatedCollections) {
  component_.CreateFullSystemReport();
  EXPECT_TRUE(component_.created_report());

  // Clear the report and ensure it isn't populated again, since
  // |created_report| is still true.
  EXPECT_LT(0, GetChromeCleanerReport().system_report().processes_size());
  cleaner_logging_service_->Terminate();
  cleaner_logging_service_->Initialize(/*registry_logger=*/nullptr);
  EXPECT_EQ(0, GetChromeCleanerReport().system_report().processes_size());
  component_.CreateFullSystemReport();
  EXPECT_EQ(0, GetChromeCleanerReport().system_report().processes_size());
}

TEST_F(SystemReportComponentTest, DetectFakePrograms) {
  base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
  base::FilePath program_files_dir;
  ASSERT_TRUE(
      base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

  base::ScopedPathOverride appdata_override(base::DIR_LOCAL_APP_DATA);
  base::FilePath appdata_dir;
  ASSERT_TRUE(base::PathService::Get(base::DIR_LOCAL_APP_DATA, &appdata_dir));

  // Setup a fake program installation folder.
  base::FilePath fake_program_dir(program_files_dir.Append(kFakeProgramFolder));
  ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_program_dir, nullptr));
  ASSERT_TRUE(CreateFileInFolder(fake_program_dir, L"fake.exe"));

  base::FilePath fake_appdata_dir(
      appdata_dir.Append(kFakeAppDataProgramFolder));
  ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_appdata_dir, nullptr));
  ASSERT_TRUE(CreateFileInFolder(fake_appdata_dir, L"fake.exe"));

  // Setup a fake runonce keys.
  base::win::RegKey run_once(HKEY_CURRENT_USER, kRunKeyPath, KEY_WRITE);
  ASSERT_TRUE(run_once.Valid());
  ASSERT_EQ(run_once.WriteValue(kRunTestName, kRunTestValue), ERROR_SUCCESS);

  component_.CreateFullSystemReport();

  ChromeCleanerReport report = GetChromeCleanerReport();
  const auto& system_report = report.system_report();

  const base::FilePath module_path =
      PreFetchedPaths::GetInstance()->GetExecutablePath();
  EXPECT_TRUE(
      SomeComponentContainsPath(system_report.loaded_modules(), module_path));

  EXPECT_TRUE(
      SomeComponentContainsPath(system_report.processes(), module_path));

  EXPECT_TRUE(RegistryEntryCollected(
      system_report.registry_values(), base::UTF16ToASCII(kRunKeyPath),
      base::UTF16ToASCII(kRunTestName), base::UTF16ToASCII(kRunTestValue)));

  EXPECT_TRUE(InstalledProgramCollected(system_report.installed_programs(),
                                        kFakeProgram));
  EXPECT_TRUE(InstalledProgramCollected(system_report.installed_programs(),
                                        kFakeAppDataProgram));
}

TEST_F(SystemReportComponentTest, ReportNameServer) {
  // Setup a fake key that triggers nameserver check.
  base::win::RegKey nameserver_key;
  ASSERT_EQ(ERROR_SUCCESS,
            nameserver_key.Create(HKEY_LOCAL_MACHINE, kNameServerKeyPath,
                                  KEY_ALL_ACCESS));
  ASSERT_TRUE(nameserver_key.Valid());
  ASSERT_EQ(nameserver_key.WriteValue(kNameServerName, kNameServerValue),
            ERROR_SUCCESS);

  component_.CreateFullSystemReport();

  EXPECT_TRUE(RegistryEntryCollected(
      GetChromeCleanerReport().system_report().registry_values(),
      base::UTF16ToASCII(kNameServerKeyPath),
      base::UTF16ToASCII(kNameServerName),
      base::UTF16ToASCII(kNameServerValue)));
}

TEST_F(SystemReportComponentTest, ReportNameServerBadValue) {
  // Setup a fake key that triggers nameserver check.
  base::win::RegKey nameserver_key;
  ASSERT_EQ(ERROR_SUCCESS,
            nameserver_key.Create(HKEY_LOCAL_MACHINE, kNameServerKeyPath,
                                  KEY_ALL_ACCESS));
  ASSERT_TRUE(nameserver_key.Valid());
  ASSERT_EQ(nameserver_key.WriteValue(kNameServerName, L""), ERROR_SUCCESS);

  component_.CreateFullSystemReport();

  EXPECT_FALSE(RegistryKeyCollected(
      GetChromeCleanerReport().system_report().registry_values(),
      base::UTF16ToASCII(kNameServerKeyPath)));
}

TEST_F(SystemReportComponentTest, ReportNameServerNonExistent) {
  component_.CreateFullSystemReport();

  EXPECT_FALSE(RegistryKeyCollected(
      GetChromeCleanerReport().system_report().registry_values(),
      base::UTF16ToASCII(kNameServerKeyPath)));
}

TEST_F(SystemReportComponentTest, ReportExtensionPolicies) {
  for (const auto& extension_policy : extension_policies) {
    base::win::RegKey policy_key;
    ASSERT_EQ(ERROR_SUCCESS,
              policy_key.Create(extension_policy.hkey,
                                extension_policy.key_path, KEY_ALL_ACCESS));
    ASSERT_TRUE(policy_key.Valid());
    ASSERT_EQ(
        policy_key.WriteValue(extension_policy.name, extension_policy.value),
        ERROR_SUCCESS);
  }

  component_.CreateFullSystemReport();

  ChromeCleanerReport report = GetChromeCleanerReport();
  const auto& system_report = report.system_report();
  for (const auto& extension_policy : extension_policies) {
    EXPECT_TRUE(
        RegistryEntryCollected(system_report.registry_values(),
                               base::UTF16ToASCII(extension_policy.key_path),
                               base::UTF16ToASCII(extension_policy.name),
                               base::UTF16ToASCII(extension_policy.value)));
  }
}

TEST_F(SystemReportComponentTest, ReportExtensionPoliciesBadValue) {
  base::win::RegKey policy_key;
  ASSERT_EQ(ERROR_SUCCESS,
            policy_key.Create(kExtensionPolicyEmpty.hkey,
                              kExtensionPolicyEmpty.key_path, KEY_ALL_ACCESS));
  ASSERT_TRUE(policy_key.Valid());
  ASSERT_EQ(policy_key.WriteValue(kExtensionPolicyEmpty.name,
                                  kExtensionPolicyEmpty.value),
            ERROR_SUCCESS);
  component_.CreateFullSystemReport();
  EXPECT_FALSE(RegistryKeyCollected(
      GetChromeCleanerReport().system_report().registry_values(),
      base::UTF16ToASCII(kExtensionPolicyEmpty.key_path)));
}

TEST_F(SystemReportComponentTest, ReportExtensionPoliciesNonExistent) {
  component_.CreateFullSystemReport();

  EXPECT_FALSE(RegistryKeyCollected(
      GetChromeCleanerReport().system_report().registry_values(),
      kExtensionPoliciesNonExistent));
}

TEST_F(SystemReportComponentTest, ReportForcelistExtensions) {
  for (const ReportTestData& policy : extension_forcelist_policies) {
    base::win::RegKey policy_key;
    ASSERT_EQ(ERROR_SUCCESS,
              policy_key.Create(policy.hkey, policy.key_path, KEY_ALL_ACCESS));
    ASSERT_TRUE(policy_key.Valid());
    ASSERT_EQ(ERROR_SUCCESS, policy_key.WriteValue(policy.name, policy.value));
  }

  base::test::ScopedCommandLine scoped_command_line;
  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();

  for (const ReportTestData& expected : extension_forcelist_policies) {
    std::wstring policy_value(expected.value);
    EXPECT_TRUE(InstalledExtensionReported(
        report.system_report().installed_extensions(),
        policy_value.substr(0, kExtensionIdLength),
        ExtensionInstallMethod::POLICY_EXTENSION_FORCELIST));
  }
}

TEST_F(SystemReportComponentTest, ReportDefaultExtensions) {
  // Set up a fake default extensions JSON file.
  base::ScopedPathOverride program_files_x86_override(
      base::DIR_PROGRAM_FILESX86);
  base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
  base::FilePath program_files_dir;
  ASSERT_TRUE(
      base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

  base::FilePath fake_apps_dir(
      program_files_dir.Append(kFakeChromeFolderForTests)
          .Append(L"default_apps"));
  ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

  base::FilePath default_extensions_file =
      fake_apps_dir.Append(L"external_extensions.json");
  CreateFileWithContent(default_extensions_file, kDefaultExtensionsJsonForTests,
                        kDefaultExtensionsJsonForTestsSize);
  ASSERT_TRUE(base::PathExists(default_extensions_file));

  base::test::ScopedCommandLine scoped_command_line;
  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();

  EXPECT_EQ(2, report.system_report().installed_extensions().size());
  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId1,
      ExtensionInstallMethod::DEFAULT_APPS_EXTENSION));
  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId2,
      ExtensionInstallMethod::DEFAULT_APPS_EXTENSION));

  EXPECT_TRUE(ExtensionsReportedWithExpectedFiles(
      report.system_report().installed_extensions(),
      extension_id_to_filenames_map_));
}

TEST_F(SystemReportComponentTest, ReportExtensionSettings) {
  // Set up a fake ExtensionSettings registry key.
  base::win::RegKey settings_key;
  ASSERT_EQ(
      ERROR_SUCCESS,
      settings_key.Create(extension_settings_entry.hkey,
                          extension_settings_entry.key_path, KEY_ALL_ACCESS));
  DCHECK(settings_key.Valid());
  ASSERT_EQ(ERROR_SUCCESS,
            settings_key.WriteValue(extension_settings_entry.name,
                                    extension_settings_entry.value));

  base::test::ScopedCommandLine scoped_command_line;
  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();

  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId1,
      ExtensionInstallMethod::POLICY_EXTENSION_SETTINGS));
  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId2,
      ExtensionInstallMethod::POLICY_EXTENSION_SETTINGS));

  EXPECT_TRUE(ExtensionsReportedWithExpectedFiles(
      report.system_report().installed_extensions(),
      extension_id_to_filenames_map_));
}

TEST_F(SystemReportComponentTest, ReportMasterPreferencesExtensions) {
  // Set up a fake master preferences file
  base::ScopedPathOverride program_files_x86_override(
      base::DIR_PROGRAM_FILESX86);
  base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
  base::FilePath program_files_dir;
  ASSERT_TRUE(
      base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

  base::FilePath chrome_dir(program_files_dir.Append(kChromeExePathForTests));
  ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

  base::FilePath master_preferences =
      chrome_dir.Append(kMasterPreferencesFileNameForTests);
  CreateFileWithContent(master_preferences, kMasterPreferencesJsonForTests,
                        sizeof(kMasterPreferencesJsonForTests) - 1);
  ASSERT_TRUE(base::PathExists(master_preferences));

  base::test::ScopedCommandLine scoped_command_line;
  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();

  EXPECT_EQ(2, report.system_report().installed_extensions().size());
  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId1,
      ExtensionInstallMethod::POLICY_MASTER_PREFERENCES));
  EXPECT_TRUE(InstalledExtensionReported(
      report.system_report().installed_extensions(), kTestingExtensionId2,
      ExtensionInstallMethod::POLICY_MASTER_PREFERENCES));

  EXPECT_TRUE(ExtensionsReportedWithExpectedFiles(
      report.system_report().installed_extensions(),
      extension_id_to_filenames_map_));
}

TEST_F(SystemReportComponentTest,
       ReportModifiedShortcutWithCommandLineArguments) {
  const base::string16 kShortcutArguments =
      L"--some-flag --some-other-scary-flag --flag-with-personal-data=" +
      appdata_file_path_.value();
  const int kArgumentSize = 3;
  ShortcutInformation shortcut_with_command_line_arguments;
  shortcut_with_command_line_arguments.lnk_path = appdata_file_path_;
  shortcut_with_command_line_arguments.target_path =
      (appdata_file_path_.Append(L"chrome.exe")).value();
  shortcut_with_command_line_arguments.command_line_arguments =
      kShortcutArguments;

  std::vector<ShortcutInformation> fake_parsed_shortcuts;
  fake_parsed_shortcuts.push_back(shortcut_with_command_line_arguments);

  shortcut_parser_.SetShortcutsToReturn(fake_parsed_shortcuts);

  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();
  ASSERT_EQ(report.system_report().shortcut_data().size(), 1);
  ChromeCleanerReport_SystemReport_ShortcutData shortcut_data =
      report.system_report().shortcut_data(0);

  EXPECT_EQ(shortcut_data.lnk_path(), kSanitizedLnkPath);

  const std::string kSanitizedFakeChromePath = "CSIDL_APPDATA\\chrome.exe";
  EXPECT_EQ(shortcut_data.executable_path(), kSanitizedFakeChromePath);

  ASSERT_EQ(shortcut_data.command_line_arguments().size(), kArgumentSize);
  EXPECT_EQ(
      shortcut_data.command_line_arguments(0),
      base::JoinString({"--flag-with-personal-data=", kSanitizedLnkPath}, ""));
  EXPECT_EQ(shortcut_data.command_line_arguments(1), "--some-flag");
  EXPECT_EQ(shortcut_data.command_line_arguments(2), "--some-other-scary-flag");
}

TEST_F(SystemReportComponentTest, ReportShortcutWithPersonalSite) {
  const base::string16 kPersonalSite =
      L"http://www.somesite.com/user/happy_user";
  const std::string kSanitizedPersonalSite = "http://www.somesite.com";
  ShortcutInformation shortcut_with_personal_site;
  shortcut_with_personal_site.lnk_path = appdata_file_path_;
  shortcut_with_personal_site.target_path =
      (appdata_file_path_.Append(L"chrome.exe")).value();
  shortcut_with_personal_site.command_line_arguments = kPersonalSite;

  std::vector<ShortcutInformation> fake_parsed_shortcuts;
  fake_parsed_shortcuts.push_back(shortcut_with_personal_site);
  shortcut_parser_.SetShortcutsToReturn(fake_parsed_shortcuts);

  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();
  ASSERT_EQ(report.system_report().shortcut_data().size(), 1);
  ChromeCleanerReport_SystemReport_ShortcutData shortcut_data =
      report.system_report().shortcut_data(0);

  ASSERT_EQ(shortcut_data.command_line_arguments().size(), 1);
  EXPECT_EQ(shortcut_data.lnk_path(), kSanitizedLnkPath);

  const std::string kSanitizedFakeChromePath = "CSIDL_APPDATA\\chrome.exe";
  EXPECT_EQ(shortcut_data.executable_path(), kSanitizedFakeChromePath);

  ASSERT_EQ(shortcut_data.command_line_arguments().size(), 1);
  EXPECT_EQ(shortcut_data.command_line_arguments(0), kSanitizedPersonalSite);
}

TEST_F(SystemReportComponentTest, ReportShortcutWithDifferentTarget) {
  ShortcutInformation shortcut_with_different_target;
  shortcut_with_different_target.lnk_path = appdata_file_path_;
  shortcut_with_different_target.target_path =
      (appdata_file_path_.Append(L"totallynotuws.exe")).value();
  shortcut_with_different_target.command_line_arguments = L"";

  std::vector<ShortcutInformation> fake_parsed_shortcuts;
  fake_parsed_shortcuts.push_back(shortcut_with_different_target);
  shortcut_parser_.SetShortcutsToReturn(fake_parsed_shortcuts);

  component_.CreateFullSystemReport();

  ChromeCleanerReport report = GetChromeCleanerReport();
  ASSERT_EQ(report.system_report().shortcut_data().size(), 1);
  ChromeCleanerReport_SystemReport_ShortcutData shortcut_data =
      report.system_report().shortcut_data(0);

  EXPECT_EQ(shortcut_data.lnk_path(), kSanitizedLnkPath);

  const std::string kSanitizedFakeUwSFile = "CSIDL_APPDATA\\totallynotuws.exe";
  EXPECT_EQ(shortcut_data.executable_path(), kSanitizedFakeUwSFile);

  EXPECT_EQ(shortcut_data.command_line_arguments().size(), 0);
}

TEST_F(SystemReportComponentTest, DoNotReportShortcutWithoutModifications) {
  ShortcutInformation not_modified_shortcut;
  not_modified_shortcut.lnk_path = appdata_file_path_;
  not_modified_shortcut.target_path =
      (appdata_file_path_.Append(L"chrome.exe")).value();
  not_modified_shortcut.command_line_arguments = L"";

  std::vector<ShortcutInformation> fake_parsed_shortcuts;
  fake_parsed_shortcuts.push_back(not_modified_shortcut);
  shortcut_parser_.SetShortcutsToReturn(fake_parsed_shortcuts);

  component_.CreateFullSystemReport();
  ChromeCleanerReport report = GetChromeCleanerReport();
  EXPECT_EQ(report.system_report().shortcut_data().size(), 0);
}
}  // namespace chrome_cleaner