open_file_operation_unittest.cc revision 58537e28ecd584eab876aee8be7156509866d23a 
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/open_file_operation.h"
6
7#include <map>
8
9#include "base/file_util.h"
10#include "base/files/file_path.h"
11#include "base/memory/scoped_ptr.h"
12#include "chrome/browser/chromeos/drive/drive.pb.h"
13#include "chrome/browser/chromeos/drive/file_errors.h"
14#include "chrome/browser/chromeos/drive/file_system/operation_test_base.h"
15#include "chrome/browser/google_apis/test_util.h"
16#include "testing/gtest/include/gtest/gtest.h"
17
18namespace drive {
19namespace file_system {
20
21class OpenFileOperationTest : public OperationTestBase {
22 protected:
23  virtual void SetUp() OVERRIDE {
24    OperationTestBase::SetUp();
25
26    operation_.reset(new OpenFileOperation(
27        blocking_task_runner(), observer(), scheduler(), metadata(), cache(),
28        temp_dir()));
29  }
30
31  scoped_ptr<OpenFileOperation> operation_;
32};
33
34TEST_F(OpenFileOperationTest, OpenExistingFile) {
35  const base::FilePath file_in_root(
36      FILE_PATH_LITERAL("drive/root/File 1.txt"));
37  ResourceEntry src_entry;
38  ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(file_in_root, &src_entry));
39  const int64 file_size = src_entry.file_info().size();
40
41  FileError error = FILE_ERROR_FAILED;
42  base::FilePath file_path;
43  base::Closure close_callback;
44  operation_->OpenFile(
45      file_in_root,
46      OPEN_FILE,
47      std::string(),  // mime_type
48      google_apis::test_util::CreateCopyResultCallback(
49          &error, &file_path, &close_callback));
50  test_util::RunBlockingPoolTask();
51
52  EXPECT_EQ(FILE_ERROR_OK, error);
53  ASSERT_TRUE(base::PathExists(file_path));
54  int64 local_file_size;
55  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
56  EXPECT_EQ(file_size, local_file_size);
57
58  ASSERT_FALSE(close_callback.is_null());
59  close_callback.Run();
60  EXPECT_EQ(
61      1U,
62      observer()->upload_needed_local_ids().count(src_entry.resource_id()));
63}
64
65TEST_F(OpenFileOperationTest, OpenNonExistingFile) {
66  const base::FilePath file_in_root(
67      FILE_PATH_LITERAL("drive/root/not-exist.txt"));
68
69  FileError error = FILE_ERROR_FAILED;
70  base::FilePath file_path;
71  base::Closure close_callback;
72  operation_->OpenFile(
73      file_in_root,
74      OPEN_FILE,
75      std::string(),  // mime_type
76      google_apis::test_util::CreateCopyResultCallback(
77          &error, &file_path, &close_callback));
78  test_util::RunBlockingPoolTask();
79  EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
80  EXPECT_TRUE(close_callback.is_null());
81}
82
83TEST_F(OpenFileOperationTest, CreateExistingFile) {
84  const base::FilePath file_in_root(
85      FILE_PATH_LITERAL("drive/root/File 1.txt"));
86  ResourceEntry src_entry;
87  ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(file_in_root, &src_entry));
88
89  FileError error = FILE_ERROR_FAILED;
90  base::FilePath file_path;
91  base::Closure close_callback;
92  operation_->OpenFile(
93      file_in_root,
94      CREATE_FILE,
95      std::string(),  // mime_type
96      google_apis::test_util::CreateCopyResultCallback(
97          &error, &file_path, &close_callback));
98  test_util::RunBlockingPoolTask();
99
100  EXPECT_EQ(FILE_ERROR_EXISTS, error);
101  EXPECT_TRUE(close_callback.is_null());
102}
103
104TEST_F(OpenFileOperationTest, CreateNonExistingFile) {
105  const base::FilePath file_in_root(
106      FILE_PATH_LITERAL("drive/root/not-exist.txt"));
107
108  FileError error = FILE_ERROR_FAILED;
109  base::FilePath file_path;
110  base::Closure close_callback;
111  operation_->OpenFile(
112      file_in_root,
113      CREATE_FILE,
114      std::string(),  // mime_type
115      google_apis::test_util::CreateCopyResultCallback(
116          &error, &file_path, &close_callback));
117  test_util::RunBlockingPoolTask();
118
119  EXPECT_EQ(1U, observer()->get_changed_paths().size());
120  EXPECT_TRUE(observer()->get_changed_paths().count(file_in_root.DirName()));
121
122  EXPECT_EQ(FILE_ERROR_OK, error);
123  ASSERT_TRUE(base::PathExists(file_path));
124  int64 local_file_size;
125  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
126  EXPECT_EQ(0, local_file_size);  // Should be an empty file.
127
128  ASSERT_FALSE(close_callback.is_null());
129  close_callback.Run();
130  // Here we don't know about the resource id, so just make sure
131  // OnCacheFileUploadNeededByOperation is called actually.
132  EXPECT_EQ(1U, observer()->upload_needed_local_ids().size());
133}
134
135TEST_F(OpenFileOperationTest, OpenOrCreateExistingFile) {
136  const base::FilePath file_in_root(
137      FILE_PATH_LITERAL("drive/root/File 1.txt"));
138  ResourceEntry src_entry;
139  ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(file_in_root, &src_entry));
140  const int64 file_size = src_entry.file_info().size();
141
142  FileError error = FILE_ERROR_FAILED;
143  base::FilePath file_path;
144  base::Closure close_callback;
145  operation_->OpenFile(
146      file_in_root,
147      OPEN_OR_CREATE_FILE,
148      std::string(),  // mime_type
149      google_apis::test_util::CreateCopyResultCallback(
150          &error, &file_path, &close_callback));
151  test_util::RunBlockingPoolTask();
152
153  // Notified because 'available offline' status of the existing file changes.
154  EXPECT_EQ(1U, observer()->get_changed_paths().size());
155  EXPECT_TRUE(observer()->get_changed_paths().count(file_in_root.DirName()));
156
157  EXPECT_EQ(FILE_ERROR_OK, error);
158  ASSERT_TRUE(base::PathExists(file_path));
159  int64 local_file_size;
160  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
161  EXPECT_EQ(file_size, local_file_size);
162
163  ASSERT_FALSE(close_callback.is_null());
164  close_callback.Run();
165  EXPECT_EQ(
166      1U,
167      observer()->upload_needed_local_ids().count(src_entry.resource_id()));
168
169  bool success = false;
170  FileCacheEntry cache_entry;
171  cache()->GetCacheEntryOnUIThread(
172      src_entry.resource_id(),
173      google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
174  test_util::RunBlockingPoolTask();
175  EXPECT_TRUE(success);
176  EXPECT_TRUE(cache_entry.is_present());
177  EXPECT_TRUE(cache_entry.is_dirty());
178}
179
180TEST_F(OpenFileOperationTest, OpenOrCreateNonExistingFile) {
181  const base::FilePath file_in_root(
182      FILE_PATH_LITERAL("drive/root/not-exist.txt"));
183
184  FileError error = FILE_ERROR_FAILED;
185  base::FilePath file_path;
186  base::Closure close_callback;
187  operation_->OpenFile(
188      file_in_root,
189      OPEN_OR_CREATE_FILE,
190      std::string(),  // mime_type
191      google_apis::test_util::CreateCopyResultCallback(
192          &error, &file_path, &close_callback));
193  test_util::RunBlockingPoolTask();
194
195  EXPECT_EQ(FILE_ERROR_OK, error);
196  ASSERT_TRUE(base::PathExists(file_path));
197  int64 local_file_size;
198  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
199  EXPECT_EQ(0, local_file_size);  // Should be an empty file.
200
201  ASSERT_FALSE(close_callback.is_null());
202  close_callback.Run();
203  // Here we don't know about the resource id, so just make sure
204  // OnCacheFileUploadNeededByOperation is called actually.
205  EXPECT_EQ(1U, observer()->upload_needed_local_ids().size());
206}
207
208TEST_F(OpenFileOperationTest, OpenFileTwice) {
209  const base::FilePath file_in_root(
210      FILE_PATH_LITERAL("drive/root/File 1.txt"));
211  ResourceEntry src_entry;
212  ASSERT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(file_in_root, &src_entry));
213  const int64 file_size = src_entry.file_info().size();
214
215  FileError error = FILE_ERROR_FAILED;
216  base::FilePath file_path;
217  base::Closure close_callback;
218  operation_->OpenFile(
219      file_in_root,
220      OPEN_FILE,
221      std::string(),  // mime_type
222      google_apis::test_util::CreateCopyResultCallback(
223          &error, &file_path, &close_callback));
224  test_util::RunBlockingPoolTask();
225
226  EXPECT_EQ(FILE_ERROR_OK, error);
227  ASSERT_TRUE(base::PathExists(file_path));
228  int64 local_file_size;
229  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
230  EXPECT_EQ(file_size, local_file_size);
231
232  // Open again.
233  error = FILE_ERROR_FAILED;
234  base::Closure close_callback2;
235  operation_->OpenFile(
236      file_in_root,
237      OPEN_FILE,
238      std::string(),  // mime_type
239      google_apis::test_util::CreateCopyResultCallback(
240          &error, &file_path, &close_callback2));
241  test_util::RunBlockingPoolTask();
242
243  EXPECT_EQ(FILE_ERROR_OK, error);
244  ASSERT_TRUE(base::PathExists(file_path));
245  ASSERT_TRUE(file_util::GetFileSize(file_path, &local_file_size));
246  EXPECT_EQ(file_size, local_file_size);
247
248  ASSERT_FALSE(close_callback.is_null());
249  ASSERT_FALSE(close_callback2.is_null());
250
251  close_callback.Run();
252
253  // There still remains a client opening the file, so it shouldn't be
254  // uploaded yet.
255  EXPECT_TRUE(observer()->upload_needed_local_ids().empty());
256
257  close_callback2.Run();
258
259  // Here, all the clients close the file, so it should be uploaded then.
260  EXPECT_EQ(
261      1U,
262      observer()->upload_needed_local_ids().count(src_entry.resource_id()));
263}
264
265}  // namespace file_system
266}  // namespace drive
267