// Copyright 2018 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/extensions/file_manager/event_router.h"
#include <memory>
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/rand_util.h"
#include "base/run_loop.h"
#include "base/test/bind.h"
#include "base/test/gmock_callback_support.h"
#include "base/values.h"
#include "chrome/browser/ash/extensions/file_manager/event_router_factory.h"
#include "chrome/browser/ash/file_manager/io_task.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/volume_manager_factory.h"
#include "chrome/browser/ash/fileapi/file_system_backend.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/scoped_testing_local_state.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile.h"
#include "chromeos/ash/components/disks/fake_disk_mount_manager.h"
#include "content/public/test/browser_task_environment.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/test_event_router.h"
#include "extensions/common/extension.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "storage/browser/quota/quota_manager_proxy.h"
#include "storage/browser/test/test_file_system_context.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"
#include "ui/display/test/test_screen.h"
#include "url/gurl.h"
#include "url/origin.h"
namespace file_manager {
TEST(EventRouterTest, PopulateCrostiniEvent) {
extensions::api::file_manager_private::CrostiniEvent ext_event;
url::Origin ext_origin = url::Origin::Create(
extensions::Extension::GetBaseURLFromExtensionId("extensionid"));
EventRouter::PopulateCrostiniEvent(
ext_event,
extensions::api::file_manager_private::CrostiniEventType::kUnshare,
"vmname", ext_origin, "mountname", "filesystemname", "/full/path");
EXPECT_EQ(ext_event.event_type,
extensions::api::file_manager_private::CrostiniEventType::kUnshare);
EXPECT_EQ(ext_event.vm_name, "vmname");
EXPECT_EQ(ext_event.entries.size(), 1u);
base::Value::Dict ext_props;
ext_props.Set(
"fileSystemRoot",
"filesystem:chrome-extension://extensionid/external/mountname/");
ext_props.Set("fileSystemName", "filesystemname");
ext_props.Set("fileFullPath", "/full/path");
ext_props.Set("fileIsDirectory", true);
EXPECT_EQ(ext_event.entries[0].additional_properties, ext_props);
extensions::api::file_manager_private::CrostiniEvent swa_event;
url::Origin swa_origin = url::Origin::Create(
GURL("chrome://file-manager/this-part-should-not-be-in?the=event"));
EventRouter::PopulateCrostiniEvent(
swa_event,
extensions::api::file_manager_private::CrostiniEventType::kShare,
"vmname", swa_origin, "mountname", "filesystemname", "/full/path");
EXPECT_EQ(swa_event.event_type,
extensions::api::file_manager_private::CrostiniEventType::kShare);
EXPECT_EQ(swa_event.vm_name, "vmname");
EXPECT_EQ(swa_event.entries.size(), 1u);
base::Value::Dict swa_props;
swa_props.Set("fileSystemRoot",
"filesystem:chrome://file-manager/external/mountname/");
swa_props.Set("fileSystemName", "filesystemname");
swa_props.Set("fileFullPath", "/full/path");
swa_props.Set("fileIsDirectory", true);
EXPECT_EQ(swa_event.entries[0].additional_properties, swa_props);
}
namespace {
using ::base::test::RunClosure;
using ::testing::_;
using ::testing::AllOf;
using ::testing::Field;
// Observes the `BroadcastEvent` operation that is emitted by the event router.
// The mock methods are used to assert expectations on the return results.
class TestEventRouterObserver
: public extensions::TestEventRouter::EventObserver {
public:
explicit TestEventRouterObserver(extensions::TestEventRouter* event_router)
: event_router_(event_router) {
event_router_->AddEventObserver(this);
}
~TestEventRouterObserver() override {
event_router_->RemoveEventObserver(this);
}
TestEventRouterObserver(const TestEventRouterObserver&) = delete;
TestEventRouterObserver& operator=(const TestEventRouterObserver&) = delete;
// TestEventRouter::EventObserver:
MOCK_METHOD(void, OnBroadcastEvent, (const extensions::Event&), (override));
MOCK_METHOD(void,
OnDispatchEventToExtension,
(const std::string&, const extensions::Event&),
(override));
private:
raw_ptr<extensions::TestEventRouter> event_router_;
};
class FileManagerEventRouterTest : public testing::Test {
public:
FileManagerEventRouterTest()
: scoped_testing_local_state_(TestingBrowserProcess::GetGlobal()) {}
FileManagerEventRouterTest(const FileManagerEventRouterTest&) = delete;
FileManagerEventRouterTest& operator=(const FileManagerEventRouterTest&) =
delete;
void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
profile_ =
std::make_unique<TestingProfile>(base::FilePath(temp_dir_.GetPath()));
file_system_context_ = storage::CreateFileSystemContextForTesting(
nullptr, temp_dir_.GetPath());
VolumeManagerFactory::GetInstance()->SetTestingFactory(
profile_.get(),
base::BindLambdaForTesting([this](content::BrowserContext* context) {
return std::unique_ptr<KeyedService>(std::make_unique<VolumeManager>(
Profile::FromBrowserContext(context), nullptr, nullptr,
&disk_mount_manager_, nullptr,
VolumeManager::GetMtpStorageInfoCallback()));
}));
storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
file_manager::util::GetDownloadsMountPointName(profile_.get()),
storage::kFileSystemTypeLocal, storage::FileSystemMountOption(),
temp_dir_.GetPath());
auto* context = file_manager::util::GetFileSystemContextForSourceURL(
profile_.get(), GURL("chrome-extension://abc"));
ash::FileSystemBackend::Get(*context)->GrantFileAccessToOrigin(
url::Origin::Create(GURL("chrome-extension://abc")),
base::FilePath(
file_manager::util::GetDownloadsMountPointName(profile_.get())));
}
const io_task::EntryStatus CreateSuccessfulEntryStatusForFileName(
const std::string& file_name) {
const base::FilePath file_path = temp_dir_.GetPath().Append(file_name);
EXPECT_TRUE(base::WriteFile(file_path, base::RandBytesAsString(32)));
storage::FileSystemURL url =
file_system_context_->CreateCrackedFileSystemURL(
kTestStorageKey, storage::kFileSystemTypeTest, file_path);
return io_task::EntryStatus(std::move(url), base::File::FILE_OK);
}
ScopedTestingLocalState scoped_testing_local_state_;
content::BrowserTaskEnvironment task_environment_;
display::test::TestScreen test_screen_{/*create_display=*/true,
/*register_screen=*/true};
base::ScopedTempDir temp_dir_;
ash::disks::FakeDiskMountManager disk_mount_manager_;
std::unique_ptr<TestingProfile> profile_;
const blink::StorageKey kTestStorageKey =
blink::StorageKey::CreateFromStringForTesting("chrome-extension://abc");
scoped_refptr<storage::FileSystemContext> file_system_context_;
};
MATCHER(ExpectNoArgs, "") {
return arg.size() == 0;
}
// A matcher that matches an `extensions::Event::event_args` and attempts to
// extract the "outputs" key. It then looks at the output at `index` and matches
// the `field` against the `expected_value`.
MATCHER_P3(ExpectEventArgString, index, field, expected_value, "") {
EXPECT_GE(arg.size(), 1u);
const base::Value::List* outputs = arg[0].GetDict().FindList("outputs");
EXPECT_TRUE(outputs) << "The outputs field is not available on the event";
EXPECT_GT(outputs->size(), index)
<< "The supplied index on outputs is not available, size: "
<< outputs->size() << ", index: " << index;
const std::string* actual_value =
(*outputs)[index].GetDict().FindString(field);
EXPECT_TRUE(actual_value) << "Could not find the string with key: " << field;
return testing::ExplainMatchResult(expected_value, *actual_value,
result_listener);
}
// A matcher that matches an `extensions::Event::event_args` and attempts to
// extract the "conflictParams" and "pauseParams" keys. It expects
// "conflictParams" to be empty, and then matches the "policyParams" values
// against the expected ones.
MATCHER_P4(ExpectEventArgPauseParams,
expected_type,
expected_count,
expected_file_name,
expected_always_show_review,
"") {
EXPECT_GE(arg.size(), 1u);
const base::Value::Dict* pause_params =
arg[0].GetDict().FindDict("pauseParams");
EXPECT_TRUE(pause_params)
<< "The pause_params field is not available on the event";
const base::Value::Dict* conflict_pause_params =
pause_params->FindDict("conflictParams");
EXPECT_FALSE(conflict_pause_params)
<< "The conflictParams field should not be available on the event";
const base::Value::Dict* policy_pause_params =
pause_params->FindDict("policyParams");
EXPECT_TRUE(policy_pause_params)
<< "The policyParams field is not available on the event";
const std::string* actual_type = policy_pause_params->FindString("type");
EXPECT_TRUE(actual_type) << "Could not find the string with key: type";
const std::optional<int> actual_count =
policy_pause_params->FindInt("policyFileCount");
EXPECT_TRUE(actual_count.has_value())
<< "Could not find the number with key: type";
const std::string* actual_file_name =
policy_pause_params->FindString("fileName");
EXPECT_TRUE(actual_file_name)
<< "Could not find the string with key: fileName";
const std::optional<bool> actual_always_show_review =
policy_pause_params->FindBool("alwaysShowReview");
EXPECT_TRUE(actual_always_show_review.has_value())
<< "Could not find the string with key: alwaysShowReview";
return testing::ExplainMatchResult(expected_type, *actual_type,
result_listener) &&
testing::ExplainMatchResult(expected_count, actual_count.value(),
result_listener) &&
testing::ExplainMatchResult(expected_file_name, *actual_file_name,
result_listener) &&
testing::ExplainMatchResult(expected_always_show_review,
actual_always_show_review.value(),
result_listener);
}
// A matcher that matches an `extensions::Event::event_args` and attempts to
// extract the "policyError" key. It then matches the "policyError" values
// against the expected ones.
MATCHER_P4(ExpectEventArgPolicyError,
expected_type,
expected_count,
expected_file_name,
expected_always_show_review,
"") {
EXPECT_GE(arg.size(), 1u);
const base::Value::Dict* policy_error =
arg[0].GetDict().FindDict("policyError");
EXPECT_TRUE(policy_error)
<< "The policyError field is not available on the event";
const std::string* actual_type = policy_error->FindString("type");
EXPECT_TRUE(actual_type) << "Could not find the string with key: type";
const std::optional<int> actual_count =
policy_error->FindInt("policyFileCount");
EXPECT_TRUE(actual_count.has_value())
<< "Could not find the string with key: type";
const std::string* actual_file_name = policy_error->FindString("fileName");
EXPECT_TRUE(actual_file_name)
<< "Could not find the string with key: fileName";
const std::optional<bool> actual_always_show_review =
policy_error->FindBool("alwaysShowReview");
EXPECT_TRUE(actual_always_show_review.has_value())
<< "Could not find the string with key: alwaysShowReview";
return testing::ExplainMatchResult(expected_type, *actual_type,
result_listener) &&
testing::ExplainMatchResult(expected_count, actual_count.value(),
result_listener) &&
testing::ExplainMatchResult(expected_file_name, *actual_file_name,
result_listener) &&
testing::ExplainMatchResult(expected_always_show_review,
actual_always_show_review.value(),
result_listener);
}
TEST_F(FileManagerEventRouterTest, OnIOTaskStatusForTrash) {
// Setup event routers.
extensions::TestEventRouter* test_event_router =
extensions::CreateAndUseTestEventRouter(profile_.get());
TestEventRouterObserver observer(test_event_router);
auto event_router = std::make_unique<EventRouter>(profile_.get());
event_router->ForceBroadcastingForTesting(true);
io_task::EntryStatus source_entry =
CreateSuccessfulEntryStatusForFileName("foo.txt");
io_task::EntryStatus output_entry =
CreateSuccessfulEntryStatusForFileName("bar.txt");
std::vector<io_task::EntryStatus> source_entries;
source_entries.push_back(std::move(source_entry));
std::vector<io_task::EntryStatus> output_entries;
output_entries.push_back(std::move(output_entry));
// Setup the ProgressStatus event that expects
file_manager::io_task::ProgressStatus status;
status.type = file_manager::io_task::OperationType::kTrash;
status.state = file_manager::io_task::State::kSuccess;
status.sources = std::move(source_entries);
status.outputs = std::move(output_entries);
base::RunLoop run_loop;
EXPECT_CALL(
observer,
OnBroadcastEvent(Field(
&extensions::Event::event_args,
AllOf(ExpectEventArgString(0u, "fileFullPath", "/bar.txt"),
ExpectEventArgString(0u, "fileSystemName", "Downloads"),
ExpectEventArgString(
0u, "fileSystemRoot",
"filesystem:chrome-extension://abc/external/Downloads/")))))
.WillOnce(RunClosure(run_loop.QuitClosure()));
event_router->OnIOTaskStatus(status);
run_loop.Run();
}
TEST_F(FileManagerEventRouterTest, OnIOTaskStatusForCopyPause) {
// Setup event routers.
extensions::TestEventRouter* test_event_router =
extensions::CreateAndUseTestEventRouter(profile_.get());
TestEventRouterObserver observer(test_event_router);
auto event_router = std::make_unique<EventRouter>(profile_.get());
event_router->ForceBroadcastingForTesting(true);
io_task::EntryStatus source_entry =
CreateSuccessfulEntryStatusForFileName("foo.txt");
std::vector<io_task::EntryStatus> source_entries;
source_entries.push_back(std::move(source_entry));
// Setup the ProgressStatus event.
file_manager::io_task::ProgressStatus status;
status.type = file_manager::io_task::OperationType::kCopy;
status.state = file_manager::io_task::State::kPaused;
status.sources = std::move(source_entries);
status.pause_params.policy_params = io_task::PolicyPauseParams(
policy::Policy::kDlp, /*warning_files_count*/ 2u, "foo.txt",
/*always_show_review=*/false);
// Expect the event to have dlp as policy pause params.
base::RunLoop run_loop;
EXPECT_CALL(observer,
OnBroadcastEvent(Field(&extensions::Event::event_args,
AllOf(ExpectEventArgPauseParams(
"dlp", 2, "foo.txt", false)))))
.WillOnce(RunClosure(run_loop.QuitClosure()));
event_router->OnIOTaskStatus(status);
run_loop.Run();
}
TEST_F(FileManagerEventRouterTest, OnIOTaskStatusForPolicyError) {
// Setup event routers.
extensions::TestEventRouter* test_event_router =
extensions::CreateAndUseTestEventRouter(profile_.get());
TestEventRouterObserver observer(test_event_router);
auto event_router = std::make_unique<EventRouter>(profile_.get());
event_router->ForceBroadcastingForTesting(true);
io_task::EntryStatus source_entry =
CreateSuccessfulEntryStatusForFileName("foo.txt");
std::vector<io_task::EntryStatus> source_entries;
source_entries.push_back(std::move(source_entry));
// Setup the ProgressStatus event.
file_manager::io_task::ProgressStatus status;
status.type = file_manager::io_task::OperationType::kCopy;
status.state = file_manager::io_task::State::kError;
status.sources = std::move(source_entries);
status.policy_error.emplace(io_task::PolicyErrorType::kDlp,
/*blocked_files=*/1, "foo.txt",
/*always_show_review=*/true);
// Expect the event to have dlp as policy error.
base::RunLoop run_loop;
EXPECT_CALL(observer,
OnBroadcastEvent(Field(
&extensions::Event::event_args,
AllOf(ExpectEventArgPolicyError("dlp", 1, "foo.txt", true)))))
.WillOnce(RunClosure(run_loop.QuitClosure()));
event_router->OnIOTaskStatus(status);
run_loop.Run();
}
class FileManagerEventRouterLocalFilesTest : public FileManagerEventRouterTest {
public:
FileManagerEventRouterLocalFilesTest() {
scoped_feature_list_.InitAndEnableFeature(features::kSkyVault);
}
~FileManagerEventRouterLocalFilesTest() override = default;
void SetLocalUserFilesPolicy(bool allowed) {
scoped_testing_local_state_.Get()->SetBoolean(prefs::kLocalUserFilesAllowed,
allowed);
}
private:
base::test::ScopedFeatureList scoped_feature_list_;
};
TEST_F(FileManagerEventRouterLocalFilesTest, OnLocalUserFilesPolicyChanged) {
// Set up event routers.
extensions::TestEventRouter* test_event_router =
extensions::CreateAndUseTestEventRouter(profile_.get());
TestEventRouterObserver observer(test_event_router);
auto event_router = std::make_unique<EventRouter>(profile_.get());
event_router->ForceBroadcastingForTesting(true);
// Expect the preferences changed event.
base::Value::List event_args =
extensions::api::file_manager_private::OnPreferencesChanged::Create();
base::RunLoop run_loop;
EXPECT_CALL(observer, OnBroadcastEvent(Field(&extensions::Event::event_args,
AllOf(ExpectNoArgs()))))
.WillOnce(RunClosure(run_loop.QuitClosure()));
SetLocalUserFilesPolicy(/*allowed=*/false);
run_loop.Run();
}
} // namespace
} // namespace file_manager
Codebase Browser
chromium