chrome/browser/ash/policy/skyvault/test/skyvault_test_utils.h

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

#ifndef CHROME_BROWSER_ASH_POLICY_SKYVAULT_TEST_SKYVAULT_TEST_UTILS_H_
#define CHROME_BROWSER_ASH_POLICY_SKYVAULT_TEST_SKYVAULT_TEST_UTILS_H_

#include "base/test/gmock_callback_support.h"
#include "chrome/browser/ash/policy/skyvault/local_files_migration_manager.h"
#include "chrome/browser/ash/policy/skyvault/migration_coordinator.h"
#include "chrome/browser/ash/policy/skyvault/migration_notification_manager.h"
#include "chrome/browser/ash/policy/skyvault/policy_utils.h"
#include "testing/gmock/include/gmock/gmock.h"

namespace policy::local_user_files {
namespace {
inline constexpr char kEmail[] = "stub-user@example.com";
}

// Matcher for `SetUserDataStorageWriteEnabledRequest`.
MATCHER_P(WithEnabled, enabled, "") {
  return arg.account_id().account_id() == kEmail && arg.enabled() == enabled;
}

// GMock action that runs the callback (which is expected to be the second
// argument in the mocked function) with the given reply.
template <typename ReplyType>
auto ReplyWith(const ReplyType& reply) {
  return base::test::RunOnceCallbackRepeatedly<1>(reply);
}

// Mock implementation of LocalFilesMigrationManager::Observer.
class MockMigrationObserver : public LocalFilesMigrationManager::Observer {
 public:
  MockMigrationObserver();
  ~MockMigrationObserver();

  MOCK_METHOD(void, OnMigrationSucceeded, (), (override));

  MOCK_METHOD(void, OnMigrationReset, (), (override));
};

// Mock implementation of MigrationNotificationManager.
class MockMigrationNotificationManager : public MigrationNotificationManager {
 public:
  explicit MockMigrationNotificationManager(content::BrowserContext* context);
  ~MockMigrationNotificationManager() override;

  MOCK_METHOD(void,
              ShowMigrationInfoDialog,
              (MigrationDestination, base::Time, base::OnceClosure),
              (override));

  MOCK_METHOD(void,
              ShowConfigurationErrorNotification,
              (MigrationDestination),
              (override));

  MOCK_METHOD(void, ShowDeletionCompletedNotification, (), (override));
};

// Mock implementation of MigrationCoordinator, with the default behavior to
// succeed the upload with a small delay.
class MockMigrationCoordinator : public MigrationCoordinator {
 public:
  explicit MockMigrationCoordinator(Profile* profile);
  ~MockMigrationCoordinator() override;

  // MigrationCoordinator overrides:
  bool IsRunning() const override { return is_running_; }
  void OnMigrationDone(MigrationDoneCallback callback,
                       std::map<base::FilePath, MigrationUploadError> errors,
                       base::FilePath upload_root_path,
                       base::FilePath error_log_path) override;

  // By default waits some minutes and completes the upload successfully.
  MOCK_METHOD(void,
              Run,
              (MigrationDestination,
               std::vector<base::FilePath>,
               const std::string&,
               MigrationDoneCallback),
              (override));
  MOCK_METHOD(void, Cancel, (MigrationStoppedCallback callback), (override));

  // Sets a callback to be invoked when Run() is called.
  void SetRunCallback(base::RepeatingClosure run_cb);

 private:
  bool is_running_ = false;
  // If set, invoked when Run() is.
  base::RepeatingClosure run_cb_;

  base::WeakPtrFactory<MockMigrationCoordinator> weak_ptr_factory_{this};
};

// Mock implementation of FilesCleanupHandler. By default, cleanup succeeds
// immediately.
class MockCleanupHandler : public chromeos::FilesCleanupHandler {
 public:
  MockCleanupHandler();

  MockCleanupHandler(const MockCleanupHandler&) = delete;
  MockCleanupHandler& operator=(const MockCleanupHandler&) = delete;

  ~MockCleanupHandler() override;

  base::WeakPtr<MockCleanupHandler> GetWeakPtr() {
    return weak_ptr_factory_.GetWeakPtr();
  }

  MOCK_METHOD(void, Cleanup, (CleanupHandlerCallback callback), (override));

 private:
  base::WeakPtrFactory<MockCleanupHandler> weak_ptr_factory_{this};
};

}  // namespace policy::local_user_files

#endif  // CHROME_BROWSER_ASH_POLICY_SKYVAULT_TEST_SKYVAULT_TEST_UTILS_H_