Files.app: split query into AND conditioned keywords in metadata search.

components/drive/search_metadata_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/drive/search_metadata.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/string_search.h"
+#include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/drive/drive_api_util.h"
 #include "components/drive/drive_test_util.h"
 #include "components/drive/fake_free_disk_space_getter.h"
 #include "components/drive/file_cache.h"
 #include "components/drive/file_system_core_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace internal {
 
 namespace {
 
 const int kDefaultAtMostNumMatches = 10;
 
 // A simple wrapper for testing FindAndHighlightWrapper(). It just converts the
 // query text parameter to FixedPatternStringSearchIgnoringCaseAndAccents.
 bool FindAndHighlightWrapper(
     const std::string& text,
     const std::string& query_text,
     std::string* highlighted_text) {
-  base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents query(
-      base::UTF8ToUTF16(query_text));
-  return FindAndHighlight(text, &query, highlighted_text);
+  ScopedVector<base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>
+      queries;
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16(query_text)));
+  return FindAndHighlight(text, queries, highlighted_text);
 }
 
 }  // namespace
 
 class SearchMetadataTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
@@ skipping 22 matching lines @@
     const std::string temp_file_md5 = "md5";
 
     ResourceEntry entry;
     std::string local_id;
 
     // drive/root
     EXPECT_EQ(FILE_ERROR_OK, resource_metadata_->GetIdByPath(
         util::GetDriveMyDriveRootPath(), &local_id));
     const std::string root_local_id = local_id;
 
-    // drive/root/Directory 1
-    EXPECT_EQ(FILE_ERROR_OK, resource_metadata_->AddEntry(GetDirectoryEntry(
-        "Directory 1", "dir1", 1, root_local_id), &local_id));
+    // drive/root/Directory-1
+    EXPECT_EQ(FILE_ERROR_OK,
+              resource_metadata_->AddEntry(
+                  GetDirectoryEntry("Directory-1", "dir1", 1, root_local_id),
+                  &local_id));
     const std::string dir1_local_id = local_id;
 
-    // drive/root/Directory 1/SubDirectory File 1.txt
+    // drive/root/Directory-1/SubDirectory File 1.txt
     EXPECT_EQ(FILE_ERROR_OK, resource_metadata_->AddEntry(GetFileEntry(
         "SubDirectory File 1.txt", "file1a", 2, dir1_local_id), &local_id));
     EXPECT_EQ(FILE_ERROR_OK, cache_->Store(
         local_id, temp_file_md5, temp_file, FileCache::FILE_OPERATION_COPY));
 
-    // drive/root/Directory 1/Shared To The Account Owner.txt
+    // drive/root/Directory-1/Shared To The Account Owner.txt
     entry = GetFileEntry(
         "Shared To The Account Owner.txt", "file1b", 3, dir1_local_id);
     entry.set_shared_with_me(true);
     EXPECT_EQ(FILE_ERROR_OK, resource_metadata_->AddEntry(entry, &local_id));
 
     // drive/root/Directory 2 excludeDir-test
     EXPECT_EQ(FILE_ERROR_OK, resource_metadata_->AddEntry(GetDirectoryEntry(
         "Directory 2 excludeDir-test", "dir2", 4, root_local_id), &local_id));
 
     // drive/root/Slash \xE2\x88\x95 in directory
@@ skipping 78 matching lines @@
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "SubDirectory File 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
-  EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 // This test checks if |FindAndHighlightWrapper| does case-insensitive search.
 // Tricker test cases for |FindAndHighlightWrapper| can be found below.
 TEST_F(SearchMetadataTest, SearchMetadata_CaseInsensitiveSearch) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // The query is all in lower case.
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "subdirectory file 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
-  EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_RegularFiles) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(2U, result->size());
 
   // All base names should contain "File". The results should be sorted by the
   // last accessed time in descending order.
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
-  EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
             result->at(1).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_AtMostOneFile) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   // There are two files matching "SubDir" but only one file should be
   // returned.
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       1,  // at_most_num_matches
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
   EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_Directory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
-      "Directory 1", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
+      "Directory-1", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
-  EXPECT_EQ("drive/root/Directory 1", result->at(0).path.AsUTF8Unsafe());
+  EXPECT_EQ("drive/root/Directory-1", result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_HostedDocument) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "Document",
       base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
@@ skipping 27 matching lines @@
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "",
       base::Bind(&MatchesType, SEARCH_METADATA_SHARED_WITH_ME),
       kDefaultAtMostNumMatches,
       google_apis::test_util::CreateCopyResultCallback(&error, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_TRUE(result);
   ASSERT_EQ(1U, result->size());
-  EXPECT_EQ("drive/root/Directory 1/Shared To The Account Owner.txt",
+  EXPECT_EQ("drive/root/Directory-1/Shared To The Account Owner.txt",
             result->at(0).path.AsUTF8Unsafe());
 }
 
 TEST_F(SearchMetadataTest, SearchMetadata_FileAndDirectory) {
   FileError error = FILE_ERROR_FAILED;
   scoped_ptr<MetadataSearchResultVector> result;
 
   SearchMetadata(
       base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
       "excludeDir-test", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
@@ skipping 63 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
   ASSERT_EQ(3U, result->size());
 
   // This is not included in the cache but is a hosted document.
   EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc",
             result->at(0).path.AsUTF8Unsafe());
 
   EXPECT_EQ("drive/root/File 2.txt",
             result->at(1).path.AsUTF8Unsafe());
-  EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt",
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
             result->at(2).path.AsUTF8Unsafe());
 }
 
+TEST_F(SearchMetadataTest, SearchMetadata_MultipleKeywords) {
+  FileError error = FILE_ERROR_FAILED;
+  scoped_ptr<MetadataSearchResultVector> result;
+
+  SearchMetadata(
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
+      "Directory 1", base::Bind(&MatchesType, SEARCH_METADATA_ALL),
+      kDefaultAtMostNumMatches,
+      google_apis::test_util::CreateCopyResultCallback(&error, &result));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+  ASSERT_TRUE(result);
+  ASSERT_EQ(2U, result->size());
+
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
+            result->at(0).path.AsUTF8Unsafe());
+  EXPECT_EQ("drive/root/Directory-1", result->at(1).path.AsUTF8Unsafe());
+}
+
+TEST_F(SearchMetadataTest,
+       SearchMetadata_KeywordsSeparatedWithIdeographicSpace) {
+  FileError error = FILE_ERROR_FAILED;
+  scoped_ptr<MetadataSearchResultVector> result;
+
+  // \xE3\x80\x80 is ideographic space.
+  SearchMetadata(
+      base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(),
+      "Directory\xE3\x80\x80"
+      "1",
+      base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches,
+      google_apis::test_util::CreateCopyResultCallback(&error, &result));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(FILE_ERROR_OK, error);
+  ASSERT_TRUE(result);
+  ASSERT_EQ(2U, result->size());
+
+  EXPECT_EQ("drive/root/Directory-1/SubDirectory File 1.txt",
+            result->at(0).path.AsUTF8Unsafe());
+  EXPECT_EQ("drive/root/Directory-1", result->at(1).path.AsUTF8Unsafe());
+}
+
 TEST(SearchMetadataSimpleTest, FindAndHighlight_ZeroMatches) {
   std::string highlighted_text;
   EXPECT_FALSE(FindAndHighlightWrapper("text", "query", &highlighted_text));
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_EmptyText) {
   std::string highlighted_text;
   EXPECT_FALSE(FindAndHighlightWrapper("", "query", &highlighted_text));
 }
 
+TEST(SearchMetadataSimpleTest, FindAndHighlight_EmptyQuery) {
+  ScopedVector<base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>
+      queries;
+
+  std::string highlighted_text;
+  EXPECT_TRUE(FindAndHighlight("hello", queries, &highlighted_text));
+  EXPECT_EQ("hello", highlighted_text);
+}
+
 TEST(SearchMetadataSimpleTest, FindAndHighlight_FullMatch) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("hello", "hello", &highlighted_text));
   EXPECT_EQ("<b>hello</b>", highlighted_text);
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_StartWith) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("hello, world", "hello",
                                      &highlighted_text));
@@ skipping 43 matching lines @@
   EXPECT_TRUE(FindAndHighlightWrapper(
       "\xE3\x81\xB2\xE3\x82\x9A\xE3\x82\x83\xE3\x83\xBC",
       "\xE3\x83\x94\xE3\x83\xA4",
       &highlighted_text));
   EXPECT_EQ(
       "<b>\xE3\x81\xB2\xE3\x82\x9A\xE3\x82\x83</b>\xE3\x83\xBC",
       highlighted_text);
 }
 
 TEST(SearchMetadataSimpleTest, MultiTextBySingleQuery) {
-  base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents query(
-      base::UTF8ToUTF16("hello"));
+  ScopedVector<base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>
+      queries;
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16("hello")));
 
   std::string highlighted_text;
-  EXPECT_TRUE(FindAndHighlight("hello", &query, &highlighted_text));
+  EXPECT_TRUE(FindAndHighlight("hello", queries, &highlighted_text));
   EXPECT_EQ("<b>hello</b>", highlighted_text);
-  EXPECT_FALSE(FindAndHighlight("goodbye", &query, &highlighted_text));
-  EXPECT_TRUE(FindAndHighlight("1hello2", &query, &highlighted_text));
+  EXPECT_FALSE(FindAndHighlight("goodbye", queries, &highlighted_text));
+  EXPECT_TRUE(FindAndHighlight("1hello2", queries, &highlighted_text));
   EXPECT_EQ("1<b>hello</b>2", highlighted_text);
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_MetaChars) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("<hello>", "hello", &highlighted_text));
   EXPECT_EQ("&lt;<b>hello</b>&gt;", highlighted_text);
 }
 
 TEST(SearchMetadataSimpleTest, FindAndHighlight_MoreMetaChars) {
   std::string highlighted_text;
   EXPECT_TRUE(FindAndHighlightWrapper("a&b&c&d", "b&c", &highlighted_text));
   EXPECT_EQ("a&amp;<b>b&amp;c</b>&amp;d", highlighted_text);
 }
 
+TEST(SearchMetadataSimpleTest, FindAndHighlight_SurrogatePair) {
+  std::string highlighted_text;
+  // \xF0\x9F\x98\x81 (U+1F601) is a surrogate pair for smile icon of emoji.
+  EXPECT_TRUE(FindAndHighlightWrapper("hi\xF0\x9F\x98\x81hello",
+                                      "i\xF0\x9F\x98\x81", &highlighted_text));
+  EXPECT_EQ("h<b>i\xF0\x9F\x98\x81</b>hello", highlighted_text);
+}
+
+TEST(SearchMetadataSimpleTest, FindAndHighlight_MultipleQueries) {
+  ScopedVector<base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>
+      queries;
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16("hello")));
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16("good")));
+
+  std::string highlighted_text;
+  EXPECT_TRUE(
+      FindAndHighlight("good morning, hello", queries, &highlighted_text));
+  EXPECT_EQ("<b>good</b> morning, <b>hello</b>", highlighted_text);
+}
+
+TEST(SearchMetadataSimpleTest, FindAndHighlight_OverlappingHighlights) {
+  ScopedVector<base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents>
+      queries;
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16("morning")));
+  queries.push_back(
+      new base::i18n::FixedPatternStringSearchIgnoringCaseAndAccents(
+          base::UTF8ToUTF16("ing,")));
+
+  std::string highlighted_text;
+  EXPECT_TRUE(
+      FindAndHighlight("good morning, hello", queries, &highlighted_text));
+  EXPECT_EQ("good <b>morning,</b> hello", highlighted_text);
+}
+
 }  // namespace internal
 }  // namespace drive