1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/drive/file_system/search_operation.h"
6
7#include "chrome/browser/chromeos/drive/change_list_loader.h"
8#include "chrome/browser/chromeos/drive/file_system/operation_test_base.h"
9#include "chrome/browser/drive/fake_drive_service.h"
10#include "chrome/browser/google_apis/gdata_wapi_parser.h"
11#include "chrome/browser/google_apis/test_util.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace drive {
15namespace file_system {
16
17namespace {
18
19struct SearchResultPair {
20  const char* path;
21  const bool is_directory;
22};
23
24}  // namespace
25
26typedef OperationTestBase SearchOperationTest;
27
28TEST_F(SearchOperationTest, ContentSearch) {
29  SearchOperation operation(blocking_task_runner(), scheduler(), metadata());
30
31  const SearchResultPair kExpectedResults[] = {
32    { "drive/root/Directory 1/Sub Directory Folder/Sub Sub Directory Folder",
33      true },
34    { "drive/root/Directory 1/Sub Directory Folder", true },
35    { "drive/root/Directory 1/SubDirectory File 1.txt", false },
36    { "drive/root/Directory 1", true },
37    { "drive/root/Directory 2 excludeDir-test", true },
38  };
39
40  FileError error = FILE_ERROR_FAILED;
41  GURL next_url;
42  scoped_ptr<std::vector<SearchResultInfo> > results;
43
44  operation.Search("Directory", GURL(),
45                   google_apis::test_util::CreateCopyResultCallback(
46                       &error, &next_url, &results));
47  test_util::RunBlockingPoolTask();
48
49  EXPECT_EQ(FILE_ERROR_OK, error);
50  EXPECT_EQ(GURL(), next_url);
51  EXPECT_EQ(ARRAYSIZE_UNSAFE(kExpectedResults), results->size());
52  for (size_t i = 0; i < results->size(); i++) {
53    EXPECT_EQ(kExpectedResults[i].path, results->at(i).path.AsUTF8Unsafe());
54    EXPECT_EQ(kExpectedResults[i].is_directory,
55              results->at(i).entry.file_info().is_directory());
56  }
57}
58
59TEST_F(SearchOperationTest, ContentSearchWithNewEntry) {
60  SearchOperation operation(blocking_task_runner(), scheduler(), metadata());
61
62  // Create a new directory in the drive service.
63  google_apis::GDataErrorCode gdata_error = google_apis::GDATA_OTHER_ERROR;
64  scoped_ptr<google_apis::ResourceEntry> resource_entry;
65  fake_service()->AddNewDirectory(
66      fake_service()->GetRootResourceId(),
67      "New Directory 1!",
68      google_apis::test_util::CreateCopyResultCallback(
69          &gdata_error, &resource_entry));
70  test_util::RunBlockingPoolTask();
71  ASSERT_EQ(google_apis::HTTP_CREATED, gdata_error);
72
73  // As the result of the first Search(), only entries in the current file
74  // system snapshot are expected to be returned in the "right" path. New
75  // entries like "New Directory 1!" is temporarily added to "drive/other".
76  const SearchResultPair kExpectedResultsBeforeLoad[] = {
77      { "drive/root/Directory 1", true },
78      { "drive/other/New Directory 1!", true },
79  };
80
81  FileError error = FILE_ERROR_FAILED;
82  GURL next_url;
83  scoped_ptr<std::vector<SearchResultInfo> > results;
84
85  operation.Search("\"Directory 1\"", GURL(),
86                   google_apis::test_util::CreateCopyResultCallback(
87                       &error, &next_url, &results));
88  test_util::RunBlockingPoolTask();
89
90  EXPECT_EQ(FILE_ERROR_OK, error);
91  EXPECT_EQ(GURL(), next_url);
92  ASSERT_EQ(ARRAYSIZE_UNSAFE(kExpectedResultsBeforeLoad), results->size());
93  for (size_t i = 0; i < results->size(); i++) {
94    EXPECT_EQ(kExpectedResultsBeforeLoad[i].path,
95              results->at(i).path.AsUTF8Unsafe());
96    EXPECT_EQ(kExpectedResultsBeforeLoad[i].is_directory,
97              results->at(i).entry.file_info().is_directory());
98  }
99
100  // Load the change from FakeDriveService.
101  internal::ChangeListLoader change_list_loader(
102      blocking_task_runner(), metadata(), scheduler());
103  change_list_loader.CheckForUpdates(
104      google_apis::test_util::CreateCopyResultCallback(&error));
105  test_util::RunBlockingPoolTask();
106
107  // Now the new entry must be reported to be in the right directory.
108  const SearchResultPair kExpectedResultsAfterLoad[] = {
109      { "drive/root/Directory 1", true },
110      { "drive/root/New Directory 1!", true },
111  };
112  error = FILE_ERROR_FAILED;
113  operation.Search("\"Directory 1\"", GURL(),
114                   google_apis::test_util::CreateCopyResultCallback(
115                       &error, &next_url, &results));
116  test_util::RunBlockingPoolTask();
117
118  EXPECT_EQ(FILE_ERROR_OK, error);
119  EXPECT_EQ(GURL(), next_url);
120  ASSERT_EQ(ARRAYSIZE_UNSAFE(kExpectedResultsAfterLoad), results->size());
121  for (size_t i = 0; i < results->size(); i++) {
122    EXPECT_EQ(kExpectedResultsAfterLoad[i].path,
123              results->at(i).path.AsUTF8Unsafe());
124    EXPECT_EQ(kExpectedResultsAfterLoad[i].is_directory,
125              results->at(i).entry.file_info().is_directory());
126  }
127}
128
129TEST_F(SearchOperationTest, ContentSearchEmptyResult) {
130  SearchOperation operation(blocking_task_runner(), scheduler(), metadata());
131
132  FileError error = FILE_ERROR_FAILED;
133  GURL next_url;
134  scoped_ptr<std::vector<SearchResultInfo> > results;
135
136  operation.Search("\"no-match query\"", GURL(),
137                   google_apis::test_util::CreateCopyResultCallback(
138                       &error, &next_url, &results));
139  test_util::RunBlockingPoolTask();
140
141  EXPECT_EQ(FILE_ERROR_OK, error);
142  EXPECT_EQ(GURL(), next_url);
143  EXPECT_EQ(0U, results->size());
144}
145
146}  // namespace file_system
147}  // namespace drive
148