// 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 "chromeos/ash/components/file_manager/indexing/file_index_service.h"
#include <string>
#include <string_view>
#include <vector>
#include "base/files/scoped_temp_dir.h"
#include "base/strings/strcat.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "base/threading/platform_thread.h"
#include "base/time/time.h"
#include "chromeos/ash/components/file_manager/indexing/file_info.h"
#include "chromeos/ash/components/file_manager/indexing/query.h"
#include "chromeos/ash/components/file_manager/indexing/term.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#include "url/url_canon.h"
#include "url/url_util.h"
namespace ash::file_manager {
namespace {
GURL MakeLocalURL(const std::string& file_name) {
return GURL(base::StrCat(
{"filesystem:chrome://file-manager/external/Downloads-user123/",
file_name}));
}
GURL MakeDriveURL(const std::string& file_name) {
return GURL(base::StrCat(
{"filesystem:chrome://file-manager/external/drivefs-987654321/",
file_name}));
}
MATCHER_P(ContainsFiles, expected_files, "") {
std::set<FileInfo> result_set;
for (const Match& match : arg.matches) {
result_set.emplace(match.file_info);
}
std::set<FileInfo> expected_set;
for (const FileInfo& info : expected_files) {
expected_set.emplace(info);
}
return expected_set == result_set;
}
class FileIndexServiceTest : public testing::Test {
public:
FileIndexServiceTest()
: pinned_("label", u"pinned"),
downloaded_("label", u"downloaded"),
starred_("label", u"starred") {}
void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
scheme_registry_ = std::make_unique<url::ScopedSchemeRegistryForTests>();
url::AddStandardScheme("chrome", url::SCHEME_WITH_HOST);
// These URLs must be created after scheme_registry_ has 'chrome' scheme
// added to it. Otherwise, they are deemed invalid.
foo_url_ = MakeLocalURL("foo.txt");
bar_url_ = MakeLocalURL("bar.txt");
CreateIndex();
}
void TearDown() override {
DestroyIndex();
ASSERT_TRUE(temp_dir_.Delete());
}
// Convenience methods that convert asynchronous results to synchronous.
void CreateIndex() {
base::FilePath db_path =
temp_dir_.GetPath().Append("FileIndexServiceTest.db");
index_service_ = std::make_unique<FileIndexService>(db_path);
ASSERT_EQ(Init(), OpResults::kSuccess);
}
void DestroyIndex() { index_service_.reset(); }
OpResults Init() {
base::RunLoop run_loop;
OpResults outcome;
index_service_->Init(base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
SearchResults Search(const Query& query) {
base::RunLoop run_loop;
SearchResults outcome;
index_service_->Search(
query, base::BindLambdaForTesting([&](SearchResults results) {
outcome.total_matches = results.total_matches;
outcome.matches = results.matches;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults PutFileInfo(const FileInfo& file_info) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->PutFileInfo(
file_info, base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults SetTerms(const std::vector<Term> terms, const GURL& url) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->SetTerms(terms, url,
base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults AddTerms(const std::vector<Term> terms, const GURL& url) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->AddTerms(terms, url,
base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults RemoveTerms(const std::vector<Term> terms, const GURL& url) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->RemoveTerms(
terms, url, base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults RemoveFile(const GURL& url) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->RemoveFile(
url, base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
OpResults MoveFile(const GURL& old_url, const GURL& new_url) {
base::RunLoop run_loop;
OpResults outcome;
index_service_->MoveFile(old_url, new_url,
base::BindLambdaForTesting([&](OpResults results) {
outcome = results;
run_loop.Quit();
}));
run_loop.Run();
return outcome;
}
Term pinned_;
Term downloaded_;
Term starred_;
GURL foo_url_;
GURL bar_url_;
std::unique_ptr<FileIndexService> index_service_;
base::ScopedTempDir temp_dir_;
// Allows registering the "chrome://" scheme, without depending on //content.
std::unique_ptr<url::ScopedSchemeRegistryForTests> scheme_registry_;
base::test::TaskEnvironment task_environment_;
};
typedef std::vector<FileInfo> FileInfoList;
TEST_F(FileIndexServiceTest, InitializeTwice) {
ASSERT_EQ(Init(), OpResults::kSuccess);
}
TEST_F(FileIndexServiceTest, CreateDestroyCreate) {
// Index is already created by SetUp(). Thus just destroy it and create.
// it again.
DestroyIndex();
// TODO(b:327534824): Remove the sleep statement.
base::PlatformThread::Sleep(base::Milliseconds(250));
CreateIndex();
}
TEST_F(FileIndexServiceTest, EmptySearch) {
// Empty query on an empty index.
EXPECT_THAT(Search(Query({})), ContainsFiles(FileInfoList{}));
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({pinned_}, file_info.file_url), OpResults::kSuccess);
// Empty query on an non-empty index.
EXPECT_THAT(Search(Query({})), ContainsFiles(FileInfoList{}));
}
TEST_F(FileIndexServiceTest, SimpleMatch) {
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({pinned_}, file_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({pinned_})), ContainsFiles(FileInfoList{file_info}));
}
TEST_F(FileIndexServiceTest, MultiTermMatch) {
FileInfo file_info(foo_url_, 1024, base::Time());
// Label file_info as pinned and starred.
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({pinned_, starred_}, file_info.file_url),
OpResults::kSuccess);
EXPECT_THAT(Search(Query({pinned_})), ContainsFiles(FileInfoList{file_info}));
EXPECT_THAT(Search(Query({starred_})),
ContainsFiles(FileInfoList{file_info}));
EXPECT_THAT(Search(Query({pinned_, starred_})),
ContainsFiles(FileInfoList{file_info}));
}
TEST_F(FileIndexServiceTest, AddTerms) {
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
// Label file_info as pinned and starred.
EXPECT_EQ(SetTerms({downloaded_}, file_info.file_url), OpResults::kSuccess);
// Can find by downloaded.
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{file_info}));
// Cannot find by starred.
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{}));
EXPECT_EQ(AddTerms({starred_}, foo_url_), OpResults::kSuccess);
// Can find by downloaded.
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{file_info}));
// And by starred.
EXPECT_THAT(Search(Query({starred_})),
ContainsFiles(FileInfoList{file_info}));
// And by starred and downloaded.
EXPECT_THAT(Search(Query({starred_, downloaded_})),
ContainsFiles(FileInfoList{file_info}));
}
TEST_F(FileIndexServiceTest, ReplaceTerms) {
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
// Start with the single label: downloaded.
EXPECT_EQ(SetTerms({downloaded_}, file_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{file_info}));
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{}));
// Just adding more labels: both downloaded and starred.
EXPECT_EQ(SetTerms({downloaded_, starred_}, file_info.file_url),
OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{file_info}));
EXPECT_THAT(Search(Query({starred_})),
ContainsFiles(FileInfoList{file_info}));
// Remove the original "downloaded" label.
EXPECT_EQ(SetTerms({starred_}, file_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})), ContainsFiles(FileInfoList{}));
EXPECT_THAT(Search(Query({starred_})),
ContainsFiles(FileInfoList{file_info}));
// Remove the "starred" label and add back "downloaded".
EXPECT_EQ(SetTerms({downloaded_}, file_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{file_info}));
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList({})));
}
TEST_F(FileIndexServiceTest, SearchMultipleFiles) {
FileInfo foo_file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(foo_file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({downloaded_}, foo_file_info.file_url),
OpResults::kSuccess);
GURL bar_drive_url = MakeDriveURL("bar.txt");
FileInfo bar_file_info(bar_drive_url, 1024, base::Time());
EXPECT_EQ(PutFileInfo(bar_file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({downloaded_}, bar_file_info.file_url),
OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{foo_file_info, bar_file_info}));
}
TEST_F(FileIndexServiceTest, SearchByNonexistingTerms) {
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({pinned_}, file_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({downloaded_})), ContainsFiles(FileInfoList{}));
}
TEST_F(FileIndexServiceTest, EmptySetTermsIsInvalid) {
FileInfo file_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(file_info), OpResults::kSuccess);
// Insert into the index with pinned label.
EXPECT_EQ(SetTerms({pinned_}, file_info.file_url), OpResults::kSuccess);
// Verify that passing empty terms is disallowed.
EXPECT_EQ(SetTerms({}, file_info.file_url), OpResults::kArgumentError);
EXPECT_THAT(Search(Query({pinned_})), ContainsFiles(FileInfoList{file_info}));
}
TEST_F(FileIndexServiceTest, FieldSeparator) {
Term colon_in_field("foo:", u"one");
FileInfo foo_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(foo_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({colon_in_field}, foo_info.file_url), OpResults::kSuccess);
Term colon_in_text("foo", u":one");
FileInfo bar_info(bar_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(bar_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({colon_in_text}, bar_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({colon_in_field})),
ContainsFiles(FileInfoList{foo_info}));
EXPECT_THAT(Search(Query({colon_in_text})),
ContainsFiles(FileInfoList{bar_info}));
}
TEST_F(FileIndexServiceTest, GlobalSearch) {
// Setup: two files, one marked with the label:starred, the other with
// content:starred. This simulates the case where identical tokens, "starred"
// came from two different sources (labeling, and file content).
const std::u16string text = u"starred";
Term label_term("label", text);
Term content_term("content", text);
FileInfo labeled_info(foo_url_, 1024, base::Time());
FileInfo content_info(bar_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(labeled_info), OpResults::kSuccess);
EXPECT_EQ(PutFileInfo(content_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({label_term}, labeled_info.file_url), OpResults::kSuccess);
EXPECT_EQ(SetTerms({content_term}, content_info.file_url),
OpResults::kSuccess);
// Searching with empty field name means global space search.
EXPECT_THAT(Search(Query({Term("", text)})),
ContainsFiles(FileInfoList{labeled_info, content_info}));
// Searching with field name, gives us unique results.
EXPECT_THAT(Search(Query({label_term})),
ContainsFiles(FileInfoList{labeled_info}));
EXPECT_THAT(Search(Query({content_term})),
ContainsFiles(FileInfoList{content_info}));
}
TEST_F(FileIndexServiceTest, MixedSearch) {
// Setup: two files, both starred, one labeled "tax", one containing the word
// "tax" in its content.
const std::u16string tax_text = u"tax";
Term tax_content_term("content", tax_text);
Term tax_label_term("label", tax_text);
FileInfo tax_label_info(foo_url_, 1024, base::Time());
FileInfo tax_content_info(bar_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(tax_label_info), OpResults::kSuccess);
EXPECT_EQ(PutFileInfo(tax_content_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({starred_, tax_content_term}, tax_content_info.file_url),
OpResults::kSuccess);
EXPECT_EQ(SetTerms({starred_, tax_label_term}, tax_label_info.file_url),
OpResults::kSuccess);
// Searching with "starred tax" should return both files.
EXPECT_THAT(Search(Query({Term("", tax_text), Term("", u"starred")})),
ContainsFiles(FileInfoList{tax_content_info, tax_label_info}));
// Searching with with "label:starred content:tax" gives us just the file that
// has "tax" in content.
EXPECT_THAT(Search(Query({starred_, tax_content_term})),
ContainsFiles(FileInfoList{tax_content_info}));
// Searching with with "label:starred label:tax" gives us just the file that
// has "tax" as a label.
EXPECT_THAT(Search(Query({starred_, tax_label_term})),
ContainsFiles(FileInfoList{tax_label_info}));
}
TEST_F(FileIndexServiceTest, MoveFile) {
// Test 1: Move non-existing file.
EXPECT_EQ(MoveFile(foo_url_, bar_url_), OpResults::kFileMissing);
// Test 2: Move file to itself.
FileInfo foo_info(foo_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(foo_info), OpResults::kSuccess);
EXPECT_EQ(MoveFile(foo_info.file_url, foo_info.file_url),
OpResults::kSuccess);
// Test 3: Move file onto existing file.
FileInfo bar_info(bar_url_, 1024, base::Time());
EXPECT_EQ(PutFileInfo(bar_info), OpResults::kSuccess);
EXPECT_EQ(MoveFile(foo_info.file_url, bar_info.file_url),
OpResults::kFileExists);
// Test 4: Actually move the file to the new URL.
// First setup terms and make sure we can find the file by those terms.
EXPECT_EQ(SetTerms({starred_, downloaded_}, foo_info.file_url),
OpResults::kSuccess);
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{foo_info}));
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{foo_info}));
// Now actually move the file and verify that we cannot match the old foo_info
// but can match foo_info_new.
GURL new_foo_url = MakeLocalURL("foo2.txt");
FileInfo new_foo_info(new_foo_url, foo_info.size, foo_info.last_modified);
EXPECT_EQ(MoveFile(foo_info.file_url, new_foo_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({starred_})),
ContainsFiles(FileInfoList{new_foo_info}));
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{new_foo_info}));
// We cannot directly check if a given URL exists in the system, but we
// can try to update terms using old URL and expect a kFileMissing error.
EXPECT_EQ(SetTerms({starred_}, foo_info.file_url), OpResults::kFileMissing);
}
TEST_F(FileIndexServiceTest, RemoveFile) {
// Empty remove.
FileInfo foo_info(foo_url_, 1024, base::Time());
EXPECT_EQ(RemoveFile(foo_info.file_url), OpResults::kSuccess);
// Add foo_info to the index.
EXPECT_EQ(PutFileInfo(foo_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({starred_}, foo_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{foo_info}));
EXPECT_EQ(RemoveFile(foo_info.file_url), OpResults::kSuccess);
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{}));
}
TEST_F(FileIndexServiceTest, RemoveTerms) {
FileInfo foo_info(foo_url_, 1024, base::Time());
EXPECT_EQ(RemoveTerms({}, foo_url_), OpResults::kSuccess);
// Add terms for foo_info.
EXPECT_EQ(PutFileInfo(foo_info), OpResults::kSuccess);
EXPECT_EQ(SetTerms({starred_, downloaded_}, foo_info.file_url),
OpResults::kSuccess);
EXPECT_THAT(Search(Query({starred_})), ContainsFiles(FileInfoList{foo_info}));
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{foo_info}));
EXPECT_EQ(RemoveTerms({starred_}, foo_info.file_url), OpResults::kSuccess);
EXPECT_TRUE(Search(Query({starred_})).matches.empty());
EXPECT_THAT(Search(Query({downloaded_})),
ContainsFiles(FileInfoList{foo_info}));
// Remove more terms, including one that is no longer there.
EXPECT_EQ(RemoveTerms({starred_, downloaded_}, foo_info.file_url),
OpResults::kSuccess);
EXPECT_TRUE(Search(Query({starred_})).matches.empty());
EXPECT_TRUE(Search(Query({downloaded_})).matches.empty());
}
TEST_F(FileIndexServiceTest, AddOrSetBeforePut) {
EXPECT_EQ(SetTerms({starred_}, foo_url_), OpResults::kFileMissing);
EXPECT_EQ(AddTerms({starred_}, foo_url_), OpResults::kFileMissing);
}
} // namespace
} // namespace ash::file_manager
Codebase Browser
chromium