// 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.

#include "chrome/browser/ash/file_system_provider/cloud_file_system.h"

#include "base/base64.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/run_loop.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/test_future.h"
#include "chrome/browser/ash/file_system_provider/abort_callback.h"
#include "chrome/browser/ash/file_system_provider/content_cache/cache_manager.h"
#include "chrome/browser/ash/file_system_provider/content_cache/content_cache.h"
#include "chrome/browser/ash/file_system_provider/content_cache/content_cache_impl.h"
#include "chrome/browser/ash/file_system_provider/content_cache/context_database.h"
#include "chrome/browser/ash/file_system_provider/fake_provided_file_system.h"
#include "chrome/browser/ash/file_system_provider/mount_path_util.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "chrome/test/base/testing_profile.h"
#include "content/public/test/browser_task_environment.h"
#include "net/base/io_buffer.h"
#include "testing/gmock/include/gmock/gmock-actions.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash::file_system_provider {
namespace {

using base::test::IsNotNullCallback;
using base::test::RunClosure;
using base::test::RunOnceCallback;
using base::test::TestFuture;
using testing::_;
using testing::DoAll;
using testing::Field;
using testing::IsEmpty;
using testing::IsFalse;
using testing::Return;
using testing::ReturnRef;

using OpenFileFuture =
    TestFuture<int, base::File::Error, std::unique_ptr<EntryMetadata>>;
using ReadFileFuture = TestFuture<int, bool, base::File::Error>;
using GetMetadataFuture =
    TestFuture<std::unique_ptr<EntryMetadata>, base::File::Error>;
using FileErrorFuture = TestFuture<base::File::Error>;

const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
const char kFileSystemId[] = "cloud-fs-id";
const char kDisplayName[] = "Cloud FS";

// An action for a mock function which is equivalent to `RunOnceCallback<I>()`,
// `run_loop.Quit()` and `Return(AbortCallback())`. That is, it invokes the
// Run() method on the I-th (0-based) argument of the mock function with
// argument `result`, quits the `run_loop` and then returns an
// `AbortCallback()`. This is used when mocking `ProvidedFileSystemInterface`
// functions that have a `StatusCallback`. This waits for the function to be
// called, runs the callback and returns an AbortCallback().
template <size_t I>
auto RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback(
    base::RunLoop& run_loop,
    base::File::Error result) {
  return [&run_loop, result](auto&&... args) -> AbortCallback {
    auto callback =
        std::move(base::gmock_callback_support_internal::get<I>(args...));
    std::move(callback).Run(result);
    run_loop.Quit();
    return AbortCallback();
  };
}

class MockCacheManager : public CacheManager {
 public:
  MOCK_METHOD(void,
              InitializeForProvider,
              (const ProvidedFileSystemInfo& file_system_info,
               FileErrorOrContentCacheCallback callback),
              (override));
  MOCK_METHOD(void,
              UninitializeForProvider,
              (const ProvidedFileSystemInfo& file_system_info),
              (override));
  MOCK_METHOD(bool,
              IsProviderInitialized,
              (const ProvidedFileSystemInfo& file_system_info),
              (override));
  MOCK_METHOD(void, AddObserver, (Observer * observer), (override));
  MOCK_METHOD(void, RemoveObserver, (Observer * observer), (override));
};

class MockContentCache : public ContentCache {
 public:
  MOCK_METHOD(void, SetMaxCacheItems, (size_t max_cache_items), (override));
  MOCK_METHOD(void,
              ReadBytes,
              (const OpenedCloudFile& file,
               scoped_refptr<net::IOBuffer> buffer,
               int64_t offset,
               int length,
               ProvidedFileSystemInterface::ReadChunkReceivedCallback callback),
              (override));
  MOCK_METHOD(void,
              WriteBytes,
              (const OpenedCloudFile& file,
               scoped_refptr<net::IOBuffer> buffer,
               int64_t offset,
               int length,
               FileErrorCallback callback),
              (override));
  MOCK_METHOD(void, CloseFile, (const OpenedCloudFile& file), (override));
  MOCK_METHOD(void, LoadFromDisk, (base::OnceClosure callback), (override));
  MOCK_METHOD(std::vector<base::FilePath>, GetCachedFilePaths, (), (override));
  MOCK_METHOD(void,
              Notify,
              (ProvidedFileSystemObserver::Changes & changes),
              (override));
  MOCK_METHOD(void,
              ObservedVersionTag,
              (const base::FilePath& entry_path,
               const std::string& version_tag),
              (override));
  MOCK_METHOD(void, Evict, (const base::FilePath& file_path), (override));
  MOCK_METHOD(void, AddObserver, (Observer * observer), (override));
  MOCK_METHOD(void, RemoveObserver, (Observer * observer), (override));

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

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

class MockContentCacheObserver : public ContentCache::Observer {
 public:
  MOCK_METHOD(void,
              OnItemEvicted,
              (const base::FilePath& fsp_path),
              (override));
  MOCK_METHOD(void,
              OnItemRemovedFromDisk,
              (const base::FilePath& fsp_path, int64_t bytes_removed),
              (override));
};

class MockProvidedFileSystem : public ProvidedFileSystemInterface {
 public:
  MOCK_METHOD(AbortCallback,
              RequestUnmount,
              (storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              GetMetadata,
              (const base::FilePath& entry_path,
               ProvidedFileSystemInterface::MetadataFieldMask fields,
               ProvidedFileSystemInterface::GetMetadataCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              GetActions,
              (const std::vector<base::FilePath>& entry_paths,
               GetActionsCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              ExecuteAction,
              (const std::vector<base::FilePath>& entry_paths,
               const std::string& action_id,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              ReadDirectory,
              (const base::FilePath& directory_path,
               storage::AsyncFileUtil::ReadDirectoryCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              OpenFile,
              (const base::FilePath& file_path,
               OpenFileMode mode,
               OpenFileCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              CloseFile,
              (int file_handle,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              ReadFile,
              (int file_handle,
               net::IOBuffer* buffer,
               int64_t offset,
               int length,
               ReadChunkReceivedCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              CreateDirectory,
              (const base::FilePath& directory_path,
               bool recursive,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              DeleteEntry,
              (const base::FilePath& entry_path,
               bool recursive,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              CreateFile,
              (const base::FilePath& file_path,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              CopyEntry,
              (const base::FilePath& source_path,
               const base::FilePath& target_path,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              MoveEntry,
              (const base::FilePath& source_path,
               const base::FilePath& target_path,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              Truncate,
              (const base::FilePath& file_path,
               int64_t length,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              WriteFile,
              (int file_handle,
               net::IOBuffer* buffer,
               int64_t offset,
               int length,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(AbortCallback,
              FlushFile,
              (int file_handle,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(
      AbortCallback,
      AddWatcher,
      (const GURL& origin,
       const base::FilePath& entry_path,
       bool recursive,
       bool persistent,
       storage::AsyncFileUtil::StatusCallback callback,
       storage::WatcherManager::NotificationCallback notification_callback),
      (override));
  MOCK_METHOD(void,
              RemoveWatcher,
              (const GURL& origin,
               const base::FilePath& entry_path,
               bool recursive,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(const ProvidedFileSystemInfo&,
              GetFileSystemInfo,
              (),
              (const, override));
  MOCK_METHOD(OperationRequestManager*, GetRequestManager, (), (override));
  MOCK_METHOD(Watchers*, GetWatchers, (), (override));
  MOCK_METHOD(const OpenedFiles&, GetOpenedFiles, (), (const, override));
  MOCK_METHOD(void,
              AddObserver,
              (ProvidedFileSystemObserver * observer),
              (override));
  MOCK_METHOD(void,
              RemoveObserver,
              (ProvidedFileSystemObserver * observer),
              (override));
  MOCK_METHOD(void,
              Notify,
              (const base::FilePath& entry_path,
               bool recursive,
               storage::WatcherManager::ChangeType change_type,
               std::unique_ptr<ProvidedFileSystemObserver::Changes> changes,
               const std::string& tag,
               storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(void,
              Configure,
              (storage::AsyncFileUtil::StatusCallback callback),
              (override));
  MOCK_METHOD(base::WeakPtr<ProvidedFileSystemInterface>,
              GetWeakPtr,
              (),
              (override));
  MOCK_METHOD(std::unique_ptr<ScopedUserInteraction>,
              StartUserInteraction,
              (),
              (override));

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

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

// Holder for the constructed mock content cache and the cloud file system.
struct MockContentCacheAndCloudFileSystemAndFakeFsp {
  base::WeakPtr<MockContentCache> mock_content_cache;
  base::WeakPtr<FakeProvidedFileSystem> fake_fsp;
  std::unique_ptr<CloudFileSystem> cloud_file_system;
};

struct MockContentCacheObserverAndCloudFileSystemAndFakeFsp {
  std::unique_ptr<MockContentCacheObserver> mock_content_cache_observer;
  base::WeakPtr<FakeProvidedFileSystem> fake_fsp;
  std::unique_ptr<CloudFileSystem> cloud_file_system;
};

class FileSystemProviderCloudFileSystemTest : public testing::Test,
                                              public CacheManager::Observer {
 protected:
  FileSystemProviderCloudFileSystemTest() = default;
  ~FileSystemProviderCloudFileSystemTest() override = default;

  void SetUp() override { profile_ = std::make_unique<TestingProfile>(); }

  const ProvidedFileSystemInfo GetFileSystemInfo(bool with_mock_cache_manager) {
    MountOptions mount_options;
    mount_options.file_system_id = kFileSystemId;
    mount_options.display_name = kDisplayName;
    mount_options.supports_notify_tag = true;
    mount_options.writable = true;
    const base::FilePath mount_path = util::GetMountPath(
        profile_.get(), ProviderId::CreateFromExtensionId(kExtensionId),
        kFileSystemId);
    return ProvidedFileSystemInfo(
        kExtensionId, mount_options, mount_path,
        /*configurable=*/false,
        /*watchable=*/true, extensions::SOURCE_NETWORK, IconSet(),
        with_mock_cache_manager ? CacheType::LRU : CacheType::NONE);
  }

  // Creates a CloudFileSystem which wraps a FakeProvidedFileSystem.
  std::unique_ptr<CloudFileSystem> CreateCloudFileSystem(
      std::unique_ptr<ProvidedFileSystemInterface> provided_file_system,
      bool with_mock_cache_manager) {
    // Start the CloudFileSystem initialisation.
    std::unique_ptr<CloudFileSystem> cloud_file_system =
        std::make_unique<CloudFileSystem>(
            std::move(provided_file_system),
            with_mock_cache_manager ? &mock_cache_manager_ : nullptr);
    return cloud_file_system;
  }

  base::WeakPtr<MockContentCache> CreateMockContentCache() {
    std::unique_ptr<MockContentCache> mock_content_cache =
        std::make_unique<MockContentCache>();
    base::WeakPtr<MockContentCache> cache_weak_ptr =
        mock_content_cache->GetWeakPtr();
    EXPECT_CALL(mock_cache_manager_,
                InitializeForProvider(_, IsNotNullCallback()))
        .WillOnce(RunOnceCallback<1>(std::move(mock_content_cache)));
    return cache_weak_ptr;
  }

  std::unique_ptr<MockContentCacheObserver>
  CreateContentCacheAndMockObserver() {
    EXPECT_TRUE(temp_cache_dir_.CreateUniqueTempDir());

    // Initialize a `ContextDatabase` in memory on a blocking task runner.
    std::unique_ptr<ContextDatabase> context_db =
        std::make_unique<ContextDatabase>(base::FilePath());
    scoped_refptr<base::SequencedTaskRunner> db_task_runner =
        base::ThreadPool::CreateSequencedTaskRunner(
            {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
    BoundContextDatabase db(db_task_runner, std::move(context_db));
    TestFuture<bool> future;
    db.AsyncCall(&ContextDatabase::Initialize).Then(future.GetCallback());
    EXPECT_TRUE(future.Get());

    auto content_cache_observer = std::make_unique<MockContentCacheObserver>();
    std::unique_ptr<ContentCache> content_cache =
        ContentCacheImpl::Create(temp_cache_dir_.GetPath(), std::move(db));
    content_cache->AddObserver(content_cache_observer.get());

    EXPECT_CALL(mock_cache_manager_,
                InitializeForProvider(_, IsNotNullCallback()))
        .WillOnce(RunOnceCallback<1>(std::move(content_cache)));
    return content_cache_observer;
  }

  MockContentCacheObserverAndCloudFileSystemAndFakeFsp
  CreateContentCacheAndObserverAndCloudFileSystemWithFakeFsp() {
    std::unique_ptr<FakeProvidedFileSystem> provided_file_system =
        std::make_unique<FakeProvidedFileSystem>(
            GetFileSystemInfo(/*with_mock_cache_manager=*/true));
    return MockContentCacheObserverAndCloudFileSystemAndFakeFsp{
        .mock_content_cache_observer = CreateContentCacheAndMockObserver(),
        .fake_fsp = provided_file_system->GetFakeWeakPtr(),
        .cloud_file_system = CreateCloudFileSystem(
            std::move(provided_file_system), /*with_mock_cache_manager=*/true)};
  }

  MockContentCacheAndCloudFileSystemAndFakeFsp
  CreateMockContentCacheAndCloudFileSystemWithFakeFsp() {
    std::unique_ptr<FakeProvidedFileSystem> provided_file_system =
        std::make_unique<FakeProvidedFileSystem>(
            GetFileSystemInfo(/*with_mock_cache_manager=*/true));
    return MockContentCacheAndCloudFileSystemAndFakeFsp{
        .mock_content_cache = CreateMockContentCache(),
        .fake_fsp = provided_file_system->GetFakeWeakPtr(),
        .cloud_file_system = CreateCloudFileSystem(
            std::move(provided_file_system), /*with_mock_cache_manager=*/true)};
  }

  void CloseFileSuccessfully(CloudFileSystem& cloud_file_system,
                             int file_handle) {
    FileErrorFuture close_file_future;
    cloud_file_system.CloseFile(file_handle, close_file_future.GetCallback());
    EXPECT_EQ(close_file_future.Get(), base::File::FILE_OK);
  }

  void ReadFileSuccessfully(CloudFileSystem& cloud_file_system,
                            int file_handle,
                            scoped_refptr<net::IOBuffer> buffer,
                            int64_t offset = 0,
                            int length = 1) {
    ReadFileFuture read_file_future;
    cloud_file_system.ReadFile(file_handle, buffer.get(), offset, length,
                               read_file_future.GetRepeatingCallback());
    EXPECT_EQ(read_file_future.Get<int>(), 1);
    EXPECT_EQ(read_file_future.Get<base::File::Error>(), base::File::FILE_OK);
  }

  void WriteFileSuccessfully(CloudFileSystem& cloud_file_system,
                             int file_handle,
                             scoped_refptr<net::IOBuffer> buffer,
                             int64_t offset = 0,
                             int length = 1) {
    FileErrorFuture write_file_future;
    cloud_file_system.WriteFile(file_handle, buffer.get(), offset, length,
                                write_file_future.GetRepeatingCallback());
    EXPECT_EQ(write_file_future.Get(), base::File::FILE_OK);
  }

  void DeleteFileSuccessfully(CloudFileSystem& cloud_file_system,
                              const base::FilePath& entry_path) {
    FileErrorFuture delete_file_future;
    cloud_file_system.DeleteEntry(entry_path, /*recursive=*/false,
                                  delete_file_future.GetRepeatingCallback());
    EXPECT_EQ(delete_file_future.Get(), base::File::FILE_OK);
  }

  int GetFileHandleFromSuccessfulOpenFile(
      CloudFileSystem& cloud_file_system,
      const base::FilePath& file_path,
      OpenFileMode mode = OPEN_FILE_MODE_READ) {
    OpenFileFuture open_file_future;
    cloud_file_system.OpenFile(file_path, mode, open_file_future.GetCallback());
    EXPECT_EQ(open_file_future.Get<base::File::Error>(), base::File::FILE_OK);
    return open_file_future.Get<int>();
  }

  void DeleteEntryOnFakeFileSystem(
      base::WeakPtr<FakeProvidedFileSystem> fake_fsp,
      const base::FilePath& entry_path) {
    FileErrorFuture delete_entry_future;
    fake_fsp->DeleteEntry(entry_path, /*recursive=*/true,
                          delete_entry_future.GetCallback());
    EXPECT_EQ(delete_entry_future.Get(), base::File::FILE_OK);
  }

  void UpdateEntryWithVersionTagOnFakeFileSystem(
      base::WeakPtr<FakeProvidedFileSystem> fake_fsp,
      const base::FilePath& entry_path,
      const std::string& version_tag) {
    fake_fsp->GetEntry(entry_path)->metadata->cloud_file_info->version_tag =
        version_tag;
  }

  MockCacheManager mock_cache_manager_;
  content::BrowserTaskEnvironment task_environment_;
  std::unique_ptr<TestingProfile> profile_;
  base::ScopedTempDir temp_cache_dir_;
};

TEST_F(FileSystemProviderCloudFileSystemTest, ContiguousReadsWriteToCache) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Set the first read bytes to return `base::File::FILE_ERROR_NOT_FOUND`, this
  // indicates that the data is not cached in the content cache.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, buffer, /*offset=*/0,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/-1, /*has_more=*/false,
                                   base::File::FILE_ERROR_NOT_FOUND));

  // Set the first write bytes to return successfully, this indicates the post
  // FSP stream to disk succeeded.
  EXPECT_CALL(*mock_content_cache,
              WriteBytes(_, buffer, /*offset=*/0,
                         /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(base::File::FILE_OK));

  // Read the first chunk.
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/0,
                       /*length=*/1);

  // Expect watcher added for file.
  EXPECT_THAT(
      cloud_file_system->GetWatchers(),
      Pointee(ElementsAre(Pair(
          _, AllOf(Field(&Watcher::entry_path, base::FilePath(kFakeFilePath)),
                   Field(&Watcher::recursive, IsFalse()))))));

  // Read the next chunk.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, buffer, /*offset=*/1,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/-1, /*has_more=*/false,
                                   base::File::FILE_ERROR_NOT_FOUND));
  EXPECT_CALL(*mock_content_cache,
              WriteBytes(_, buffer, /*offset=*/1,
                         /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(base::File::FILE_OK));
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/1,
                       /*length=*/1);

  // Expect no new watcher added for the file.
  EXPECT_THAT(
      cloud_file_system->GetWatchers(),
      Pointee(ElementsAre(Pair(
          _, AllOf(Field(&Watcher::entry_path, base::FilePath(kFakeFilePath)),
                   Field(&Watcher::recursive, IsFalse()))))));

  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       UpToDateItemsInCacheShouldReturnWithoutCallingTheFsp) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Set the first read bytes to return `base::File::FILE_OK`, this indicates
  // that the data is fresh and available in the cache.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, buffer, /*offset=*/0,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/1, /*has_more=*/false,
                                   base::File::FILE_OK));

  // Expect that `WriteBytes` should not be called.
  EXPECT_CALL(*mock_content_cache, WriteBytes(_, _, _, _, _)).Times(0);

  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer);
  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       WhenReadingUpToDateItemsFromCacheFailsShouldDeferToFsp) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Make the inner callback to return `base::File::FILE_ERROR_FAILED` to
  // indicate that the actual underlying read of the cached file failed.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, buffer, /*offset=*/0,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/-1, /*has_more=*/false,
                                   base::File::FILE_ERROR_FAILED));

  // Ensure that the read still completes successfully, this indicates it
  // deferred the actual read to the underlying FSP instead of the failed cloud
  // file system.
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer);
  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       ContentCacheFailsWritingBytesShouldStillReturnSuccessfully) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Set the first read bytes to return `base::File::FILE_ERROR_NOT_FOUND`, this
  // indicates that the data is not cached in the content cache.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, buffer, /*offset=*/0,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/-1, /*has_more=*/false,
                                   base::File::FILE_ERROR_NOT_FOUND));

  // Set the first write bytes to return `base::File::FILE_ERROR_FAILED`, this
  // simulates a failure whilst streaming to disk. Given the FSP succeeded, we
  // should succeed back to the caller and follow up requests will defer
  // straight to the FSP.
  EXPECT_CALL(*mock_content_cache,
              WriteBytes(_, buffer, /*offset=*/0,
                         /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(base::File::FILE_ERROR_FAILED));

  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer);
  // Expect no watcher is added.
  EXPECT_THAT(cloud_file_system->GetWatchers(), Pointee(IsEmpty()));

  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       FilesOpenForWriteShouldAlwaysGoToTheFspNotContentCache) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath), OPEN_FILE_MODE_WRITE);

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Neither the `ReadBytes` nor the `WriteBytes` should be called.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, _, _, _, _)).Times(0);
  EXPECT_CALL(*mock_content_cache, WriteBytes(_, _, _, _, _)).Times(0);

  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer);
  // Expect no watcher is added.
  EXPECT_THAT(cloud_file_system->GetWatchers(), Pointee(IsEmpty()));

  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       IfFspReadFailsOnFirstCallContentCacheShouldNotWriteBytes) {
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  const base::FilePath fake_file_path(kFakeFilePath);
  int file_handle =
      GetFileHandleFromSuccessfulOpenFile(*cloud_file_system, fake_file_path);

  // Remove the entry from the underlying FSP, this should result in a
  // base::File::FILE_ERROR_INVALID_OPERATION on the `ReadFile` request.
  DeleteEntryOnFakeFileSystem(fake_fsp, fake_file_path);

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  // Set the first read bytes to return `base::File::FILE_ERROR_NOT_FOUND`, this
  // simulates a cache miss.
  EXPECT_CALL(*mock_content_cache, ReadBytes(_, _, /*offset=*/0,
                                             /*length=*/1, IsNotNullCallback()))
      .WillOnce(RunOnceCallback<4>(/*bytes_read=*/-1, /*has_more=*/false,
                                   base::File::FILE_ERROR_NOT_FOUND));

  // Assert that `WriteBytes` never gets called as the underlying FSP
  // should respond with a `base::File::FILE_ERROR_INVALID_OPERATION` due to the
  // file not existing between the `OpenFile` and the `ReadFile`.
  EXPECT_CALL(*mock_content_cache, WriteBytes(_, _, _, _, _)).Times(0);

  ReadFileFuture read_file_future;
  cloud_file_system->ReadFile(file_handle, buffer.get(), /*offset=*/0,
                              /*length=*/1,
                              read_file_future.GetRepeatingCallback());
  EXPECT_EQ(read_file_future.Get<int>(), 0);
  EXPECT_EQ(read_file_future.Get<base::File::Error>(),
            base::File::FILE_ERROR_INVALID_OPERATION);
  // Expect no watcher is added.
  EXPECT_THAT(cloud_file_system->GetWatchers(), Pointee(IsEmpty()));

  CloseFileSuccessfully(*cloud_file_system, file_handle);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       WatchersAddedForEachFileAlreadyInTheCacheOnStartUp) {
  base::WeakPtr<MockContentCache> mock_content_cache = CreateMockContentCache();
  std::unique_ptr<MockProvidedFileSystem> provided_file_system =
      std::make_unique<MockProvidedFileSystem>();
  base::WeakPtr<MockProvidedFileSystem> mock_fsp =
      provided_file_system->GetMockWeakPtr();

  // Mock the fake file system info.
  auto file_system_info = GetFileSystemInfo(/*with_mock_cache_manager=*/true);
  EXPECT_CALL(*mock_fsp, GetFileSystemInfo())
      .WillRepeatedly(ReturnRef(file_system_info));

  // Set the content cache to already have files.
  std::vector<base::FilePath> cached_files(
      {base::FilePath("/a.txt"), base::FilePath("/b.txt")});
  EXPECT_CALL(*mock_content_cache, GetCachedFilePaths())
      .WillOnce(Return(cached_files));

  // Expect that AddWatcher is called for each cached file.
  base::RunLoop run_loop1;
  EXPECT_CALL(*mock_fsp,
              AddWatcher(GURL("chrome://content-cache/"),
                         base::FilePath("/a.txt"), /*recursive=*/false,
                         /*persistent=*/false, _, _))
      .WillOnce(RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback<4>(
          run_loop1, base::File::Error::FILE_OK));
  base::RunLoop run_loop2;
  EXPECT_CALL(*mock_fsp,
              AddWatcher(GURL("chrome://content-cache/"),
                         base::FilePath("/b.txt"), /*recursive=*/false,
                         /*persistent=*/false, _, _))
      .WillOnce(RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback<4>(
          run_loop2, base::File::Error::FILE_OK));

  // Initialise the CloudFileSystem.
  std::unique_ptr<CloudFileSystem> cloud_file_system = CreateCloudFileSystem(
      std::move(provided_file_system), /*with_mock_cache_manager=*/true);
  run_loop1.Run();
  run_loop2.Run();
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       RetryToAddWatcherOnSecurityErrorOnStartUp) {
  base::WeakPtr<MockContentCache> mock_content_cache = CreateMockContentCache();
  std::unique_ptr<MockProvidedFileSystem> provided_file_system =
      std::make_unique<MockProvidedFileSystem>();
  base::WeakPtr<MockProvidedFileSystem> mock_fsp =
      provided_file_system->GetMockWeakPtr();

  // Mock the fake file system info.
  auto file_system_info = GetFileSystemInfo(/*with_mock_cache_manager=*/true);
  EXPECT_CALL(*mock_fsp, GetFileSystemInfo())
      .WillRepeatedly(ReturnRef(file_system_info));

  // Set the content cache to already have a file.
  std::vector<base::FilePath> cached_files({base::FilePath("/a.txt")});
  EXPECT_CALL(*mock_content_cache, GetCachedFilePaths())
      .WillOnce(Return(cached_files));

  // Expect that AddWatcher is called for the cached file. Fail the first
  // AddWatcher call with `FILE_ERROR_SECURITY` and pass the follow up call.
  base::RunLoop run_loop1;
  base::RunLoop run_loop2;
  EXPECT_CALL(*mock_fsp,
              AddWatcher(GURL("chrome://content-cache/"),
                         base::FilePath("/a.txt"), /*recursive=*/false,
                         /*persistent=*/false, IsNotNullCallback(), _))
      .WillOnce(RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback<4>(
          run_loop1, base::File::Error::FILE_ERROR_SECURITY))
      .WillOnce(RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback<4>(
          run_loop2, base::File::Error::FILE_OK));

  // Initialise the CloudFileSystem.
  std::unique_ptr<CloudFileSystem> cloud_file_system = CreateCloudFileSystem(
      std::move(provided_file_system), /*with_mock_cache_manager=*/true);
  run_loop1.Run();
  run_loop2.Run();
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       NoRetryToAddWatcherOnNonSecurityErrorOnStartUp) {
  base::WeakPtr<MockContentCache> mock_content_cache = CreateMockContentCache();
  std::unique_ptr<MockProvidedFileSystem> provided_file_system =
      std::make_unique<MockProvidedFileSystem>();
  base::WeakPtr<MockProvidedFileSystem> mock_fsp =
      provided_file_system->GetMockWeakPtr();

  // Mock the fake file system info.
  auto file_system_info = GetFileSystemInfo(/*with_mock_cache_manager=*/true);
  EXPECT_CALL(*mock_fsp, GetFileSystemInfo())
      .WillRepeatedly(ReturnRef(file_system_info));

  // Set the content cache to already have a file.
  std::vector<base::FilePath> cached_files({base::FilePath("/a.txt")});
  EXPECT_CALL(*mock_content_cache, GetCachedFilePaths())
      .WillOnce(Return(cached_files));

  // Expect that AddWatcher is called for the cached file. Fail the AddWatcher
  // call with `FILE_ERROR_FAILED` and expect that no follow up call is made.
  base::RunLoop run_loop;
  EXPECT_CALL(*mock_fsp,
              AddWatcher(GURL("chrome://content-cache/"),
                         base::FilePath("/a.txt"), /*recursive=*/false,
                         /*persistent=*/false, IsNotNullCallback(), _))
      .WillOnce(RunStatusCallbackAndQuitRunLoopAndReturnAbortCallback<4>(
          run_loop, base::File::Error::FILE_ERROR_FAILED));

  // Initialise the CloudFileSystem.
  std::unique_ptr<CloudFileSystem> cloud_file_system = CreateCloudFileSystem(
      std::move(provided_file_system), /*with_mock_cache_manager=*/true);
  run_loop.Run();
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       WatcherAddedWhenFileAddedAndRemovedWhenFileEvicted) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache_observer, fake_fsp, cloud_file_system] =
      CreateContentCacheAndObserverAndCloudFileSystemWithFakeFsp();

  // Add file to the cache.
  int file_handle =
      GetFileHandleFromSuccessfulOpenFile(*cloud_file_system, fake_file_path);
  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/0,
                       /*length=*/1);
  CloseFileSuccessfully(*cloud_file_system, file_handle);

  // There should be a watcher added for the file.
  EXPECT_THAT(cloud_file_system->GetWatchers(),
              Pointee(UnorderedElementsAre(
                  Pair(_, AllOf(Field(&Watcher::entry_path, fake_file_path),
                                Field(&Watcher::recursive, IsFalse()))))));

  // Remove the entry from the underlying FSP, this should result in a
  // base::File::FILE_ERROR_NOT_FOUND on the `GetMetadata` request.
  DeleteEntryOnFakeFileSystem(fake_fsp, fake_file_path);

  // The file will be evicted after the unsuccessful GetMetadata request.
  EXPECT_CALL(*mock_content_cache_observer, OnItemEvicted(fake_file_path));
  GetMetadataFuture get_metadata_future;
  cloud_file_system->GetMetadata(fake_file_path,
                                 /*fields*/ {},
                                 get_metadata_future.GetRepeatingCallback());
  EXPECT_EQ(get_metadata_future.Get<base::File::Error>(),
            base::File::FILE_ERROR_NOT_FOUND);

  // Expect watcher is removed.
  EXPECT_THAT(cloud_file_system->GetWatchers(), Pointee(IsEmpty()));
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       NotFoundFromGetMetadataEvictsCachedFile) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // The file won't be evicted after the successful GetMetadata request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(0);
  GetMetadataFuture get_metadata_future1;
  cloud_file_system->GetMetadata(fake_file_path,
                                 /*fields*/ {},
                                 get_metadata_future1.GetRepeatingCallback());
  EXPECT_EQ(get_metadata_future1.Get<base::File::Error>(), base::File::FILE_OK);

  // Remove the entry from the underlying FSP, this should result in a
  // base::File::FILE_ERROR_NOT_FOUND on the `GetMetadata` request.
  DeleteEntryOnFakeFileSystem(fake_fsp, fake_file_path);

  // The file will be evicted after the unsuccessful GetMetadata request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(1);
  GetMetadataFuture get_metadata_future2;
  cloud_file_system->GetMetadata(fake_file_path,
                                 /*fields*/ {},
                                 get_metadata_future2.GetRepeatingCallback());
  EXPECT_EQ(get_metadata_future2.Get<base::File::Error>(),
            base::File::FILE_ERROR_NOT_FOUND);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       NotFoundFromOpenFileEvictsCachedFile) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // The file won't be evicted after the successful `OpenFile` request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(0);
  OpenFileFuture open_file_future1;
  cloud_file_system->OpenFile(fake_file_path, OPEN_FILE_MODE_READ,
                              open_file_future1.GetRepeatingCallback());
  EXPECT_EQ(open_file_future1.Get<base::File::Error>(), base::File::FILE_OK);

  // Remove the entry from the underlying FSP, this should result in a
  // base::File::FILE_ERROR_NOT_FOUND on the `OpenFile` request.
  DeleteEntryOnFakeFileSystem(fake_fsp, fake_file_path);

  // The file will be evicted after the unsuccessful `OpenFile` request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(1);
  OpenFileFuture open_file_future2;
  cloud_file_system->OpenFile(fake_file_path, OPEN_FILE_MODE_READ,
                              open_file_future2.GetRepeatingCallback());
  EXPECT_EQ(open_file_future2.Get<base::File::Error>(),
            base::File::FILE_ERROR_NOT_FOUND);
}

TEST_F(FileSystemProviderCloudFileSystemTest, OkFromWriteFileEvictsCachedFile) {
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Open the `kFakeFilePath` file to stage it in the `FakeProvidedFileSystem`.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  // The file will be evicted after the successful `WriteFile` request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(1);
  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);
  WriteFileSuccessfully(*cloud_file_system, file_handle, buffer);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       OkFromDeleteEntryEvictsCachedFile) {
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // The file will be evicted after the successful `WriteFile` request.
  EXPECT_CALL(*mock_content_cache, Evict(fake_file_path)).Times(1);
  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);
  DeleteFileSuccessfully(*cloud_file_system, fake_file_path);
}

TEST_F(FileSystemProviderCloudFileSystemTest, CurrentReaderCanReadEvictedFile) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache_observer, fake_fsp, cloud_file_system] =
      CreateContentCacheAndObserverAndCloudFileSystemWithFakeFsp();

  // Read 2 bytes of the `kFakeFilePath` file and insert them into the cache.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));
  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/0,
                       /*length=*/1);
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/1,
                       /*length=*/1);
  CloseFileSuccessfully(*cloud_file_system, file_handle);

  // Open the file again.
  file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  // Read the first byte from the cache.
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/0,
                       /*length=*/1);

  // Remove the entry from the underlying FSP to ensure that the ReadFile is
  // indeed reading from the cache.
  DeleteEntryOnFakeFileSystem(fake_fsp, fake_file_path);

  // Send a delete notification. Expect that the item gets evicted.
  auto changes = std::make_unique<ProvidedFileSystemObserver::Changes>();
  changes->emplace_back(
      fake_file_path, storage::WatcherManager::ChangeType::DELETED,
      std::make_unique<ash::file_system_provider::CloudFileInfo>("versionA"));
  EXPECT_CALL(*mock_content_cache_observer, OnItemEvicted(fake_file_path));
  cloud_file_system->Notify(fake_file_path, /*recursive=*/true,
                            storage::WatcherManager::ChangeType::DELETED,
                            std::move(changes), /*tag=*/"", base::DoNothing());

  // Read the second byte from the cache.
  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/1,
                       /*length=*/1);

  // Fail to read the third byte. Expect that the request is forwarded to the
  // FSP which responds with a `base::File::FILE_ERROR_INVALID_OPERATION` due to
  // the file not existing.
  ReadFileFuture read_file_future;
  cloud_file_system->ReadFile(file_handle, buffer.get(), /*offset=*/2,
                              /*length=*/1,
                              read_file_future.GetRepeatingCallback());
  EXPECT_EQ(read_file_future.Get<int>(), 0);
  EXPECT_EQ(read_file_future.Get<base::File::Error>(),
            base::File::FILE_ERROR_INVALID_OPERATION);

  // Close the file, expect that it now gets removed.
  base::RunLoop run_loop;
  EXPECT_CALL(*mock_content_cache_observer,
              OnItemRemovedFromDisk(fake_file_path, /*bytes_removed=*/2))
      .WillOnce(RunClosure(run_loop.QuitClosure()));
  CloseFileSuccessfully(*cloud_file_system, file_handle);
  run_loop.Run();
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       GetMetadataCallsObservedVersionTag) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Expect the successful GetMetadata request for a CloudFileInfo triggers a
  // `ObservedVersionTag()` call.
  EXPECT_CALL(*mock_content_cache,
              ObservedVersionTag(fake_file_path, kFakeFileVersionTag))
      .Times(1);
  GetMetadataFuture get_metadata_future;
  cloud_file_system->GetMetadata(
      fake_file_path,
      /*fields*/ ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_FILE_INFO,
      get_metadata_future.GetRepeatingCallback());
  EXPECT_EQ(get_metadata_future.Get<base::File::Error>(), base::File::FILE_OK);
}

TEST_F(FileSystemProviderCloudFileSystemTest, OpenFileCallsObservedVersionTag) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache, fake_fsp, cloud_file_system] =
      CreateMockContentCacheAndCloudFileSystemWithFakeFsp();

  // Expect the successful OpenFile request triggers a `ObservedVersionTag()`
  // call.
  EXPECT_CALL(*mock_content_cache,
              ObservedVersionTag(fake_file_path, kFakeFileVersionTag))
      .Times(1);
  OpenFileFuture open_file_future1;
  cloud_file_system->OpenFile(fake_file_path, OPEN_FILE_MODE_READ,
                              open_file_future1.GetRepeatingCallback());
  EXPECT_EQ(open_file_future1.Get<base::File::Error>(), base::File::FILE_OK);
}

TEST_F(FileSystemProviderCloudFileSystemTest,
       OpenFileForNewVersionEvictsStaleCachedFile) {
  // Underlying FakeProvidedFileSystem is (always) initialised with fake file
  // with kFakeFilePath.
  const base::FilePath fake_file_path(kFakeFilePath);
  auto [mock_content_cache_observer, fake_fsp, cloud_file_system] =
      CreateContentCacheAndObserverAndCloudFileSystemWithFakeFsp();

  // Read 1 byte of the `kFakeFilePath` file and insert it into the cache.
  int file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));
  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::IOBufferWithSize>(1);

  ReadFileSuccessfully(*cloud_file_system, file_handle, buffer, /*offset=*/0,
                       /*length=*/1);
  CloseFileSuccessfully(*cloud_file_system, file_handle);

  // Update the version tag.
  UpdateEntryWithVersionTagOnFakeFileSystem(fake_fsp, fake_file_path,
                                            "new version");

  // Expect that opening the file causes the stale cache version to be evicted.
  EXPECT_CALL(*mock_content_cache_observer, OnItemEvicted(fake_file_path));
  file_handle = GetFileHandleFromSuccessfulOpenFile(
      *cloud_file_system, base::FilePath(kFakeFilePath));

  // Close the file, expect that it now gets removed.
  base::RunLoop run_loop;
  EXPECT_CALL(*mock_content_cache_observer,
              OnItemRemovedFromDisk(fake_file_path, /*bytes_removed=*/1))
      .WillOnce(RunClosure(run_loop.QuitClosure()));
  CloseFileSuccessfully(*cloud_file_system, file_handle);
  run_loop.Run();
}

}  // namespace
}  // namespace ash::file_system_provider