// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/policy/uploading/system_log_uploader.h"

#include <map>
#include <utility>

#include "base/containers/contains.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_simple_task_runner.h"
#include "base/time/time.h"
#include "chrome/browser/ash/settings/scoped_cros_settings_test_helper.h"
#include "chrome/browser/prefs/browser_prefs.h"
#include "chrome/common/chrome_features.h"
#include "chrome/test/base/scoped_testing_local_state.h"
#include "chrome/test/base/testing_browser_process.h"
#include "components/policy/core/common/remote_commands/remote_command_job.h"
#include "components/prefs/testing_pref_service.h"
#include "content/public/test/browser_task_environment.h"
#include "content/public/test/test_utils.h"
#include "net/http/http_request_headers.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gmock/include/gmock/gmock.h"

using ::testing::ContainerEq;

namespace policy {

namespace {

constexpr char kPolicyDump[] = "{}";

// The list of tested system log file names.
const char* const kTestSystemLogFileNames[] = {"name1.txt", "name32.txt"};

constexpr char kZippedData[] = "zipped_data";

constexpr RemoteCommandJob::UniqueIDType kCommandId = 12345;

// Generate the fake system log files.
SystemLogUploader::SystemLogs GenerateTestSystemLogFiles() {
  SystemLogUploader::SystemLogs system_logs;
  for (auto* file_path : kTestSystemLogFileNames) {
    system_logs.push_back(std::make_pair(file_path, file_path));
  }
  return system_logs;
}

class MockUploadJob : public UploadJob {
 public:
  // If is_upload_error is false OnSuccess() will be invoked when the
  // Start() method is called, otherwise OnFailure() will be invoked.
  MockUploadJob(UploadJob::Delegate* delegate,
                bool is_upload_error,
                bool is_immediate_upload);
  ~MockUploadJob() override;

  // policy::UploadJob:
  void AddDataSegment(const std::string& name,
                      const std::string& filename,
                      const std::map<std::string, std::string>& header_entries,
                      std::unique_ptr<std::string> data) override;
  void Start() override;

 protected:
  const std::map<std::string, std::string> kExpectedUploadHeaders = {
      {SystemLogUploader::kFileTypeHeaderName,
       SystemLogUploader::kFileTypeZippedLogFile},
      {net::HttpRequestHeaders::kContentType,
       SystemLogUploader::kContentTypeOctetStream}};

  // Immediate upload headers need to contain "Command-ID" field as they're
  // triggered by a remote command.
  const std::map<std::string, std::string> kExpectedHeadersImmediateUpload = {
      {SystemLogUploader::kFileTypeHeaderName,
       SystemLogUploader::kFileTypeZippedLogFile},
      {net::HttpRequestHeaders::kContentType,
       SystemLogUploader::kContentTypeOctetStream},
      {SystemLogUploader::kCommandIdHeaderName,
       base::NumberToString(kCommandId)}};

  raw_ptr<UploadJob::Delegate> delegate_;
  bool is_upload_error_;
  bool is_immediate_upload_;
};

MockUploadJob::MockUploadJob(UploadJob::Delegate* delegate,
                             bool is_upload_error,
                             bool is_immediate_upload)
    : delegate_(delegate),
      is_upload_error_(is_upload_error),
      is_immediate_upload_(is_immediate_upload) {}

MockUploadJob::~MockUploadJob() = default;

void MockUploadJob::AddDataSegment(
    const std::string& name,
    const std::string& filename,
    const std::map<std::string, std::string>& header_entries,
    std::unique_ptr<std::string> data) {
  // Test all fields to upload.
  EXPECT_EQ(SystemLogUploader::kZippedLogsName, name);

  EXPECT_EQ(SystemLogUploader::kZippedLogsFileName, filename);

  EXPECT_THAT(header_entries,
              ContainerEq(is_immediate_upload_ ? kExpectedHeadersImmediateUpload
                                               : kExpectedUploadHeaders));
  EXPECT_EQ(kZippedData, *data);
}

void MockUploadJob::Start() {
  DCHECK(delegate_);

  if (is_upload_error_) {
    // Send any ErrorCode.
    delegate_->OnFailure(UploadJob::ErrorCode::NETWORK_ERROR);
  } else {
    delegate_->OnSuccess();
  }
}

// MockSystemLogDelegate - mock class that creates an upload job and runs upload
// callback.
class MockSystemLogDelegate : public SystemLogUploader::Delegate {
 public:
  MockSystemLogDelegate(bool is_upload_error,
                        const SystemLogUploader::SystemLogs& system_logs,
                        bool is_immediate_upload)
      : is_upload_error_(is_upload_error),
        is_immediate_upload_(is_immediate_upload),
        system_logs_(system_logs) {}
  ~MockSystemLogDelegate() override = default;

  std::string GetPolicyAsJSON() override { return kPolicyDump; }

  void LoadSystemLogs(LogUploadCallback upload_callback) override {
    EXPECT_TRUE(is_upload_allowed_);
    std::move(upload_callback)
        .Run(std::make_unique<SystemLogUploader::SystemLogs>(system_logs_));
  }

  std::unique_ptr<UploadJob> CreateUploadJob(
      const GURL& url,
      UploadJob::Delegate* delegate) override {
    return std::make_unique<MockUploadJob>(delegate, is_upload_error_,
                                           is_immediate_upload_);
  }

  void ZipSystemLogs(std::unique_ptr<SystemLogUploader::SystemLogs> system_logs,
                     ZippedLogUploadCallback upload_callback) override {
    for (const auto& log : system_logs_)
      EXPECT_TRUE(base::Contains(*system_logs, log));
    std::move(upload_callback).Run(std::string(kZippedData));
  }

  void set_upload_allowed(bool is_upload_allowed) {
    is_upload_allowed_ = is_upload_allowed;
  }

 private:
  bool is_upload_allowed_;
  bool is_upload_error_;
  bool is_immediate_upload_;
  SystemLogUploader::SystemLogs system_logs_;
};

class MockSystemLogUploader : public SystemLogUploader {
 public:
  MockSystemLogUploader(
      std::unique_ptr<Delegate> syslog_delegate,
      const scoped_refptr<base::SequencedTaskRunner>& task_runner)
      : SystemLogUploader(std::move(syslog_delegate), task_runner) {}
  MOCK_METHOD(void, OnSuccess, (), (override));
};

}  //  namespace

class SystemLogUploaderTest : public testing::TestWithParam<bool> {
 public:
  SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {}

  void SetUp() override {
    settings_helper_.ReplaceDeviceSettingsProviderWithStub();
  }

  void TearDown() override {
    settings_helper_.RestoreRealDeviceSettingsProvider();
    content::RunAllTasksUntilIdle();
  }

  // Given a pending task to upload system logs.
  void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader,
                                        base::TimeDelta expected_delay) {
    EXPECT_TRUE(task_runner_->HasPendingTask());
    task_runner_->RunPendingTasks();

    // The previous task should have uploaded another log upload task.
    EXPECT_EQ(1U, task_runner_->NumPendingTasks());

    CheckPendingTaskDelay(uploader, expected_delay);
  }

  void CheckPendingTaskDelay(const SystemLogUploader& uploader,
                             base::TimeDelta expected_delay) {
    // The next task should be scheduled sometime between
    // |last_upload_attempt| + |expected_delay| and
    // |now| + |expected_delay|.
    base::Time now = base::Time::NowFromSystemTime();
    base::Time next_task = now + task_runner_->NextPendingTaskDelay();

    EXPECT_LE(next_task, now + expected_delay);
    EXPECT_GE(next_task, uploader.last_upload_attempt() + expected_delay);
  }

 protected:
  content::BrowserTaskEnvironment task_environment_;
  ScopedTestingLocalState scoped_testing_local_state_{
      TestingBrowserProcess::GetGlobal()};
  ash::ScopedCrosSettingsTestHelper settings_helper_;
  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
  base::test::ScopedFeatureList feature_list;
};

// Verify log throttling. Try successive kLogThrottleCount log uploads by
// creating a new task. First kLogThrottleCount logs should have 0 delay.
// Successive logs should have delay greater than zero.
TEST_P(SystemLogUploaderTest, LogThrottleTest) {
  for (int upload_num = 0;
       upload_num < SystemLogUploader::kLogThrottleCount + 3; upload_num++) {
    EXPECT_FALSE(task_runner_->HasPendingTask());
    auto syslog_delegate = std::make_unique<MockSystemLogDelegate>(
        false, SystemLogUploader::SystemLogs(), /*is_immediate_upload=*/false);

    syslog_delegate->set_upload_allowed(true);
    settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);

    SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

    EXPECT_EQ(1U, task_runner_->NumPendingTasks());

    if (upload_num < SystemLogUploader::kLogThrottleCount) {
      EXPECT_EQ(task_runner_->NextPendingTaskDelay(), base::Milliseconds(0));
    } else {
      EXPECT_GT(task_runner_->NextPendingTaskDelay(), base::Milliseconds(0));
    }

    task_runner_->RunPendingTasks();
    task_runner_->ClearPendingTasks();
  }
}

// Verify that we never throttle immediate log upload.
TEST_P(SystemLogUploaderTest, ImmediateLogUpload) {
  EXPECT_FALSE(task_runner_->HasPendingTask());
  auto syslog_delegate = std::make_unique<MockSystemLogDelegate>(
      false, SystemLogUploader::SystemLogs(), /*is_immediate_upload=*/true);

  syslog_delegate->set_upload_allowed(true);
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);

  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
  for (int upload_num = 0;
       upload_num < SystemLogUploader::kLogThrottleCount + 3; upload_num++) {
    uploader.ScheduleNextSystemLogUploadImmediately(kCommandId);
    EXPECT_EQ(task_runner_->NextPendingTaskDelay(), base::Milliseconds(0));
    task_runner_->RunPendingTasks();
    task_runner_->ClearPendingTasks();
  }
}

// Check disabled system log uploads by default.
TEST_P(SystemLogUploaderTest, Basic) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/false,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  syslog_delegate->set_upload_allowed(false);
  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  task_runner_->RunPendingTasks();
}

// One success task pending.
TEST_P(SystemLogUploaderTest, SuccessTest) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/false,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  syslog_delegate->set_upload_allowed(true);
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  EXPECT_EQ(1U, task_runner_->NumPendingTasks());

  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kDefaultUploadDelayMs));
}

// Three failed responses received.
TEST_P(SystemLogUploaderTest, ThreeFailureTest) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/true,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  syslog_delegate->set_upload_allowed(true);
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  EXPECT_EQ(1U, task_runner_->NumPendingTasks());

  // Do not retry two times consequentially.
  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kErrorUploadDelayMs));
  // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here
  // because there's just one retry.
  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kDefaultUploadDelayMs));
  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kErrorUploadDelayMs));
}

// Check header fields of system log files to upload.
TEST_P(SystemLogUploaderTest, CheckHeaders) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles();
  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/false, system_logs,
                                /*is_immediate_upload=*/false));
  syslog_delegate->set_upload_allowed(true);
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  EXPECT_EQ(1U, task_runner_->NumPendingTasks());

  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kDefaultUploadDelayMs));
}

// Disable system log uploads after one failed log upload.
TEST_P(SystemLogUploaderTest, DisableLogUpload) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/true,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  mock_delegate->set_upload_allowed(true);
  SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kErrorUploadDelayMs));

  // Disable log upload and check that frequency is usual, because there is no
  // errors, we should not upload logs.
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, false);
  mock_delegate->set_upload_allowed(false);
  task_runner_->RunPendingTasks();

  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kDefaultUploadDelayMs));
  RunPendingUploadTaskAndCheckNext(
      uploader, base::Milliseconds(SystemLogUploader::kDefaultUploadDelayMs));
}

// Test that we observe for settings to become trusted and create log jobs
// when the settings become trusted.
TEST_F(SystemLogUploaderTest, DeviceSettingsPendingToTrusted) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/false,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  settings_helper_.SetTrustedStatus(
      ash::CrosSettingsProvider::TEMPORARILY_UNTRUSTED);
  mock_delegate->set_upload_allowed(true);
  MockSystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  // We should only see one log job success case after running all of the tasks.
  EXPECT_CALL(uploader, OnSuccess()).Times(1);

  // Tasks should not be pending while trusted settings are pending.
  EXPECT_EQ(0U, task_runner_->NumPendingTasks());

  // Change settings to trusted to trigger
  // the log uploader's settings observer callback.
  settings_helper_.SetTrustedStatus(ash::CrosSettingsProvider::TRUSTED);

  // There should be a pending task now
  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
  task_runner_->RunPendingTasks();
}

// Test that log jobs are not created when settings are untrusted
// and permanently untrusted.
TEST_F(SystemLogUploaderTest, DeviceSettingsPendingToUntrusted) {
  EXPECT_FALSE(task_runner_->HasPendingTask());

  std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
      new MockSystemLogDelegate(/*is_upload_error=*/false,
                                SystemLogUploader::SystemLogs(),
                                /*is_immediate_upload=*/false));
  MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
  settings_helper_.SetBoolean(ash::kSystemLogUploadEnabled, true);
  settings_helper_.SetTrustedStatus(
      ash::CrosSettingsProvider::TEMPORARILY_UNTRUSTED);
  mock_delegate->set_upload_allowed(true);
  MockSystemLogUploader uploader(std::move(syslog_delegate), task_runner_);

  // We should not see any log job successes after running all of the tasks.
  EXPECT_CALL(uploader, OnSuccess()).Times(0);

  // Tasks should not be pending while trusted settings are pending.
  EXPECT_EQ(0U, task_runner_->NumPendingTasks());

  // Change settings to permanently untrusted.
  settings_helper_.SetTrustedStatus(
      ash::CrosSettingsProvider::PERMANENTLY_UNTRUSTED);

  // Tasks should not be pending if trusted settings are permanently untrusted.
  EXPECT_EQ(0U, task_runner_->NumPendingTasks());
}

INSTANTIATE_TEST_SUITE_P(SystemLogUploaderTestInstance,
                         SystemLogUploaderTest,
                         testing::Bool());

}  // namespace policy