OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/drive/fake_drive_service.h" | 5 #include "chrome/browser/drive/fake_drive_service.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/file_util.h" | 10 #include "base/file_util.h" |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
103 content::TestBrowserThreadBundle thread_bundle_; | 103 content::TestBrowserThreadBundle thread_bundle_; |
104 FakeDriveService fake_service_; | 104 FakeDriveService fake_service_; |
105 }; | 105 }; |
106 | 106 |
107 void AppendProgressCallbackResult(std::vector<int64>* values, int64 progress) { | 107 void AppendProgressCallbackResult(std::vector<int64>* values, int64 progress) { |
108 values->push_back(progress); | 108 values->push_back(progress); |
109 } | 109 } |
110 | 110 |
111 TEST_F(FakeDriveServiceTest, GetAllResourceList) { | 111 TEST_F(FakeDriveServiceTest, GetAllResourceList) { |
112 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 112 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
113 "chromeos/gdata/root_feed.json")); | 113 "gdata/root_feed.json")); |
114 | 114 |
115 GDataErrorCode error = GDATA_OTHER_ERROR; | 115 GDataErrorCode error = GDATA_OTHER_ERROR; |
116 scoped_ptr<ResourceList> resource_list; | 116 scoped_ptr<ResourceList> resource_list; |
117 fake_service_.GetAllResourceList( | 117 fake_service_.GetAllResourceList( |
118 test_util::CreateCopyResultCallback(&error, &resource_list)); | 118 test_util::CreateCopyResultCallback(&error, &resource_list)); |
119 base::RunLoop().RunUntilIdle(); | 119 base::RunLoop().RunUntilIdle(); |
120 | 120 |
121 EXPECT_EQ(HTTP_SUCCESS, error); | 121 EXPECT_EQ(HTTP_SUCCESS, error); |
122 ASSERT_TRUE(resource_list); | 122 ASSERT_TRUE(resource_list); |
123 // Do some sanity check. | 123 // Do some sanity check. |
124 EXPECT_EQ(14U, resource_list->entries().size()); | 124 EXPECT_EQ(14U, resource_list->entries().size()); |
125 EXPECT_EQ(1, fake_service_.resource_list_load_count()); | 125 EXPECT_EQ(1, fake_service_.resource_list_load_count()); |
126 } | 126 } |
127 | 127 |
128 TEST_F(FakeDriveServiceTest, GetAllResourceList_Offline) { | 128 TEST_F(FakeDriveServiceTest, GetAllResourceList_Offline) { |
129 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 129 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
130 "chromeos/gdata/root_feed.json")); | 130 "gdata/root_feed.json")); |
131 fake_service_.set_offline(true); | 131 fake_service_.set_offline(true); |
132 | 132 |
133 GDataErrorCode error = GDATA_OTHER_ERROR; | 133 GDataErrorCode error = GDATA_OTHER_ERROR; |
134 scoped_ptr<ResourceList> resource_list; | 134 scoped_ptr<ResourceList> resource_list; |
135 fake_service_.GetAllResourceList( | 135 fake_service_.GetAllResourceList( |
136 test_util::CreateCopyResultCallback(&error, &resource_list)); | 136 test_util::CreateCopyResultCallback(&error, &resource_list)); |
137 base::RunLoop().RunUntilIdle(); | 137 base::RunLoop().RunUntilIdle(); |
138 | 138 |
139 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 139 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
140 EXPECT_FALSE(resource_list); | 140 EXPECT_FALSE(resource_list); |
141 } | 141 } |
142 | 142 |
143 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InRootDirectory) { | 143 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InRootDirectory) { |
144 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 144 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
145 "chromeos/gdata/root_feed.json")); | 145 "gdata/root_feed.json")); |
146 | 146 |
147 GDataErrorCode error = GDATA_OTHER_ERROR; | 147 GDataErrorCode error = GDATA_OTHER_ERROR; |
148 scoped_ptr<ResourceList> resource_list; | 148 scoped_ptr<ResourceList> resource_list; |
149 fake_service_.GetResourceListInDirectory( | 149 fake_service_.GetResourceListInDirectory( |
150 fake_service_.GetRootResourceId(), | 150 fake_service_.GetRootResourceId(), |
151 test_util::CreateCopyResultCallback(&error, &resource_list)); | 151 test_util::CreateCopyResultCallback(&error, &resource_list)); |
152 base::RunLoop().RunUntilIdle(); | 152 base::RunLoop().RunUntilIdle(); |
153 | 153 |
154 EXPECT_EQ(HTTP_SUCCESS, error); | 154 EXPECT_EQ(HTTP_SUCCESS, error); |
155 ASSERT_TRUE(resource_list); | 155 ASSERT_TRUE(resource_list); |
156 // Do some sanity check. There are 8 entries in the root directory. | 156 // Do some sanity check. There are 8 entries in the root directory. |
157 EXPECT_EQ(8U, resource_list->entries().size()); | 157 EXPECT_EQ(8U, resource_list->entries().size()); |
158 EXPECT_EQ(1, fake_service_.directory_load_count()); | 158 EXPECT_EQ(1, fake_service_.directory_load_count()); |
159 } | 159 } |
160 | 160 |
161 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InNonRootDirectory) { | 161 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InNonRootDirectory) { |
162 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 162 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
163 "chromeos/gdata/root_feed.json")); | 163 "gdata/root_feed.json")); |
164 | 164 |
165 GDataErrorCode error = GDATA_OTHER_ERROR; | 165 GDataErrorCode error = GDATA_OTHER_ERROR; |
166 scoped_ptr<ResourceList> resource_list; | 166 scoped_ptr<ResourceList> resource_list; |
167 fake_service_.GetResourceListInDirectory( | 167 fake_service_.GetResourceListInDirectory( |
168 "folder:1_folder_resource_id", | 168 "folder:1_folder_resource_id", |
169 test_util::CreateCopyResultCallback(&error, &resource_list)); | 169 test_util::CreateCopyResultCallback(&error, &resource_list)); |
170 base::RunLoop().RunUntilIdle(); | 170 base::RunLoop().RunUntilIdle(); |
171 | 171 |
172 EXPECT_EQ(HTTP_SUCCESS, error); | 172 EXPECT_EQ(HTTP_SUCCESS, error); |
173 ASSERT_TRUE(resource_list); | 173 ASSERT_TRUE(resource_list); |
174 // Do some sanity check. There is three entries in 1_folder_resource_id | 174 // Do some sanity check. There is three entries in 1_folder_resource_id |
175 // directory. | 175 // directory. |
176 EXPECT_EQ(3U, resource_list->entries().size()); | 176 EXPECT_EQ(3U, resource_list->entries().size()); |
177 EXPECT_EQ(1, fake_service_.directory_load_count()); | 177 EXPECT_EQ(1, fake_service_.directory_load_count()); |
178 } | 178 } |
179 | 179 |
180 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_Offline) { | 180 TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_Offline) { |
181 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 181 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
182 "chromeos/gdata/root_feed.json")); | 182 "gdata/root_feed.json")); |
183 fake_service_.set_offline(true); | 183 fake_service_.set_offline(true); |
184 | 184 |
185 GDataErrorCode error = GDATA_OTHER_ERROR; | 185 GDataErrorCode error = GDATA_OTHER_ERROR; |
186 scoped_ptr<ResourceList> resource_list; | 186 scoped_ptr<ResourceList> resource_list; |
187 fake_service_.GetResourceListInDirectory( | 187 fake_service_.GetResourceListInDirectory( |
188 fake_service_.GetRootResourceId(), | 188 fake_service_.GetRootResourceId(), |
189 test_util::CreateCopyResultCallback(&error, &resource_list)); | 189 test_util::CreateCopyResultCallback(&error, &resource_list)); |
190 base::RunLoop().RunUntilIdle(); | 190 base::RunLoop().RunUntilIdle(); |
191 | 191 |
192 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 192 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
193 EXPECT_FALSE(resource_list); | 193 EXPECT_FALSE(resource_list); |
194 } | 194 } |
195 | 195 |
196 TEST_F(FakeDriveServiceTest, Search) { | 196 TEST_F(FakeDriveServiceTest, Search) { |
197 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 197 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
198 "chromeos/gdata/root_feed.json")); | 198 "gdata/root_feed.json")); |
199 | 199 |
200 GDataErrorCode error = GDATA_OTHER_ERROR; | 200 GDataErrorCode error = GDATA_OTHER_ERROR; |
201 scoped_ptr<ResourceList> resource_list; | 201 scoped_ptr<ResourceList> resource_list; |
202 fake_service_.Search( | 202 fake_service_.Search( |
203 "File", // search_query | 203 "File", // search_query |
204 test_util::CreateCopyResultCallback(&error, &resource_list)); | 204 test_util::CreateCopyResultCallback(&error, &resource_list)); |
205 base::RunLoop().RunUntilIdle(); | 205 base::RunLoop().RunUntilIdle(); |
206 | 206 |
207 EXPECT_EQ(HTTP_SUCCESS, error); | 207 EXPECT_EQ(HTTP_SUCCESS, error); |
208 ASSERT_TRUE(resource_list); | 208 ASSERT_TRUE(resource_list); |
209 // Do some sanity check. There are 4 entries that contain "File" in their | 209 // Do some sanity check. There are 4 entries that contain "File" in their |
210 // titles. | 210 // titles. |
211 EXPECT_EQ(4U, resource_list->entries().size()); | 211 EXPECT_EQ(4U, resource_list->entries().size()); |
212 } | 212 } |
213 | 213 |
214 TEST_F(FakeDriveServiceTest, Search_WithAttribute) { | 214 TEST_F(FakeDriveServiceTest, Search_WithAttribute) { |
215 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 215 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
216 "chromeos/gdata/root_feed.json")); | 216 "gdata/root_feed.json")); |
217 | 217 |
218 GDataErrorCode error = GDATA_OTHER_ERROR; | 218 GDataErrorCode error = GDATA_OTHER_ERROR; |
219 scoped_ptr<ResourceList> resource_list; | 219 scoped_ptr<ResourceList> resource_list; |
220 fake_service_.Search( | 220 fake_service_.Search( |
221 "title:1.txt", // search_query | 221 "title:1.txt", // search_query |
222 test_util::CreateCopyResultCallback(&error, &resource_list)); | 222 test_util::CreateCopyResultCallback(&error, &resource_list)); |
223 base::RunLoop().RunUntilIdle(); | 223 base::RunLoop().RunUntilIdle(); |
224 | 224 |
225 EXPECT_EQ(HTTP_SUCCESS, error); | 225 EXPECT_EQ(HTTP_SUCCESS, error); |
226 ASSERT_TRUE(resource_list); | 226 ASSERT_TRUE(resource_list); |
227 // Do some sanity check. There are 4 entries that contain "1.txt" in their | 227 // Do some sanity check. There are 4 entries that contain "1.txt" in their |
228 // titles. | 228 // titles. |
229 EXPECT_EQ(4U, resource_list->entries().size()); | 229 EXPECT_EQ(4U, resource_list->entries().size()); |
230 } | 230 } |
231 | 231 |
232 TEST_F(FakeDriveServiceTest, Search_MultipleQueries) { | 232 TEST_F(FakeDriveServiceTest, Search_MultipleQueries) { |
233 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 233 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
234 "chromeos/gdata/root_feed.json")); | 234 "gdata/root_feed.json")); |
235 | 235 |
236 GDataErrorCode error = GDATA_OTHER_ERROR; | 236 GDataErrorCode error = GDATA_OTHER_ERROR; |
237 scoped_ptr<ResourceList> resource_list; | 237 scoped_ptr<ResourceList> resource_list; |
238 fake_service_.Search( | 238 fake_service_.Search( |
239 "Directory 1", // search_query | 239 "Directory 1", // search_query |
240 test_util::CreateCopyResultCallback(&error, &resource_list)); | 240 test_util::CreateCopyResultCallback(&error, &resource_list)); |
241 base::RunLoop().RunUntilIdle(); | 241 base::RunLoop().RunUntilIdle(); |
242 | 242 |
243 EXPECT_EQ(HTTP_SUCCESS, error); | 243 EXPECT_EQ(HTTP_SUCCESS, error); |
244 ASSERT_TRUE(resource_list); | 244 ASSERT_TRUE(resource_list); |
245 // There are 2 entries that contain both "Directory" and "1" in their titles. | 245 // There are 2 entries that contain both "Directory" and "1" in their titles. |
246 EXPECT_EQ(2U, resource_list->entries().size()); | 246 EXPECT_EQ(2U, resource_list->entries().size()); |
247 | 247 |
248 fake_service_.Search( | 248 fake_service_.Search( |
249 "\"Directory 1\"", // search_query | 249 "\"Directory 1\"", // search_query |
250 test_util::CreateCopyResultCallback(&error, &resource_list)); | 250 test_util::CreateCopyResultCallback(&error, &resource_list)); |
251 base::RunLoop().RunUntilIdle(); | 251 base::RunLoop().RunUntilIdle(); |
252 | 252 |
253 EXPECT_EQ(HTTP_SUCCESS, error); | 253 EXPECT_EQ(HTTP_SUCCESS, error); |
254 ASSERT_TRUE(resource_list); | 254 ASSERT_TRUE(resource_list); |
255 // There is 1 entry that contain "Directory 1" in its title. | 255 // There is 1 entry that contain "Directory 1" in its title. |
256 EXPECT_EQ(1U, resource_list->entries().size()); | 256 EXPECT_EQ(1U, resource_list->entries().size()); |
257 } | 257 } |
258 | 258 |
259 TEST_F(FakeDriveServiceTest, Search_Offline) { | 259 TEST_F(FakeDriveServiceTest, Search_Offline) { |
260 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 260 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
261 "chromeos/gdata/root_feed.json")); | 261 "gdata/root_feed.json")); |
262 fake_service_.set_offline(true); | 262 fake_service_.set_offline(true); |
263 | 263 |
264 GDataErrorCode error = GDATA_OTHER_ERROR; | 264 GDataErrorCode error = GDATA_OTHER_ERROR; |
265 scoped_ptr<ResourceList> resource_list; | 265 scoped_ptr<ResourceList> resource_list; |
266 fake_service_.Search( | 266 fake_service_.Search( |
267 "Directory 1", // search_query | 267 "Directory 1", // search_query |
268 test_util::CreateCopyResultCallback(&error, &resource_list)); | 268 test_util::CreateCopyResultCallback(&error, &resource_list)); |
269 base::RunLoop().RunUntilIdle(); | 269 base::RunLoop().RunUntilIdle(); |
270 | 270 |
271 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 271 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
272 EXPECT_FALSE(resource_list); | 272 EXPECT_FALSE(resource_list); |
273 } | 273 } |
274 | 274 |
275 TEST_F(FakeDriveServiceTest, Search_Deleted) { | 275 TEST_F(FakeDriveServiceTest, Search_Deleted) { |
276 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 276 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
277 "chromeos/gdata/root_feed.json")); | 277 "gdata/root_feed.json")); |
278 | 278 |
279 GDataErrorCode error = GDATA_OTHER_ERROR; | 279 GDataErrorCode error = GDATA_OTHER_ERROR; |
280 fake_service_.DeleteResource("file:2_file_resource_id", | 280 fake_service_.DeleteResource("file:2_file_resource_id", |
281 std::string(), // etag | 281 std::string(), // etag |
282 test_util::CreateCopyResultCallback(&error)); | 282 test_util::CreateCopyResultCallback(&error)); |
283 base::RunLoop().RunUntilIdle(); | 283 base::RunLoop().RunUntilIdle(); |
284 EXPECT_EQ(HTTP_SUCCESS, error); | 284 EXPECT_EQ(HTTP_SUCCESS, error); |
285 | 285 |
286 error = GDATA_OTHER_ERROR; | 286 error = GDATA_OTHER_ERROR; |
287 scoped_ptr<ResourceList> resource_list; | 287 scoped_ptr<ResourceList> resource_list; |
288 fake_service_.Search( | 288 fake_service_.Search( |
289 "File", // search_query | 289 "File", // search_query |
290 test_util::CreateCopyResultCallback(&error, &resource_list)); | 290 test_util::CreateCopyResultCallback(&error, &resource_list)); |
291 base::RunLoop().RunUntilIdle(); | 291 base::RunLoop().RunUntilIdle(); |
292 | 292 |
293 EXPECT_EQ(HTTP_SUCCESS, error); | 293 EXPECT_EQ(HTTP_SUCCESS, error); |
294 ASSERT_TRUE(resource_list); | 294 ASSERT_TRUE(resource_list); |
295 // Do some sanity check. There are 4 entries that contain "File" in their | 295 // Do some sanity check. There are 4 entries that contain "File" in their |
296 // titles and one of them is deleted. | 296 // titles and one of them is deleted. |
297 EXPECT_EQ(3U, resource_list->entries().size()); | 297 EXPECT_EQ(3U, resource_list->entries().size()); |
298 } | 298 } |
299 | 299 |
300 TEST_F(FakeDriveServiceTest, SearchByTitle) { | 300 TEST_F(FakeDriveServiceTest, SearchByTitle) { |
301 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 301 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
302 "chromeos/gdata/root_feed.json")); | 302 "gdata/root_feed.json")); |
303 | 303 |
304 GDataErrorCode error = GDATA_OTHER_ERROR; | 304 GDataErrorCode error = GDATA_OTHER_ERROR; |
305 scoped_ptr<ResourceList> resource_list; | 305 scoped_ptr<ResourceList> resource_list; |
306 fake_service_.SearchByTitle( | 306 fake_service_.SearchByTitle( |
307 "1.txt", // title | 307 "1.txt", // title |
308 fake_service_.GetRootResourceId(), // directory_resource_id | 308 fake_service_.GetRootResourceId(), // directory_resource_id |
309 test_util::CreateCopyResultCallback(&error, &resource_list)); | 309 test_util::CreateCopyResultCallback(&error, &resource_list)); |
310 base::RunLoop().RunUntilIdle(); | 310 base::RunLoop().RunUntilIdle(); |
311 | 311 |
312 EXPECT_EQ(HTTP_SUCCESS, error); | 312 EXPECT_EQ(HTTP_SUCCESS, error); |
313 ASSERT_TRUE(resource_list); | 313 ASSERT_TRUE(resource_list); |
314 // Do some sanity check. There are 2 entries that contain "1.txt" in their | 314 // Do some sanity check. There are 2 entries that contain "1.txt" in their |
315 // titles directly under the root directory. | 315 // titles directly under the root directory. |
316 EXPECT_EQ(2U, resource_list->entries().size()); | 316 EXPECT_EQ(2U, resource_list->entries().size()); |
317 } | 317 } |
318 | 318 |
319 TEST_F(FakeDriveServiceTest, SearchByTitle_EmptyDirectoryResourceId) { | 319 TEST_F(FakeDriveServiceTest, SearchByTitle_EmptyDirectoryResourceId) { |
320 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 320 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
321 "chromeos/gdata/root_feed.json")); | 321 "gdata/root_feed.json")); |
322 | 322 |
323 GDataErrorCode error = GDATA_OTHER_ERROR; | 323 GDataErrorCode error = GDATA_OTHER_ERROR; |
324 scoped_ptr<ResourceList> resource_list; | 324 scoped_ptr<ResourceList> resource_list; |
325 fake_service_.SearchByTitle( | 325 fake_service_.SearchByTitle( |
326 "1.txt", // title | 326 "1.txt", // title |
327 "", // directory resource id | 327 "", // directory resource id |
328 test_util::CreateCopyResultCallback(&error, &resource_list)); | 328 test_util::CreateCopyResultCallback(&error, &resource_list)); |
329 base::RunLoop().RunUntilIdle(); | 329 base::RunLoop().RunUntilIdle(); |
330 | 330 |
331 EXPECT_EQ(HTTP_SUCCESS, error); | 331 EXPECT_EQ(HTTP_SUCCESS, error); |
332 ASSERT_TRUE(resource_list); | 332 ASSERT_TRUE(resource_list); |
333 // Do some sanity check. There are 4 entries that contain "1.txt" in their | 333 // Do some sanity check. There are 4 entries that contain "1.txt" in their |
334 // titles. | 334 // titles. |
335 EXPECT_EQ(4U, resource_list->entries().size()); | 335 EXPECT_EQ(4U, resource_list->entries().size()); |
336 } | 336 } |
337 | 337 |
338 TEST_F(FakeDriveServiceTest, SearchByTitle_Offline) { | 338 TEST_F(FakeDriveServiceTest, SearchByTitle_Offline) { |
339 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 339 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
340 "chromeos/gdata/root_feed.json")); | 340 "gdata/root_feed.json")); |
341 fake_service_.set_offline(true); | 341 fake_service_.set_offline(true); |
342 | 342 |
343 GDataErrorCode error = GDATA_OTHER_ERROR; | 343 GDataErrorCode error = GDATA_OTHER_ERROR; |
344 scoped_ptr<ResourceList> resource_list; | 344 scoped_ptr<ResourceList> resource_list; |
345 fake_service_.SearchByTitle( | 345 fake_service_.SearchByTitle( |
346 "Directory 1", // title | 346 "Directory 1", // title |
347 fake_service_.GetRootResourceId(), // directory_resource_id | 347 fake_service_.GetRootResourceId(), // directory_resource_id |
348 test_util::CreateCopyResultCallback(&error, &resource_list)); | 348 test_util::CreateCopyResultCallback(&error, &resource_list)); |
349 base::RunLoop().RunUntilIdle(); | 349 base::RunLoop().RunUntilIdle(); |
350 | 350 |
351 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 351 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
352 EXPECT_FALSE(resource_list); | 352 EXPECT_FALSE(resource_list); |
353 } | 353 } |
354 | 354 |
355 TEST_F(FakeDriveServiceTest, GetChangeList_NoNewEntries) { | 355 TEST_F(FakeDriveServiceTest, GetChangeList_NoNewEntries) { |
356 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 356 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
357 "chromeos/gdata/root_feed.json")); | 357 "gdata/root_feed.json")); |
358 // Load the account_metadata.json as well to add the largest changestamp | 358 // Load the account_metadata.json as well to add the largest changestamp |
359 // (654321) to the existing entries. | 359 // (654321) to the existing entries. |
360 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 360 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
361 "chromeos/gdata/account_metadata.json")); | 361 "gdata/account_metadata.json")); |
362 | 362 |
363 GDataErrorCode error = GDATA_OTHER_ERROR; | 363 GDataErrorCode error = GDATA_OTHER_ERROR; |
364 scoped_ptr<ResourceList> resource_list; | 364 scoped_ptr<ResourceList> resource_list; |
365 fake_service_.GetChangeList( | 365 fake_service_.GetChangeList( |
366 654321 + 1, // start_changestamp | 366 654321 + 1, // start_changestamp |
367 test_util::CreateCopyResultCallback(&error, &resource_list)); | 367 test_util::CreateCopyResultCallback(&error, &resource_list)); |
368 base::RunLoop().RunUntilIdle(); | 368 base::RunLoop().RunUntilIdle(); |
369 | 369 |
370 EXPECT_EQ(HTTP_SUCCESS, error); | 370 EXPECT_EQ(HTTP_SUCCESS, error); |
371 ASSERT_TRUE(resource_list); | 371 ASSERT_TRUE(resource_list); |
372 // This should be empty as the latest changestamp was passed to | 372 // This should be empty as the latest changestamp was passed to |
373 // GetResourceList(), hence there should be no new entries. | 373 // GetResourceList(), hence there should be no new entries. |
374 EXPECT_EQ(0U, resource_list->entries().size()); | 374 EXPECT_EQ(0U, resource_list->entries().size()); |
375 // It's considered loaded even if the result is empty. | 375 // It's considered loaded even if the result is empty. |
376 EXPECT_EQ(1, fake_service_.change_list_load_count()); | 376 EXPECT_EQ(1, fake_service_.change_list_load_count()); |
377 } | 377 } |
378 | 378 |
379 TEST_F(FakeDriveServiceTest, GetChangeList_WithNewEntry) { | 379 TEST_F(FakeDriveServiceTest, GetChangeList_WithNewEntry) { |
380 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 380 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
381 "chromeos/gdata/root_feed.json")); | 381 "gdata/root_feed.json")); |
382 // Load the account_metadata.json as well to add the largest changestamp | 382 // Load the account_metadata.json as well to add the largest changestamp |
383 // (654321) to the existing entries. | 383 // (654321) to the existing entries. |
384 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 384 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
385 "chromeos/gdata/account_metadata.json")); | 385 "gdata/account_metadata.json")); |
386 // Add a new directory in the root directory. The new directory will have | 386 // Add a new directory in the root directory. The new directory will have |
387 // the changestamp of 654322. | 387 // the changestamp of 654322. |
388 ASSERT_TRUE(AddNewDirectory( | 388 ASSERT_TRUE(AddNewDirectory( |
389 fake_service_.GetRootResourceId(), "new directory")); | 389 fake_service_.GetRootResourceId(), "new directory")); |
390 | 390 |
391 // Get the resource list newer than 654321. | 391 // Get the resource list newer than 654321. |
392 GDataErrorCode error = GDATA_OTHER_ERROR; | 392 GDataErrorCode error = GDATA_OTHER_ERROR; |
393 scoped_ptr<ResourceList> resource_list; | 393 scoped_ptr<ResourceList> resource_list; |
394 fake_service_.GetChangeList( | 394 fake_service_.GetChangeList( |
395 654321 + 1, // start_changestamp | 395 654321 + 1, // start_changestamp |
396 test_util::CreateCopyResultCallback(&error, &resource_list)); | 396 test_util::CreateCopyResultCallback(&error, &resource_list)); |
397 base::RunLoop().RunUntilIdle(); | 397 base::RunLoop().RunUntilIdle(); |
398 | 398 |
399 EXPECT_EQ(HTTP_SUCCESS, error); | 399 EXPECT_EQ(HTTP_SUCCESS, error); |
400 ASSERT_TRUE(resource_list); | 400 ASSERT_TRUE(resource_list); |
401 // The result should only contain the newly created directory. | 401 // The result should only contain the newly created directory. |
402 ASSERT_EQ(1U, resource_list->entries().size()); | 402 ASSERT_EQ(1U, resource_list->entries().size()); |
403 EXPECT_EQ("new directory", resource_list->entries()[0]->title()); | 403 EXPECT_EQ("new directory", resource_list->entries()[0]->title()); |
404 EXPECT_EQ(1, fake_service_.change_list_load_count()); | 404 EXPECT_EQ(1, fake_service_.change_list_load_count()); |
405 } | 405 } |
406 | 406 |
407 TEST_F(FakeDriveServiceTest, GetChangeList_Offline) { | 407 TEST_F(FakeDriveServiceTest, GetChangeList_Offline) { |
408 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 408 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
409 "chromeos/gdata/root_feed.json")); | 409 "gdata/root_feed.json")); |
410 fake_service_.set_offline(true); | 410 fake_service_.set_offline(true); |
411 | 411 |
412 GDataErrorCode error = GDATA_OTHER_ERROR; | 412 GDataErrorCode error = GDATA_OTHER_ERROR; |
413 scoped_ptr<ResourceList> resource_list; | 413 scoped_ptr<ResourceList> resource_list; |
414 fake_service_.GetChangeList( | 414 fake_service_.GetChangeList( |
415 654321, // start_changestamp | 415 654321, // start_changestamp |
416 test_util::CreateCopyResultCallback(&error, &resource_list)); | 416 test_util::CreateCopyResultCallback(&error, &resource_list)); |
417 base::RunLoop().RunUntilIdle(); | 417 base::RunLoop().RunUntilIdle(); |
418 | 418 |
419 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 419 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
420 EXPECT_FALSE(resource_list); | 420 EXPECT_FALSE(resource_list); |
421 } | 421 } |
422 | 422 |
423 TEST_F(FakeDriveServiceTest, GetChangeList_DeletedEntry) { | 423 TEST_F(FakeDriveServiceTest, GetChangeList_DeletedEntry) { |
424 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 424 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
425 "chromeos/gdata/root_feed.json")); | 425 "gdata/root_feed.json")); |
426 // Load the account_metadata.json as well to add the largest changestamp | 426 // Load the account_metadata.json as well to add the largest changestamp |
427 // (654321) to the existing entries. | 427 // (654321) to the existing entries. |
428 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 428 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
429 "chromeos/gdata/account_metadata.json")); | 429 "gdata/account_metadata.json")); |
430 // Add a new directory in the root directory. The new directory will have | 430 // Add a new directory in the root directory. The new directory will have |
431 // the changestamp of 654322. | 431 // the changestamp of 654322. |
432 ASSERT_TRUE(Exists("file:2_file_resource_id")); | 432 ASSERT_TRUE(Exists("file:2_file_resource_id")); |
433 | 433 |
434 GDataErrorCode error = GDATA_OTHER_ERROR; | 434 GDataErrorCode error = GDATA_OTHER_ERROR; |
435 fake_service_.DeleteResource("file:2_file_resource_id", | 435 fake_service_.DeleteResource("file:2_file_resource_id", |
436 std::string(), // etag | 436 std::string(), // etag |
437 test_util::CreateCopyResultCallback(&error)); | 437 test_util::CreateCopyResultCallback(&error)); |
438 base::RunLoop().RunUntilIdle(); | 438 base::RunLoop().RunUntilIdle(); |
439 ASSERT_EQ(HTTP_SUCCESS, error); | 439 ASSERT_EQ(HTTP_SUCCESS, error); |
(...skipping 12 matching lines...) Expand all Loading... |
452 // The result should only contain the newly created directory. | 452 // The result should only contain the newly created directory. |
453 ASSERT_EQ(1U, resource_list->entries().size()); | 453 ASSERT_EQ(1U, resource_list->entries().size()); |
454 const ResourceEntry& entry = *resource_list->entries()[0]; | 454 const ResourceEntry& entry = *resource_list->entries()[0]; |
455 EXPECT_EQ("file:2_file_resource_id", entry.resource_id()); | 455 EXPECT_EQ("file:2_file_resource_id", entry.resource_id()); |
456 EXPECT_TRUE(entry.deleted()); | 456 EXPECT_TRUE(entry.deleted()); |
457 EXPECT_EQ(1, fake_service_.change_list_load_count()); | 457 EXPECT_EQ(1, fake_service_.change_list_load_count()); |
458 } | 458 } |
459 | 459 |
460 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_GetAllResourceList) { | 460 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_GetAllResourceList) { |
461 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 461 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
462 "chromeos/gdata/root_feed.json")); | 462 "gdata/root_feed.json")); |
463 fake_service_.set_default_max_results(6); | 463 fake_service_.set_default_max_results(6); |
464 | 464 |
465 GDataErrorCode error = GDATA_OTHER_ERROR; | 465 GDataErrorCode error = GDATA_OTHER_ERROR; |
466 scoped_ptr<ResourceList> resource_list; | 466 scoped_ptr<ResourceList> resource_list; |
467 fake_service_.GetAllResourceList( | 467 fake_service_.GetAllResourceList( |
468 test_util::CreateCopyResultCallback(&error, &resource_list)); | 468 test_util::CreateCopyResultCallback(&error, &resource_list)); |
469 base::RunLoop().RunUntilIdle(); | 469 base::RunLoop().RunUntilIdle(); |
470 EXPECT_EQ(HTTP_SUCCESS, error); | 470 EXPECT_EQ(HTTP_SUCCESS, error); |
471 ASSERT_TRUE(resource_list); | 471 ASSERT_TRUE(resource_list); |
472 | 472 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
511 EXPECT_EQ(HTTP_SUCCESS, error); | 511 EXPECT_EQ(HTTP_SUCCESS, error); |
512 ASSERT_TRUE(resource_list); | 512 ASSERT_TRUE(resource_list); |
513 | 513 |
514 EXPECT_EQ(2U, resource_list->entries().size()); | 514 EXPECT_EQ(2U, resource_list->entries().size()); |
515 EXPECT_EQ(1, fake_service_.resource_list_load_count()); | 515 EXPECT_EQ(1, fake_service_.resource_list_load_count()); |
516 } | 516 } |
517 | 517 |
518 TEST_F(FakeDriveServiceTest, | 518 TEST_F(FakeDriveServiceTest, |
519 ContinueGetResourceList_GetResourceListInDirectory) { | 519 ContinueGetResourceList_GetResourceListInDirectory) { |
520 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 520 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
521 "chromeos/gdata/root_feed.json")); | 521 "gdata/root_feed.json")); |
522 fake_service_.set_default_max_results(3); | 522 fake_service_.set_default_max_results(3); |
523 | 523 |
524 GDataErrorCode error = GDATA_OTHER_ERROR; | 524 GDataErrorCode error = GDATA_OTHER_ERROR; |
525 scoped_ptr<ResourceList> resource_list; | 525 scoped_ptr<ResourceList> resource_list; |
526 fake_service_.GetResourceListInDirectory( | 526 fake_service_.GetResourceListInDirectory( |
527 fake_service_.GetRootResourceId(), | 527 fake_service_.GetRootResourceId(), |
528 test_util::CreateCopyResultCallback(&error, &resource_list)); | 528 test_util::CreateCopyResultCallback(&error, &resource_list)); |
529 base::RunLoop().RunUntilIdle(); | 529 base::RunLoop().RunUntilIdle(); |
530 EXPECT_EQ(HTTP_SUCCESS, error); | 530 EXPECT_EQ(HTTP_SUCCESS, error); |
531 ASSERT_TRUE(resource_list); | 531 ASSERT_TRUE(resource_list); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
570 | 570 |
571 EXPECT_EQ(HTTP_SUCCESS, error); | 571 EXPECT_EQ(HTTP_SUCCESS, error); |
572 ASSERT_TRUE(resource_list); | 572 ASSERT_TRUE(resource_list); |
573 | 573 |
574 EXPECT_EQ(2U, resource_list->entries().size()); | 574 EXPECT_EQ(2U, resource_list->entries().size()); |
575 EXPECT_EQ(1, fake_service_.directory_load_count()); | 575 EXPECT_EQ(1, fake_service_.directory_load_count()); |
576 } | 576 } |
577 | 577 |
578 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_Search) { | 578 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_Search) { |
579 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 579 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
580 "chromeos/gdata/root_feed.json")); | 580 "gdata/root_feed.json")); |
581 fake_service_.set_default_max_results(2); | 581 fake_service_.set_default_max_results(2); |
582 | 582 |
583 GDataErrorCode error = GDATA_OTHER_ERROR; | 583 GDataErrorCode error = GDATA_OTHER_ERROR; |
584 scoped_ptr<ResourceList> resource_list; | 584 scoped_ptr<ResourceList> resource_list; |
585 fake_service_.Search( | 585 fake_service_.Search( |
586 "File", // search_query | 586 "File", // search_query |
587 test_util::CreateCopyResultCallback(&error, &resource_list)); | 587 test_util::CreateCopyResultCallback(&error, &resource_list)); |
588 base::RunLoop().RunUntilIdle(); | 588 base::RunLoop().RunUntilIdle(); |
589 EXPECT_EQ(HTTP_SUCCESS, error); | 589 EXPECT_EQ(HTTP_SUCCESS, error); |
590 ASSERT_TRUE(resource_list); | 590 ASSERT_TRUE(resource_list); |
(...skipping 18 matching lines...) Expand all Loading... |
609 base::RunLoop().RunUntilIdle(); | 609 base::RunLoop().RunUntilIdle(); |
610 | 610 |
611 EXPECT_EQ(HTTP_SUCCESS, error); | 611 EXPECT_EQ(HTTP_SUCCESS, error); |
612 ASSERT_TRUE(resource_list); | 612 ASSERT_TRUE(resource_list); |
613 | 613 |
614 EXPECT_EQ(2U, resource_list->entries().size()); | 614 EXPECT_EQ(2U, resource_list->entries().size()); |
615 } | 615 } |
616 | 616 |
617 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_GetChangeList) { | 617 TEST_F(FakeDriveServiceTest, ContinueGetResourceList_GetChangeList) { |
618 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 618 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
619 "chromeos/gdata/root_feed.json")); | 619 "gdata/root_feed.json")); |
620 fake_service_.set_default_max_results(2); | 620 fake_service_.set_default_max_results(2); |
621 | 621 |
622 // Load the account_metadata.json as well to add the largest changestamp | 622 // Load the account_metadata.json as well to add the largest changestamp |
623 // (654321) to the existing entries. | 623 // (654321) to the existing entries. |
624 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 624 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
625 "chromeos/gdata/account_metadata.json")); | 625 "gdata/account_metadata.json")); |
626 // Add 5 new directory in the root directory. The new directory will have | 626 // Add 5 new directory in the root directory. The new directory will have |
627 // the changestamp of 654326. | 627 // the changestamp of 654326. |
628 for (int i = 0; i < 5; ++i) { | 628 for (int i = 0; i < 5; ++i) { |
629 ASSERT_TRUE(AddNewDirectory( | 629 ASSERT_TRUE(AddNewDirectory( |
630 fake_service_.GetRootResourceId(), | 630 fake_service_.GetRootResourceId(), |
631 base::StringPrintf("new directory %d", i))); | 631 base::StringPrintf("new directory %d", i))); |
632 } | 632 } |
633 | 633 |
634 GDataErrorCode error = GDATA_OTHER_ERROR; | 634 GDataErrorCode error = GDATA_OTHER_ERROR; |
635 scoped_ptr<ResourceList> resource_list; | 635 scoped_ptr<ResourceList> resource_list; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
680 | 680 |
681 EXPECT_EQ(HTTP_SUCCESS, error); | 681 EXPECT_EQ(HTTP_SUCCESS, error); |
682 ASSERT_TRUE(resource_list); | 682 ASSERT_TRUE(resource_list); |
683 | 683 |
684 EXPECT_EQ(1U, resource_list->entries().size()); | 684 EXPECT_EQ(1U, resource_list->entries().size()); |
685 EXPECT_EQ(1, fake_service_.change_list_load_count()); | 685 EXPECT_EQ(1, fake_service_.change_list_load_count()); |
686 } | 686 } |
687 | 687 |
688 TEST_F(FakeDriveServiceTest, GetAboutResource) { | 688 TEST_F(FakeDriveServiceTest, GetAboutResource) { |
689 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 689 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
690 "chromeos/gdata/account_metadata.json")); | 690 "gdata/account_metadata.json")); |
691 | 691 |
692 GDataErrorCode error = GDATA_OTHER_ERROR; | 692 GDataErrorCode error = GDATA_OTHER_ERROR; |
693 scoped_ptr<AboutResource> about_resource; | 693 scoped_ptr<AboutResource> about_resource; |
694 fake_service_.GetAboutResource( | 694 fake_service_.GetAboutResource( |
695 test_util::CreateCopyResultCallback(&error, &about_resource)); | 695 test_util::CreateCopyResultCallback(&error, &about_resource)); |
696 base::RunLoop().RunUntilIdle(); | 696 base::RunLoop().RunUntilIdle(); |
697 | 697 |
698 EXPECT_EQ(HTTP_SUCCESS, error); | 698 EXPECT_EQ(HTTP_SUCCESS, error); |
699 | 699 |
700 ASSERT_TRUE(about_resource); | 700 ASSERT_TRUE(about_resource); |
701 // Do some sanity check. | 701 // Do some sanity check. |
702 EXPECT_EQ(fake_service_.GetRootResourceId(), | 702 EXPECT_EQ(fake_service_.GetRootResourceId(), |
703 about_resource->root_folder_id()); | 703 about_resource->root_folder_id()); |
704 EXPECT_EQ(1, fake_service_.about_resource_load_count()); | 704 EXPECT_EQ(1, fake_service_.about_resource_load_count()); |
705 } | 705 } |
706 | 706 |
707 TEST_F(FakeDriveServiceTest, GetAboutResource_Offline) { | 707 TEST_F(FakeDriveServiceTest, GetAboutResource_Offline) { |
708 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 708 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
709 "chromeos/gdata/account_metadata.json")); | 709 "gdata/account_metadata.json")); |
710 fake_service_.set_offline(true); | 710 fake_service_.set_offline(true); |
711 | 711 |
712 GDataErrorCode error = GDATA_OTHER_ERROR; | 712 GDataErrorCode error = GDATA_OTHER_ERROR; |
713 scoped_ptr<AboutResource> about_resource; | 713 scoped_ptr<AboutResource> about_resource; |
714 fake_service_.GetAboutResource( | 714 fake_service_.GetAboutResource( |
715 test_util::CreateCopyResultCallback(&error, &about_resource)); | 715 test_util::CreateCopyResultCallback(&error, &about_resource)); |
716 base::RunLoop().RunUntilIdle(); | 716 base::RunLoop().RunUntilIdle(); |
717 | 717 |
718 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 718 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
719 EXPECT_FALSE(about_resource); | 719 EXPECT_FALSE(about_resource); |
720 } | 720 } |
721 | 721 |
722 TEST_F(FakeDriveServiceTest, GetAppList) { | 722 TEST_F(FakeDriveServiceTest, GetAppList) { |
723 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( | 723 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( |
724 "chromeos/drive/applist.json")); | 724 "drive/applist.json")); |
725 | 725 |
726 GDataErrorCode error = GDATA_OTHER_ERROR; | 726 GDataErrorCode error = GDATA_OTHER_ERROR; |
727 scoped_ptr<AppList> app_list; | 727 scoped_ptr<AppList> app_list; |
728 fake_service_.GetAppList( | 728 fake_service_.GetAppList( |
729 test_util::CreateCopyResultCallback(&error, &app_list)); | 729 test_util::CreateCopyResultCallback(&error, &app_list)); |
730 base::RunLoop().RunUntilIdle(); | 730 base::RunLoop().RunUntilIdle(); |
731 | 731 |
732 EXPECT_EQ(HTTP_SUCCESS, error); | 732 EXPECT_EQ(HTTP_SUCCESS, error); |
733 | 733 |
734 ASSERT_TRUE(app_list); | 734 ASSERT_TRUE(app_list); |
735 } | 735 } |
736 | 736 |
737 TEST_F(FakeDriveServiceTest, GetAppList_Offline) { | 737 TEST_F(FakeDriveServiceTest, GetAppList_Offline) { |
738 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( | 738 ASSERT_TRUE(fake_service_.LoadAppListForDriveApi( |
739 "chromeos/drive/applist.json")); | 739 "drive/applist.json")); |
740 fake_service_.set_offline(true); | 740 fake_service_.set_offline(true); |
741 | 741 |
742 GDataErrorCode error = GDATA_OTHER_ERROR; | 742 GDataErrorCode error = GDATA_OTHER_ERROR; |
743 scoped_ptr<AppList> app_list; | 743 scoped_ptr<AppList> app_list; |
744 fake_service_.GetAppList( | 744 fake_service_.GetAppList( |
745 test_util::CreateCopyResultCallback(&error, &app_list)); | 745 test_util::CreateCopyResultCallback(&error, &app_list)); |
746 base::RunLoop().RunUntilIdle(); | 746 base::RunLoop().RunUntilIdle(); |
747 | 747 |
748 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 748 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
749 EXPECT_FALSE(app_list); | 749 EXPECT_FALSE(app_list); |
750 } | 750 } |
751 | 751 |
752 TEST_F(FakeDriveServiceTest, GetResourceEntry_ExistingFile) { | 752 TEST_F(FakeDriveServiceTest, GetResourceEntry_ExistingFile) { |
753 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 753 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
754 "chromeos/gdata/root_feed.json")); | 754 "gdata/root_feed.json")); |
755 | 755 |
756 const std::string kResourceId = "file:2_file_resource_id"; | 756 const std::string kResourceId = "file:2_file_resource_id"; |
757 GDataErrorCode error = GDATA_OTHER_ERROR; | 757 GDataErrorCode error = GDATA_OTHER_ERROR; |
758 scoped_ptr<ResourceEntry> resource_entry; | 758 scoped_ptr<ResourceEntry> resource_entry; |
759 fake_service_.GetResourceEntry( | 759 fake_service_.GetResourceEntry( |
760 kResourceId, | 760 kResourceId, |
761 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 761 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
762 base::RunLoop().RunUntilIdle(); | 762 base::RunLoop().RunUntilIdle(); |
763 | 763 |
764 EXPECT_EQ(HTTP_SUCCESS, error); | 764 EXPECT_EQ(HTTP_SUCCESS, error); |
765 ASSERT_TRUE(resource_entry); | 765 ASSERT_TRUE(resource_entry); |
766 // Do some sanity check. | 766 // Do some sanity check. |
767 EXPECT_EQ(kResourceId, resource_entry->resource_id()); | 767 EXPECT_EQ(kResourceId, resource_entry->resource_id()); |
768 } | 768 } |
769 | 769 |
770 TEST_F(FakeDriveServiceTest, GetResourceEntry_NonexistingFile) { | 770 TEST_F(FakeDriveServiceTest, GetResourceEntry_NonexistingFile) { |
771 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 771 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
772 "chromeos/gdata/root_feed.json")); | 772 "gdata/root_feed.json")); |
773 | 773 |
774 const std::string kResourceId = "file:nonexisting_resource_id"; | 774 const std::string kResourceId = "file:nonexisting_resource_id"; |
775 GDataErrorCode error = GDATA_OTHER_ERROR; | 775 GDataErrorCode error = GDATA_OTHER_ERROR; |
776 scoped_ptr<ResourceEntry> resource_entry; | 776 scoped_ptr<ResourceEntry> resource_entry; |
777 fake_service_.GetResourceEntry( | 777 fake_service_.GetResourceEntry( |
778 kResourceId, | 778 kResourceId, |
779 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 779 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
780 base::RunLoop().RunUntilIdle(); | 780 base::RunLoop().RunUntilIdle(); |
781 | 781 |
782 EXPECT_EQ(HTTP_NOT_FOUND, error); | 782 EXPECT_EQ(HTTP_NOT_FOUND, error); |
783 ASSERT_FALSE(resource_entry); | 783 ASSERT_FALSE(resource_entry); |
784 } | 784 } |
785 | 785 |
786 TEST_F(FakeDriveServiceTest, GetResourceEntry_Offline) { | 786 TEST_F(FakeDriveServiceTest, GetResourceEntry_Offline) { |
787 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 787 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
788 "chromeos/gdata/root_feed.json")); | 788 "gdata/root_feed.json")); |
789 fake_service_.set_offline(true); | 789 fake_service_.set_offline(true); |
790 | 790 |
791 const std::string kResourceId = "file:2_file_resource_id"; | 791 const std::string kResourceId = "file:2_file_resource_id"; |
792 GDataErrorCode error = GDATA_OTHER_ERROR; | 792 GDataErrorCode error = GDATA_OTHER_ERROR; |
793 scoped_ptr<ResourceEntry> resource_entry; | 793 scoped_ptr<ResourceEntry> resource_entry; |
794 fake_service_.GetResourceEntry( | 794 fake_service_.GetResourceEntry( |
795 kResourceId, | 795 kResourceId, |
796 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 796 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
797 base::RunLoop().RunUntilIdle(); | 797 base::RunLoop().RunUntilIdle(); |
798 | 798 |
799 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 799 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
800 EXPECT_FALSE(resource_entry); | 800 EXPECT_FALSE(resource_entry); |
801 } | 801 } |
802 | 802 |
803 TEST_F(FakeDriveServiceTest, DeleteResource_ExistingFile) { | 803 TEST_F(FakeDriveServiceTest, DeleteResource_ExistingFile) { |
804 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 804 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
805 "chromeos/gdata/root_feed.json")); | 805 "gdata/root_feed.json")); |
806 | 806 |
807 // Resource "file:2_file_resource_id" should now exist. | 807 // Resource "file:2_file_resource_id" should now exist. |
808 ASSERT_TRUE(Exists("file:2_file_resource_id")); | 808 ASSERT_TRUE(Exists("file:2_file_resource_id")); |
809 | 809 |
810 GDataErrorCode error = GDATA_OTHER_ERROR; | 810 GDataErrorCode error = GDATA_OTHER_ERROR; |
811 fake_service_.DeleteResource("file:2_file_resource_id", | 811 fake_service_.DeleteResource("file:2_file_resource_id", |
812 std::string(), // etag | 812 std::string(), // etag |
813 test_util::CreateCopyResultCallback(&error)); | 813 test_util::CreateCopyResultCallback(&error)); |
814 base::RunLoop().RunUntilIdle(); | 814 base::RunLoop().RunUntilIdle(); |
815 | 815 |
816 EXPECT_EQ(HTTP_SUCCESS, error); | 816 EXPECT_EQ(HTTP_SUCCESS, error); |
817 // Resource "file:2_file_resource_id" should be gone now. | 817 // Resource "file:2_file_resource_id" should be gone now. |
818 EXPECT_FALSE(Exists("file:2_file_resource_id")); | 818 EXPECT_FALSE(Exists("file:2_file_resource_id")); |
819 | 819 |
820 error = GDATA_OTHER_ERROR; | 820 error = GDATA_OTHER_ERROR; |
821 fake_service_.DeleteResource("file:2_file_resource_id", | 821 fake_service_.DeleteResource("file:2_file_resource_id", |
822 std::string(), // etag | 822 std::string(), // etag |
823 test_util::CreateCopyResultCallback(&error)); | 823 test_util::CreateCopyResultCallback(&error)); |
824 base::RunLoop().RunUntilIdle(); | 824 base::RunLoop().RunUntilIdle(); |
825 EXPECT_EQ(HTTP_NOT_FOUND, error); | 825 EXPECT_EQ(HTTP_NOT_FOUND, error); |
826 EXPECT_FALSE(Exists("file:2_file_resource_id")); | 826 EXPECT_FALSE(Exists("file:2_file_resource_id")); |
827 } | 827 } |
828 | 828 |
829 TEST_F(FakeDriveServiceTest, DeleteResource_NonexistingFile) { | 829 TEST_F(FakeDriveServiceTest, DeleteResource_NonexistingFile) { |
830 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 830 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
831 "chromeos/gdata/root_feed.json")); | 831 "gdata/root_feed.json")); |
832 | 832 |
833 GDataErrorCode error = GDATA_OTHER_ERROR; | 833 GDataErrorCode error = GDATA_OTHER_ERROR; |
834 fake_service_.DeleteResource("file:nonexisting_resource_id", | 834 fake_service_.DeleteResource("file:nonexisting_resource_id", |
835 std::string(), // etag | 835 std::string(), // etag |
836 test_util::CreateCopyResultCallback(&error)); | 836 test_util::CreateCopyResultCallback(&error)); |
837 base::RunLoop().RunUntilIdle(); | 837 base::RunLoop().RunUntilIdle(); |
838 | 838 |
839 EXPECT_EQ(HTTP_NOT_FOUND, error); | 839 EXPECT_EQ(HTTP_NOT_FOUND, error); |
840 } | 840 } |
841 | 841 |
842 TEST_F(FakeDriveServiceTest, DeleteResource_Offline) { | 842 TEST_F(FakeDriveServiceTest, DeleteResource_Offline) { |
843 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 843 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
844 "chromeos/gdata/root_feed.json")); | 844 "gdata/root_feed.json")); |
845 fake_service_.set_offline(true); | 845 fake_service_.set_offline(true); |
846 | 846 |
847 GDataErrorCode error = GDATA_OTHER_ERROR; | 847 GDataErrorCode error = GDATA_OTHER_ERROR; |
848 fake_service_.DeleteResource("file:2_file_resource_id", | 848 fake_service_.DeleteResource("file:2_file_resource_id", |
849 std::string(), // etag | 849 std::string(), // etag |
850 test_util::CreateCopyResultCallback(&error)); | 850 test_util::CreateCopyResultCallback(&error)); |
851 base::RunLoop().RunUntilIdle(); | 851 base::RunLoop().RunUntilIdle(); |
852 | 852 |
853 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 853 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
854 } | 854 } |
855 | 855 |
856 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) { | 856 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) { |
857 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 857 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
858 "chromeos/gdata/root_feed.json")); | 858 "gdata/root_feed.json")); |
859 | 859 |
860 base::ScopedTempDir temp_dir; | 860 base::ScopedTempDir temp_dir; |
861 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 861 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
862 | 862 |
863 std::vector<test_util::ProgressInfo> download_progress_values; | 863 std::vector<test_util::ProgressInfo> download_progress_values; |
864 | 864 |
865 const GURL kContentUrl("https://file_content_url/"); | 865 const GURL kContentUrl("https://file_content_url/"); |
866 const base::FilePath kOutputFilePath = | 866 const base::FilePath kOutputFilePath = |
867 temp_dir.path().AppendASCII("whatever.txt"); | 867 temp_dir.path().AppendASCII("whatever.txt"); |
868 GDataErrorCode error = GDATA_OTHER_ERROR; | 868 GDataErrorCode error = GDATA_OTHER_ERROR; |
(...skipping 16 matching lines...) Expand all Loading... |
885 EXPECT_EQ("This is some test content.", content); | 885 EXPECT_EQ("This is some test content.", content); |
886 ASSERT_TRUE(!download_progress_values.empty()); | 886 ASSERT_TRUE(!download_progress_values.empty()); |
887 EXPECT_TRUE(base::STLIsSorted(download_progress_values)); | 887 EXPECT_TRUE(base::STLIsSorted(download_progress_values)); |
888 EXPECT_LE(0, download_progress_values.front().first); | 888 EXPECT_LE(0, download_progress_values.front().first); |
889 EXPECT_GE(26, download_progress_values.back().first); | 889 EXPECT_GE(26, download_progress_values.back().first); |
890 EXPECT_EQ(content, get_content_callback.GetConcatenatedData()); | 890 EXPECT_EQ(content, get_content_callback.GetConcatenatedData()); |
891 } | 891 } |
892 | 892 |
893 TEST_F(FakeDriveServiceTest, DownloadFile_NonexistingFile) { | 893 TEST_F(FakeDriveServiceTest, DownloadFile_NonexistingFile) { |
894 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 894 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
895 "chromeos/gdata/root_feed.json")); | 895 "gdata/root_feed.json")); |
896 | 896 |
897 base::ScopedTempDir temp_dir; | 897 base::ScopedTempDir temp_dir; |
898 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 898 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
899 | 899 |
900 const GURL kContentUrl("https://non_existing_content_url/"); | 900 const GURL kContentUrl("https://non_existing_content_url/"); |
901 const base::FilePath kOutputFilePath = | 901 const base::FilePath kOutputFilePath = |
902 temp_dir.path().AppendASCII("whatever.txt"); | 902 temp_dir.path().AppendASCII("whatever.txt"); |
903 GDataErrorCode error = GDATA_OTHER_ERROR; | 903 GDataErrorCode error = GDATA_OTHER_ERROR; |
904 base::FilePath output_file_path; | 904 base::FilePath output_file_path; |
905 fake_service_.DownloadFile( | 905 fake_service_.DownloadFile( |
906 kOutputFilePath, | 906 kOutputFilePath, |
907 kContentUrl, | 907 kContentUrl, |
908 test_util::CreateCopyResultCallback(&error, &output_file_path), | 908 test_util::CreateCopyResultCallback(&error, &output_file_path), |
909 GetContentCallback(), | 909 GetContentCallback(), |
910 ProgressCallback()); | 910 ProgressCallback()); |
911 base::RunLoop().RunUntilIdle(); | 911 base::RunLoop().RunUntilIdle(); |
912 | 912 |
913 EXPECT_EQ(HTTP_NOT_FOUND, error); | 913 EXPECT_EQ(HTTP_NOT_FOUND, error); |
914 } | 914 } |
915 | 915 |
916 TEST_F(FakeDriveServiceTest, DownloadFile_Offline) { | 916 TEST_F(FakeDriveServiceTest, DownloadFile_Offline) { |
917 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 917 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
918 "chromeos/gdata/root_feed.json")); | 918 "gdata/root_feed.json")); |
919 fake_service_.set_offline(true); | 919 fake_service_.set_offline(true); |
920 | 920 |
921 base::ScopedTempDir temp_dir; | 921 base::ScopedTempDir temp_dir; |
922 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 922 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
923 | 923 |
924 const GURL kContentUrl("https://file_content_url/"); | 924 const GURL kContentUrl("https://file_content_url/"); |
925 const base::FilePath kOutputFilePath = | 925 const base::FilePath kOutputFilePath = |
926 temp_dir.path().AppendASCII("whatever.txt"); | 926 temp_dir.path().AppendASCII("whatever.txt"); |
927 GDataErrorCode error = GDATA_OTHER_ERROR; | 927 GDataErrorCode error = GDATA_OTHER_ERROR; |
928 base::FilePath output_file_path; | 928 base::FilePath output_file_path; |
929 fake_service_.DownloadFile( | 929 fake_service_.DownloadFile( |
930 kOutputFilePath, | 930 kOutputFilePath, |
931 kContentUrl, | 931 kContentUrl, |
932 test_util::CreateCopyResultCallback(&error, &output_file_path), | 932 test_util::CreateCopyResultCallback(&error, &output_file_path), |
933 GetContentCallback(), | 933 GetContentCallback(), |
934 ProgressCallback()); | 934 ProgressCallback()); |
935 base::RunLoop().RunUntilIdle(); | 935 base::RunLoop().RunUntilIdle(); |
936 | 936 |
937 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 937 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
938 } | 938 } |
939 | 939 |
940 TEST_F(FakeDriveServiceTest, CopyResource) { | 940 TEST_F(FakeDriveServiceTest, CopyResource) { |
941 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 941 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
942 "chromeos/gdata/root_feed.json")); | 942 "gdata/root_feed.json")); |
943 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 943 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
944 "chromeos/gdata/account_metadata.json")); | 944 "gdata/account_metadata.json")); |
945 | 945 |
946 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 946 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
947 | 947 |
948 const std::string kResourceId = "file:2_file_resource_id"; | 948 const std::string kResourceId = "file:2_file_resource_id"; |
949 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 949 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
950 GDataErrorCode error = GDATA_OTHER_ERROR; | 950 GDataErrorCode error = GDATA_OTHER_ERROR; |
951 scoped_ptr<ResourceEntry> resource_entry; | 951 scoped_ptr<ResourceEntry> resource_entry; |
952 fake_service_.CopyResource( | 952 fake_service_.CopyResource( |
953 kResourceId, | 953 kResourceId, |
954 kParentResourceId, | 954 kParentResourceId, |
955 "new name", | 955 "new name", |
956 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 956 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
957 base::RunLoop().RunUntilIdle(); | 957 base::RunLoop().RunUntilIdle(); |
958 | 958 |
959 EXPECT_EQ(HTTP_SUCCESS, error); | 959 EXPECT_EQ(HTTP_SUCCESS, error); |
960 ASSERT_TRUE(resource_entry); | 960 ASSERT_TRUE(resource_entry); |
961 // The copied entry should have the new resource ID and the title. | 961 // The copied entry should have the new resource ID and the title. |
962 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); | 962 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); |
963 EXPECT_EQ("new name", resource_entry->title()); | 963 EXPECT_EQ("new name", resource_entry->title()); |
964 EXPECT_TRUE(HasParent(kResourceId, kParentResourceId)); | 964 EXPECT_TRUE(HasParent(kResourceId, kParentResourceId)); |
965 // Should be incremented as a new hosted document was created. | 965 // Should be incremented as a new hosted document was created. |
966 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 966 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
967 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 967 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
968 } | 968 } |
969 | 969 |
970 TEST_F(FakeDriveServiceTest, CopyResource_NonExisting) { | 970 TEST_F(FakeDriveServiceTest, CopyResource_NonExisting) { |
971 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 971 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
972 "chromeos/gdata/root_feed.json")); | 972 "gdata/root_feed.json")); |
973 | 973 |
974 const std::string kResourceId = "document:nonexisting_resource_id"; | 974 const std::string kResourceId = "document:nonexisting_resource_id"; |
975 GDataErrorCode error = GDATA_OTHER_ERROR; | 975 GDataErrorCode error = GDATA_OTHER_ERROR; |
976 scoped_ptr<ResourceEntry> resource_entry; | 976 scoped_ptr<ResourceEntry> resource_entry; |
977 fake_service_.CopyResource( | 977 fake_service_.CopyResource( |
978 kResourceId, | 978 kResourceId, |
979 "folder:1_folder_resource_id", | 979 "folder:1_folder_resource_id", |
980 "new name", | 980 "new name", |
981 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 981 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
982 base::RunLoop().RunUntilIdle(); | 982 base::RunLoop().RunUntilIdle(); |
983 | 983 |
984 EXPECT_EQ(HTTP_NOT_FOUND, error); | 984 EXPECT_EQ(HTTP_NOT_FOUND, error); |
985 } | 985 } |
986 | 986 |
987 TEST_F(FakeDriveServiceTest, CopyResource_EmptyParentResourceId) { | 987 TEST_F(FakeDriveServiceTest, CopyResource_EmptyParentResourceId) { |
988 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 988 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
989 "chromeos/gdata/root_feed.json")); | 989 "gdata/root_feed.json")); |
990 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 990 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
991 "chromeos/gdata/account_metadata.json")); | 991 "gdata/account_metadata.json")); |
992 | 992 |
993 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 993 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
994 | 994 |
995 const std::string kResourceId = "file:2_file_resource_id"; | 995 const std::string kResourceId = "file:2_file_resource_id"; |
996 GDataErrorCode error = GDATA_OTHER_ERROR; | 996 GDataErrorCode error = GDATA_OTHER_ERROR; |
997 scoped_ptr<ResourceEntry> resource_entry; | 997 scoped_ptr<ResourceEntry> resource_entry; |
998 fake_service_.CopyResource( | 998 fake_service_.CopyResource( |
999 kResourceId, | 999 kResourceId, |
1000 std::string(), | 1000 std::string(), |
1001 "new name", | 1001 "new name", |
1002 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1002 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1003 base::RunLoop().RunUntilIdle(); | 1003 base::RunLoop().RunUntilIdle(); |
1004 | 1004 |
1005 EXPECT_EQ(HTTP_SUCCESS, error); | 1005 EXPECT_EQ(HTTP_SUCCESS, error); |
1006 ASSERT_TRUE(resource_entry); | 1006 ASSERT_TRUE(resource_entry); |
1007 // The copied entry should have the new resource ID and the title. | 1007 // The copied entry should have the new resource ID and the title. |
1008 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); | 1008 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); |
1009 EXPECT_EQ("new name", resource_entry->title()); | 1009 EXPECT_EQ("new name", resource_entry->title()); |
1010 EXPECT_TRUE(HasParent(kResourceId, fake_service_.GetRootResourceId())); | 1010 EXPECT_TRUE(HasParent(kResourceId, fake_service_.GetRootResourceId())); |
1011 // Should be incremented as a new hosted document was created. | 1011 // Should be incremented as a new hosted document was created. |
1012 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1012 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1013 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1013 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1014 } | 1014 } |
1015 | 1015 |
1016 TEST_F(FakeDriveServiceTest, CopyResource_Offline) { | 1016 TEST_F(FakeDriveServiceTest, CopyResource_Offline) { |
1017 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1017 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1018 "chromeos/gdata/root_feed.json")); | 1018 "gdata/root_feed.json")); |
1019 fake_service_.set_offline(true); | 1019 fake_service_.set_offline(true); |
1020 | 1020 |
1021 const std::string kResourceId = "file:2_file_resource_id"; | 1021 const std::string kResourceId = "file:2_file_resource_id"; |
1022 GDataErrorCode error = GDATA_OTHER_ERROR; | 1022 GDataErrorCode error = GDATA_OTHER_ERROR; |
1023 scoped_ptr<ResourceEntry> resource_entry; | 1023 scoped_ptr<ResourceEntry> resource_entry; |
1024 fake_service_.CopyResource( | 1024 fake_service_.CopyResource( |
1025 kResourceId, | 1025 kResourceId, |
1026 "folder:1_folder_resource_id", | 1026 "folder:1_folder_resource_id", |
1027 "new name", | 1027 "new name", |
1028 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1028 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1029 base::RunLoop().RunUntilIdle(); | 1029 base::RunLoop().RunUntilIdle(); |
1030 | 1030 |
1031 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1031 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1032 EXPECT_FALSE(resource_entry); | 1032 EXPECT_FALSE(resource_entry); |
1033 } | 1033 } |
1034 | 1034 |
1035 TEST_F(FakeDriveServiceTest, CopyHostedDocument_Existing) { | 1035 TEST_F(FakeDriveServiceTest, CopyHostedDocument_Existing) { |
1036 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1036 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1037 "chromeos/gdata/root_feed.json")); | 1037 "gdata/root_feed.json")); |
1038 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1038 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1039 "chromeos/gdata/account_metadata.json")); | 1039 "gdata/account_metadata.json")); |
1040 | 1040 |
1041 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1041 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1042 | 1042 |
1043 const std::string kResourceId = "document:5_document_resource_id"; | 1043 const std::string kResourceId = "document:5_document_resource_id"; |
1044 GDataErrorCode error = GDATA_OTHER_ERROR; | 1044 GDataErrorCode error = GDATA_OTHER_ERROR; |
1045 scoped_ptr<ResourceEntry> resource_entry; | 1045 scoped_ptr<ResourceEntry> resource_entry; |
1046 fake_service_.CopyHostedDocument( | 1046 fake_service_.CopyHostedDocument( |
1047 kResourceId, | 1047 kResourceId, |
1048 "new name", | 1048 "new name", |
1049 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1049 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1050 base::RunLoop().RunUntilIdle(); | 1050 base::RunLoop().RunUntilIdle(); |
1051 | 1051 |
1052 EXPECT_EQ(HTTP_SUCCESS, error); | 1052 EXPECT_EQ(HTTP_SUCCESS, error); |
1053 ASSERT_TRUE(resource_entry); | 1053 ASSERT_TRUE(resource_entry); |
1054 // The copied entry should have the new resource ID and the title. | 1054 // The copied entry should have the new resource ID and the title. |
1055 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); | 1055 EXPECT_EQ(kResourceId + "_copied", resource_entry->resource_id()); |
1056 EXPECT_EQ("new name", resource_entry->title()); | 1056 EXPECT_EQ("new name", resource_entry->title()); |
1057 // Should be incremented as a new hosted document was created. | 1057 // Should be incremented as a new hosted document was created. |
1058 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1058 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1059 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1059 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1060 } | 1060 } |
1061 | 1061 |
1062 TEST_F(FakeDriveServiceTest, CopyHostedDocument_NonExisting) { | 1062 TEST_F(FakeDriveServiceTest, CopyHostedDocument_NonExisting) { |
1063 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1063 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1064 "chromeos/gdata/root_feed.json")); | 1064 "gdata/root_feed.json")); |
1065 | 1065 |
1066 const std::string kResourceId = "document:nonexisting_resource_id"; | 1066 const std::string kResourceId = "document:nonexisting_resource_id"; |
1067 GDataErrorCode error = GDATA_OTHER_ERROR; | 1067 GDataErrorCode error = GDATA_OTHER_ERROR; |
1068 scoped_ptr<ResourceEntry> resource_entry; | 1068 scoped_ptr<ResourceEntry> resource_entry; |
1069 fake_service_.CopyHostedDocument( | 1069 fake_service_.CopyHostedDocument( |
1070 kResourceId, | 1070 kResourceId, |
1071 "new name", | 1071 "new name", |
1072 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1072 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1073 base::RunLoop().RunUntilIdle(); | 1073 base::RunLoop().RunUntilIdle(); |
1074 | 1074 |
1075 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1075 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1076 } | 1076 } |
1077 | 1077 |
1078 TEST_F(FakeDriveServiceTest, CopyHostedDocument_Offline) { | 1078 TEST_F(FakeDriveServiceTest, CopyHostedDocument_Offline) { |
1079 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1079 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1080 "chromeos/gdata/root_feed.json")); | 1080 "gdata/root_feed.json")); |
1081 fake_service_.set_offline(true); | 1081 fake_service_.set_offline(true); |
1082 | 1082 |
1083 const std::string kResourceId = "document:5_document_resource_id"; | 1083 const std::string kResourceId = "document:5_document_resource_id"; |
1084 GDataErrorCode error = GDATA_OTHER_ERROR; | 1084 GDataErrorCode error = GDATA_OTHER_ERROR; |
1085 scoped_ptr<ResourceEntry> resource_entry; | 1085 scoped_ptr<ResourceEntry> resource_entry; |
1086 fake_service_.CopyHostedDocument( | 1086 fake_service_.CopyHostedDocument( |
1087 kResourceId, | 1087 kResourceId, |
1088 "new name", | 1088 "new name", |
1089 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1089 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1090 base::RunLoop().RunUntilIdle(); | 1090 base::RunLoop().RunUntilIdle(); |
1091 | 1091 |
1092 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1092 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1093 EXPECT_FALSE(resource_entry); | 1093 EXPECT_FALSE(resource_entry); |
1094 } | 1094 } |
1095 | 1095 |
1096 TEST_F(FakeDriveServiceTest, RenameResource_ExistingFile) { | 1096 TEST_F(FakeDriveServiceTest, RenameResource_ExistingFile) { |
1097 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1097 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1098 "chromeos/gdata/root_feed.json")); | 1098 "gdata/root_feed.json")); |
1099 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1099 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1100 "chromeos/gdata/account_metadata.json")); | 1100 "gdata/account_metadata.json")); |
1101 | 1101 |
1102 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1102 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1103 | 1103 |
1104 const std::string kResourceId = "file:2_file_resource_id"; | 1104 const std::string kResourceId = "file:2_file_resource_id"; |
1105 | 1105 |
1106 GDataErrorCode error = GDATA_OTHER_ERROR; | 1106 GDataErrorCode error = GDATA_OTHER_ERROR; |
1107 fake_service_.RenameResource(kResourceId, | 1107 fake_service_.RenameResource(kResourceId, |
1108 "new name", | 1108 "new name", |
1109 test_util::CreateCopyResultCallback(&error)); | 1109 test_util::CreateCopyResultCallback(&error)); |
1110 base::RunLoop().RunUntilIdle(); | 1110 base::RunLoop().RunUntilIdle(); |
1111 | 1111 |
1112 EXPECT_EQ(HTTP_SUCCESS, error); | 1112 EXPECT_EQ(HTTP_SUCCESS, error); |
1113 | 1113 |
1114 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); | 1114 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); |
1115 ASSERT_TRUE(resource_entry); | 1115 ASSERT_TRUE(resource_entry); |
1116 EXPECT_EQ("new name", resource_entry->title()); | 1116 EXPECT_EQ("new name", resource_entry->title()); |
1117 // Should be incremented as a file was renamed. | 1117 // Should be incremented as a file was renamed. |
1118 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1118 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1119 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1119 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1120 } | 1120 } |
1121 | 1121 |
1122 TEST_F(FakeDriveServiceTest, RenameResource_NonexistingFile) { | 1122 TEST_F(FakeDriveServiceTest, RenameResource_NonexistingFile) { |
1123 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1123 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1124 "chromeos/gdata/root_feed.json")); | 1124 "gdata/root_feed.json")); |
1125 | 1125 |
1126 const std::string kResourceId = "file:nonexisting_file"; | 1126 const std::string kResourceId = "file:nonexisting_file"; |
1127 | 1127 |
1128 GDataErrorCode error = GDATA_OTHER_ERROR; | 1128 GDataErrorCode error = GDATA_OTHER_ERROR; |
1129 fake_service_.RenameResource(kResourceId, | 1129 fake_service_.RenameResource(kResourceId, |
1130 "new name", | 1130 "new name", |
1131 test_util::CreateCopyResultCallback(&error)); | 1131 test_util::CreateCopyResultCallback(&error)); |
1132 base::RunLoop().RunUntilIdle(); | 1132 base::RunLoop().RunUntilIdle(); |
1133 | 1133 |
1134 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1134 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1135 } | 1135 } |
1136 | 1136 |
1137 TEST_F(FakeDriveServiceTest, RenameResource_Offline) { | 1137 TEST_F(FakeDriveServiceTest, RenameResource_Offline) { |
1138 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1138 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1139 "chromeos/gdata/root_feed.json")); | 1139 "gdata/root_feed.json")); |
1140 fake_service_.set_offline(true); | 1140 fake_service_.set_offline(true); |
1141 | 1141 |
1142 const std::string kResourceId = "file:2_file_resource_id"; | 1142 const std::string kResourceId = "file:2_file_resource_id"; |
1143 | 1143 |
1144 GDataErrorCode error = GDATA_OTHER_ERROR; | 1144 GDataErrorCode error = GDATA_OTHER_ERROR; |
1145 fake_service_.RenameResource(kResourceId, | 1145 fake_service_.RenameResource(kResourceId, |
1146 "new name", | 1146 "new name", |
1147 test_util::CreateCopyResultCallback(&error)); | 1147 test_util::CreateCopyResultCallback(&error)); |
1148 base::RunLoop().RunUntilIdle(); | 1148 base::RunLoop().RunUntilIdle(); |
1149 | 1149 |
1150 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1150 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1151 } | 1151 } |
1152 | 1152 |
1153 TEST_F(FakeDriveServiceTest, TouchResource_ExistingFile) { | 1153 TEST_F(FakeDriveServiceTest, TouchResource_ExistingFile) { |
1154 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1154 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1155 "chromeos/gdata/root_feed.json")); | 1155 "gdata/root_feed.json")); |
1156 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1156 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1157 "chromeos/gdata/account_metadata.json")); | 1157 "gdata/account_metadata.json")); |
1158 | 1158 |
1159 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1159 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1160 | 1160 |
1161 const std::string kResourceId = "file:2_file_resource_id"; | 1161 const std::string kResourceId = "file:2_file_resource_id"; |
1162 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; | 1162 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; |
1163 const base::Time::Exploded kLastViewedByMeDate = | 1163 const base::Time::Exploded kLastViewedByMeDate = |
1164 {2013, 7, 0, 19, 15, 59, 13, 123}; | 1164 {2013, 7, 0, 19, 15, 59, 13, 123}; |
1165 | 1165 |
1166 GDataErrorCode error = GDATA_OTHER_ERROR; | 1166 GDataErrorCode error = GDATA_OTHER_ERROR; |
1167 scoped_ptr<ResourceEntry> entry; | 1167 scoped_ptr<ResourceEntry> entry; |
(...skipping 12 matching lines...) Expand all Loading... |
1180 EXPECT_EQ(base::Time::FromUTCExploded(kLastViewedByMeDate), | 1180 EXPECT_EQ(base::Time::FromUTCExploded(kLastViewedByMeDate), |
1181 entry->last_viewed_time()); | 1181 entry->last_viewed_time()); |
1182 | 1182 |
1183 // Should be incremented as a file was renamed. | 1183 // Should be incremented as a file was renamed. |
1184 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1184 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1185 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1185 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1186 } | 1186 } |
1187 | 1187 |
1188 TEST_F(FakeDriveServiceTest, TouchResource_NonexistingFile) { | 1188 TEST_F(FakeDriveServiceTest, TouchResource_NonexistingFile) { |
1189 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1189 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1190 "chromeos/gdata/root_feed.json")); | 1190 "gdata/root_feed.json")); |
1191 | 1191 |
1192 const std::string kResourceId = "file:nonexisting_file"; | 1192 const std::string kResourceId = "file:nonexisting_file"; |
1193 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; | 1193 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; |
1194 const base::Time::Exploded kLastViewedByMeDate = | 1194 const base::Time::Exploded kLastViewedByMeDate = |
1195 {2013, 7, 0, 19, 15, 59, 13, 123}; | 1195 {2013, 7, 0, 19, 15, 59, 13, 123}; |
1196 | 1196 |
1197 GDataErrorCode error = GDATA_OTHER_ERROR; | 1197 GDataErrorCode error = GDATA_OTHER_ERROR; |
1198 scoped_ptr<ResourceEntry> entry; | 1198 scoped_ptr<ResourceEntry> entry; |
1199 fake_service_.TouchResource( | 1199 fake_service_.TouchResource( |
1200 kResourceId, | 1200 kResourceId, |
1201 base::Time::FromUTCExploded(kModifiedDate), | 1201 base::Time::FromUTCExploded(kModifiedDate), |
1202 base::Time::FromUTCExploded(kLastViewedByMeDate), | 1202 base::Time::FromUTCExploded(kLastViewedByMeDate), |
1203 test_util::CreateCopyResultCallback(&error, &entry)); | 1203 test_util::CreateCopyResultCallback(&error, &entry)); |
1204 base::RunLoop().RunUntilIdle(); | 1204 base::RunLoop().RunUntilIdle(); |
1205 | 1205 |
1206 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1206 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1207 } | 1207 } |
1208 | 1208 |
1209 TEST_F(FakeDriveServiceTest, TouchResource_Offline) { | 1209 TEST_F(FakeDriveServiceTest, TouchResource_Offline) { |
1210 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1210 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1211 "chromeos/gdata/root_feed.json")); | 1211 "gdata/root_feed.json")); |
1212 fake_service_.set_offline(true); | 1212 fake_service_.set_offline(true); |
1213 | 1213 |
1214 const std::string kResourceId = "file:2_file_resource_id"; | 1214 const std::string kResourceId = "file:2_file_resource_id"; |
1215 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; | 1215 const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123}; |
1216 const base::Time::Exploded kLastViewedByMeDate = | 1216 const base::Time::Exploded kLastViewedByMeDate = |
1217 {2013, 7, 0, 19, 15, 59, 13, 123}; | 1217 {2013, 7, 0, 19, 15, 59, 13, 123}; |
1218 | 1218 |
1219 GDataErrorCode error = GDATA_OTHER_ERROR; | 1219 GDataErrorCode error = GDATA_OTHER_ERROR; |
1220 scoped_ptr<ResourceEntry> entry; | 1220 scoped_ptr<ResourceEntry> entry; |
1221 fake_service_.TouchResource( | 1221 fake_service_.TouchResource( |
1222 kResourceId, | 1222 kResourceId, |
1223 base::Time::FromUTCExploded(kModifiedDate), | 1223 base::Time::FromUTCExploded(kModifiedDate), |
1224 base::Time::FromUTCExploded(kLastViewedByMeDate), | 1224 base::Time::FromUTCExploded(kLastViewedByMeDate), |
1225 test_util::CreateCopyResultCallback(&error, &entry)); | 1225 test_util::CreateCopyResultCallback(&error, &entry)); |
1226 base::RunLoop().RunUntilIdle(); | 1226 base::RunLoop().RunUntilIdle(); |
1227 | 1227 |
1228 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1228 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1229 } | 1229 } |
1230 | 1230 |
1231 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) { | 1231 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) { |
1232 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1232 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1233 "chromeos/gdata/root_feed.json")); | 1233 "gdata/root_feed.json")); |
1234 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1234 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1235 "chromeos/gdata/account_metadata.json")); | 1235 "gdata/account_metadata.json")); |
1236 | 1236 |
1237 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1237 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1238 | 1238 |
1239 const std::string kResourceId = "file:2_file_resource_id"; | 1239 const std::string kResourceId = "file:2_file_resource_id"; |
1240 const std::string kOldParentResourceId = fake_service_.GetRootResourceId(); | 1240 const std::string kOldParentResourceId = fake_service_.GetRootResourceId(); |
1241 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; | 1241 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; |
1242 | 1242 |
1243 // Here's the original parent link. | 1243 // Here's the original parent link. |
1244 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); | 1244 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); |
1245 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); | 1245 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); |
(...skipping 10 matching lines...) Expand all Loading... |
1256 // The parent link should now be changed. | 1256 // The parent link should now be changed. |
1257 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); | 1257 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); |
1258 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); | 1258 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); |
1259 // Should be incremented as a file was moved. | 1259 // Should be incremented as a file was moved. |
1260 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1260 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1261 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1261 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1262 } | 1262 } |
1263 | 1263 |
1264 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInNonRootDirectory) { | 1264 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInNonRootDirectory) { |
1265 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1265 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1266 "chromeos/gdata/root_feed.json")); | 1266 "gdata/root_feed.json")); |
1267 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1267 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1268 "chromeos/gdata/account_metadata.json")); | 1268 "gdata/account_metadata.json")); |
1269 | 1269 |
1270 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1270 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1271 | 1271 |
1272 const std::string kResourceId = "file:subdirectory_file_1_id"; | 1272 const std::string kResourceId = "file:subdirectory_file_1_id"; |
1273 const std::string kOldParentResourceId = "folder:1_folder_resource_id"; | 1273 const std::string kOldParentResourceId = "folder:1_folder_resource_id"; |
1274 const std::string kNewParentResourceId = "folder:2_folder_resource_id"; | 1274 const std::string kNewParentResourceId = "folder:2_folder_resource_id"; |
1275 | 1275 |
1276 // Here's the original parent link. | 1276 // Here's the original parent link. |
1277 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); | 1277 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); |
1278 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); | 1278 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); |
(...skipping 10 matching lines...) Expand all Loading... |
1289 // The parent link should now be changed. | 1289 // The parent link should now be changed. |
1290 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); | 1290 EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId)); |
1291 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); | 1291 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); |
1292 // Should be incremented as a file was moved. | 1292 // Should be incremented as a file was moved. |
1293 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1293 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1294 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1294 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1295 } | 1295 } |
1296 | 1296 |
1297 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_NonexistingFile) { | 1297 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_NonexistingFile) { |
1298 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1298 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1299 "chromeos/gdata/root_feed.json")); | 1299 "gdata/root_feed.json")); |
1300 | 1300 |
1301 const std::string kResourceId = "file:nonexisting_file"; | 1301 const std::string kResourceId = "file:nonexisting_file"; |
1302 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; | 1302 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; |
1303 | 1303 |
1304 GDataErrorCode error = GDATA_OTHER_ERROR; | 1304 GDataErrorCode error = GDATA_OTHER_ERROR; |
1305 fake_service_.AddResourceToDirectory( | 1305 fake_service_.AddResourceToDirectory( |
1306 kNewParentResourceId, | 1306 kNewParentResourceId, |
1307 kResourceId, | 1307 kResourceId, |
1308 test_util::CreateCopyResultCallback(&error)); | 1308 test_util::CreateCopyResultCallback(&error)); |
1309 base::RunLoop().RunUntilIdle(); | 1309 base::RunLoop().RunUntilIdle(); |
1310 | 1310 |
1311 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1311 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1312 } | 1312 } |
1313 | 1313 |
1314 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_OrphanFile) { | 1314 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_OrphanFile) { |
1315 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1315 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1316 "chromeos/gdata/root_feed.json")); | 1316 "gdata/root_feed.json")); |
1317 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1317 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1318 "chromeos/gdata/account_metadata.json")); | 1318 "gdata/account_metadata.json")); |
1319 | 1319 |
1320 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1320 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1321 | 1321 |
1322 const std::string kResourceId = "file:1_orphanfile_resource_id"; | 1322 const std::string kResourceId = "file:1_orphanfile_resource_id"; |
1323 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; | 1323 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; |
1324 | 1324 |
1325 // The file does not belong to any directory, even to the root. | 1325 // The file does not belong to any directory, even to the root. |
1326 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); | 1326 EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId)); |
1327 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); | 1327 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); |
1328 | 1328 |
1329 GDataErrorCode error = GDATA_OTHER_ERROR; | 1329 GDataErrorCode error = GDATA_OTHER_ERROR; |
1330 fake_service_.AddResourceToDirectory( | 1330 fake_service_.AddResourceToDirectory( |
1331 kNewParentResourceId, | 1331 kNewParentResourceId, |
1332 kResourceId, | 1332 kResourceId, |
1333 test_util::CreateCopyResultCallback(&error)); | 1333 test_util::CreateCopyResultCallback(&error)); |
1334 base::RunLoop().RunUntilIdle(); | 1334 base::RunLoop().RunUntilIdle(); |
1335 | 1335 |
1336 EXPECT_EQ(HTTP_SUCCESS, error); | 1336 EXPECT_EQ(HTTP_SUCCESS, error); |
1337 | 1337 |
1338 // The parent link should now be changed. | 1338 // The parent link should now be changed. |
1339 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); | 1339 EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId)); |
1340 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); | 1340 EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId())); |
1341 // Should be incremented as a file was moved. | 1341 // Should be incremented as a file was moved. |
1342 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1342 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1343 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1343 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1344 } | 1344 } |
1345 | 1345 |
1346 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_Offline) { | 1346 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_Offline) { |
1347 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1347 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1348 "chromeos/gdata/root_feed.json")); | 1348 "gdata/root_feed.json")); |
1349 fake_service_.set_offline(true); | 1349 fake_service_.set_offline(true); |
1350 | 1350 |
1351 const std::string kResourceId = "file:2_file_resource_id"; | 1351 const std::string kResourceId = "file:2_file_resource_id"; |
1352 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; | 1352 const std::string kNewParentResourceId = "folder:1_folder_resource_id"; |
1353 | 1353 |
1354 GDataErrorCode error = GDATA_OTHER_ERROR; | 1354 GDataErrorCode error = GDATA_OTHER_ERROR; |
1355 fake_service_.AddResourceToDirectory( | 1355 fake_service_.AddResourceToDirectory( |
1356 kNewParentResourceId, | 1356 kNewParentResourceId, |
1357 kResourceId, | 1357 kResourceId, |
1358 test_util::CreateCopyResultCallback(&error)); | 1358 test_util::CreateCopyResultCallback(&error)); |
1359 base::RunLoop().RunUntilIdle(); | 1359 base::RunLoop().RunUntilIdle(); |
1360 | 1360 |
1361 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1361 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1362 } | 1362 } |
1363 | 1363 |
1364 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) { | 1364 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) { |
1365 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1365 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1366 "chromeos/gdata/root_feed.json")); | 1366 "gdata/root_feed.json")); |
1367 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1367 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1368 "chromeos/gdata/account_metadata.json")); | 1368 "gdata/account_metadata.json")); |
1369 | 1369 |
1370 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1370 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1371 | 1371 |
1372 const std::string kResourceId = "file:subdirectory_file_1_id"; | 1372 const std::string kResourceId = "file:subdirectory_file_1_id"; |
1373 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 1373 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
1374 | 1374 |
1375 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); | 1375 scoped_ptr<ResourceEntry> resource_entry = FindEntry(kResourceId); |
1376 ASSERT_TRUE(resource_entry); | 1376 ASSERT_TRUE(resource_entry); |
1377 // The parent link should exist now. | 1377 // The parent link should exist now. |
1378 const google_apis::Link* parent_link = | 1378 const google_apis::Link* parent_link = |
(...skipping 14 matching lines...) Expand all Loading... |
1393 // The parent link should be gone now. | 1393 // The parent link should be gone now. |
1394 parent_link = resource_entry->GetLinkByType(Link::LINK_PARENT); | 1394 parent_link = resource_entry->GetLinkByType(Link::LINK_PARENT); |
1395 ASSERT_FALSE(parent_link); | 1395 ASSERT_FALSE(parent_link); |
1396 // Should be incremented as a file was moved to the root directory. | 1396 // Should be incremented as a file was moved to the root directory. |
1397 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1397 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1398 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1398 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1399 } | 1399 } |
1400 | 1400 |
1401 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_NonexistingFile) { | 1401 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_NonexistingFile) { |
1402 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1402 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1403 "chromeos/gdata/root_feed.json")); | 1403 "gdata/root_feed.json")); |
1404 | 1404 |
1405 const std::string kResourceId = "file:nonexisting_file"; | 1405 const std::string kResourceId = "file:nonexisting_file"; |
1406 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 1406 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
1407 | 1407 |
1408 GDataErrorCode error = GDATA_OTHER_ERROR; | 1408 GDataErrorCode error = GDATA_OTHER_ERROR; |
1409 fake_service_.RemoveResourceFromDirectory( | 1409 fake_service_.RemoveResourceFromDirectory( |
1410 kParentResourceId, | 1410 kParentResourceId, |
1411 kResourceId, | 1411 kResourceId, |
1412 test_util::CreateCopyResultCallback(&error)); | 1412 test_util::CreateCopyResultCallback(&error)); |
1413 base::RunLoop().RunUntilIdle(); | 1413 base::RunLoop().RunUntilIdle(); |
1414 | 1414 |
1415 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1415 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1416 } | 1416 } |
1417 | 1417 |
1418 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_OrphanFile) { | 1418 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_OrphanFile) { |
1419 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1419 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1420 "chromeos/gdata/root_feed.json")); | 1420 "gdata/root_feed.json")); |
1421 | 1421 |
1422 const std::string kResourceId = "file:1_orphanfile_resource_id"; | 1422 const std::string kResourceId = "file:1_orphanfile_resource_id"; |
1423 const std::string kParentResourceId = fake_service_.GetRootResourceId(); | 1423 const std::string kParentResourceId = fake_service_.GetRootResourceId(); |
1424 | 1424 |
1425 GDataErrorCode error = GDATA_OTHER_ERROR; | 1425 GDataErrorCode error = GDATA_OTHER_ERROR; |
1426 fake_service_.RemoveResourceFromDirectory( | 1426 fake_service_.RemoveResourceFromDirectory( |
1427 kParentResourceId, | 1427 kParentResourceId, |
1428 kResourceId, | 1428 kResourceId, |
1429 test_util::CreateCopyResultCallback(&error)); | 1429 test_util::CreateCopyResultCallback(&error)); |
1430 base::RunLoop().RunUntilIdle(); | 1430 base::RunLoop().RunUntilIdle(); |
1431 | 1431 |
1432 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1432 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1433 } | 1433 } |
1434 | 1434 |
1435 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_Offline) { | 1435 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_Offline) { |
1436 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1436 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1437 "chromeos/gdata/root_feed.json")); | 1437 "gdata/root_feed.json")); |
1438 fake_service_.set_offline(true); | 1438 fake_service_.set_offline(true); |
1439 | 1439 |
1440 const std::string kResourceId = "file:subdirectory_file_1_id"; | 1440 const std::string kResourceId = "file:subdirectory_file_1_id"; |
1441 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 1441 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
1442 | 1442 |
1443 GDataErrorCode error = GDATA_OTHER_ERROR; | 1443 GDataErrorCode error = GDATA_OTHER_ERROR; |
1444 fake_service_.RemoveResourceFromDirectory( | 1444 fake_service_.RemoveResourceFromDirectory( |
1445 kParentResourceId, | 1445 kParentResourceId, |
1446 kResourceId, | 1446 kResourceId, |
1447 test_util::CreateCopyResultCallback(&error)); | 1447 test_util::CreateCopyResultCallback(&error)); |
1448 base::RunLoop().RunUntilIdle(); | 1448 base::RunLoop().RunUntilIdle(); |
1449 | 1449 |
1450 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1450 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1451 } | 1451 } |
1452 | 1452 |
1453 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) { | 1453 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) { |
1454 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1454 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1455 "chromeos/gdata/root_feed.json")); | 1455 "gdata/root_feed.json")); |
1456 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1456 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1457 "chromeos/gdata/account_metadata.json")); | 1457 "gdata/account_metadata.json")); |
1458 | 1458 |
1459 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1459 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1460 | 1460 |
1461 GDataErrorCode error = GDATA_OTHER_ERROR; | 1461 GDataErrorCode error = GDATA_OTHER_ERROR; |
1462 scoped_ptr<ResourceEntry> resource_entry; | 1462 scoped_ptr<ResourceEntry> resource_entry; |
1463 fake_service_.AddNewDirectory( | 1463 fake_service_.AddNewDirectory( |
1464 fake_service_.GetRootResourceId(), | 1464 fake_service_.GetRootResourceId(), |
1465 "new directory", | 1465 "new directory", |
1466 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1466 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1467 base::RunLoop().RunUntilIdle(); | 1467 base::RunLoop().RunUntilIdle(); |
1468 | 1468 |
1469 EXPECT_EQ(HTTP_CREATED, error); | 1469 EXPECT_EQ(HTTP_CREATED, error); |
1470 ASSERT_TRUE(resource_entry); | 1470 ASSERT_TRUE(resource_entry); |
1471 EXPECT_TRUE(resource_entry->is_folder()); | 1471 EXPECT_TRUE(resource_entry->is_folder()); |
1472 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); | 1472 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); |
1473 EXPECT_EQ("new directory", resource_entry->title()); | 1473 EXPECT_EQ("new directory", resource_entry->title()); |
1474 EXPECT_TRUE(HasParent(resource_entry->resource_id(), | 1474 EXPECT_TRUE(HasParent(resource_entry->resource_id(), |
1475 fake_service_.GetRootResourceId())); | 1475 fake_service_.GetRootResourceId())); |
1476 // Should be incremented as a new directory was created. | 1476 // Should be incremented as a new directory was created. |
1477 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1477 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1478 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1478 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1479 } | 1479 } |
1480 | 1480 |
1481 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) { | 1481 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) { |
1482 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1482 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1483 "chromeos/gdata/empty_feed.json")); | 1483 "gdata/empty_feed.json")); |
1484 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1484 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1485 "chromeos/gdata/account_metadata.json")); | 1485 "gdata/account_metadata.json")); |
1486 | 1486 |
1487 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1487 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1488 | 1488 |
1489 GDataErrorCode error = GDATA_OTHER_ERROR; | 1489 GDataErrorCode error = GDATA_OTHER_ERROR; |
1490 scoped_ptr<ResourceEntry> resource_entry; | 1490 scoped_ptr<ResourceEntry> resource_entry; |
1491 fake_service_.AddNewDirectory( | 1491 fake_service_.AddNewDirectory( |
1492 fake_service_.GetRootResourceId(), | 1492 fake_service_.GetRootResourceId(), |
1493 "new directory", | 1493 "new directory", |
1494 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1494 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1495 base::RunLoop().RunUntilIdle(); | 1495 base::RunLoop().RunUntilIdle(); |
1496 | 1496 |
1497 EXPECT_EQ(HTTP_CREATED, error); | 1497 EXPECT_EQ(HTTP_CREATED, error); |
1498 ASSERT_TRUE(resource_entry); | 1498 ASSERT_TRUE(resource_entry); |
1499 EXPECT_TRUE(resource_entry->is_folder()); | 1499 EXPECT_TRUE(resource_entry->is_folder()); |
1500 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); | 1500 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); |
1501 EXPECT_EQ("new directory", resource_entry->title()); | 1501 EXPECT_EQ("new directory", resource_entry->title()); |
1502 EXPECT_TRUE(HasParent(resource_entry->resource_id(), | 1502 EXPECT_TRUE(HasParent(resource_entry->resource_id(), |
1503 fake_service_.GetRootResourceId())); | 1503 fake_service_.GetRootResourceId())); |
1504 // Should be incremented as a new directory was created. | 1504 // Should be incremented as a new directory was created. |
1505 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1505 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1506 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1506 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1507 } | 1507 } |
1508 | 1508 |
1509 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) { | 1509 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) { |
1510 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1510 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1511 "chromeos/gdata/root_feed.json")); | 1511 "gdata/root_feed.json")); |
1512 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1512 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1513 "chromeos/gdata/account_metadata.json")); | 1513 "gdata/account_metadata.json")); |
1514 | 1514 |
1515 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1515 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1516 | 1516 |
1517 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 1517 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
1518 | 1518 |
1519 GDataErrorCode error = GDATA_OTHER_ERROR; | 1519 GDataErrorCode error = GDATA_OTHER_ERROR; |
1520 scoped_ptr<ResourceEntry> resource_entry; | 1520 scoped_ptr<ResourceEntry> resource_entry; |
1521 fake_service_.AddNewDirectory( | 1521 fake_service_.AddNewDirectory( |
1522 kParentResourceId, | 1522 kParentResourceId, |
1523 "new directory", | 1523 "new directory", |
1524 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1524 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1525 base::RunLoop().RunUntilIdle(); | 1525 base::RunLoop().RunUntilIdle(); |
1526 | 1526 |
1527 EXPECT_EQ(HTTP_CREATED, error); | 1527 EXPECT_EQ(HTTP_CREATED, error); |
1528 ASSERT_TRUE(resource_entry); | 1528 ASSERT_TRUE(resource_entry); |
1529 EXPECT_TRUE(resource_entry->is_folder()); | 1529 EXPECT_TRUE(resource_entry->is_folder()); |
1530 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); | 1530 EXPECT_EQ("resource_id_1", resource_entry->resource_id()); |
1531 EXPECT_EQ("new directory", resource_entry->title()); | 1531 EXPECT_EQ("new directory", resource_entry->title()); |
1532 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); | 1532 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); |
1533 // Should be incremented as a new directory was created. | 1533 // Should be incremented as a new directory was created. |
1534 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1534 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1535 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1535 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1536 } | 1536 } |
1537 | 1537 |
1538 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) { | 1538 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) { |
1539 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1539 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1540 "chromeos/gdata/root_feed.json")); | 1540 "gdata/root_feed.json")); |
1541 | 1541 |
1542 const std::string kParentResourceId = "folder:nonexisting_resource_id"; | 1542 const std::string kParentResourceId = "folder:nonexisting_resource_id"; |
1543 | 1543 |
1544 GDataErrorCode error = GDATA_OTHER_ERROR; | 1544 GDataErrorCode error = GDATA_OTHER_ERROR; |
1545 scoped_ptr<ResourceEntry> resource_entry; | 1545 scoped_ptr<ResourceEntry> resource_entry; |
1546 fake_service_.AddNewDirectory( | 1546 fake_service_.AddNewDirectory( |
1547 kParentResourceId, | 1547 kParentResourceId, |
1548 "new directory", | 1548 "new directory", |
1549 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1549 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1550 base::RunLoop().RunUntilIdle(); | 1550 base::RunLoop().RunUntilIdle(); |
1551 | 1551 |
1552 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1552 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1553 EXPECT_FALSE(resource_entry); | 1553 EXPECT_FALSE(resource_entry); |
1554 } | 1554 } |
1555 | 1555 |
1556 TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) { | 1556 TEST_F(FakeDriveServiceTest, AddNewDirectory_Offline) { |
1557 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1557 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1558 "chromeos/gdata/root_feed.json")); | 1558 "gdata/root_feed.json")); |
1559 fake_service_.set_offline(true); | 1559 fake_service_.set_offline(true); |
1560 | 1560 |
1561 GDataErrorCode error = GDATA_OTHER_ERROR; | 1561 GDataErrorCode error = GDATA_OTHER_ERROR; |
1562 scoped_ptr<ResourceEntry> resource_entry; | 1562 scoped_ptr<ResourceEntry> resource_entry; |
1563 fake_service_.AddNewDirectory( | 1563 fake_service_.AddNewDirectory( |
1564 fake_service_.GetRootResourceId(), | 1564 fake_service_.GetRootResourceId(), |
1565 "new directory", | 1565 "new directory", |
1566 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 1566 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
1567 base::RunLoop().RunUntilIdle(); | 1567 base::RunLoop().RunUntilIdle(); |
1568 | 1568 |
1569 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1569 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1570 EXPECT_FALSE(resource_entry); | 1570 EXPECT_FALSE(resource_entry); |
1571 } | 1571 } |
1572 | 1572 |
1573 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) { | 1573 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) { |
1574 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1574 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1575 "chromeos/gdata/root_feed.json")); | 1575 "gdata/root_feed.json")); |
1576 fake_service_.set_offline(true); | 1576 fake_service_.set_offline(true); |
1577 | 1577 |
1578 GDataErrorCode error = GDATA_OTHER_ERROR; | 1578 GDataErrorCode error = GDATA_OTHER_ERROR; |
1579 GURL upload_location; | 1579 GURL upload_location; |
1580 fake_service_.InitiateUploadNewFile( | 1580 fake_service_.InitiateUploadNewFile( |
1581 "test/foo", | 1581 "test/foo", |
1582 13, | 1582 13, |
1583 "folder:1_folder_resource_id", | 1583 "folder:1_folder_resource_id", |
1584 "new file.foo", | 1584 "new file.foo", |
1585 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1585 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1586 base::RunLoop().RunUntilIdle(); | 1586 base::RunLoop().RunUntilIdle(); |
1587 | 1587 |
1588 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1588 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1589 EXPECT_TRUE(upload_location.is_empty()); | 1589 EXPECT_TRUE(upload_location.is_empty()); |
1590 } | 1590 } |
1591 | 1591 |
1592 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_NotFound) { | 1592 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_NotFound) { |
1593 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1593 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1594 "chromeos/gdata/root_feed.json")); | 1594 "gdata/root_feed.json")); |
1595 | 1595 |
1596 GDataErrorCode error = GDATA_OTHER_ERROR; | 1596 GDataErrorCode error = GDATA_OTHER_ERROR; |
1597 GURL upload_location; | 1597 GURL upload_location; |
1598 fake_service_.InitiateUploadNewFile( | 1598 fake_service_.InitiateUploadNewFile( |
1599 "test/foo", | 1599 "test/foo", |
1600 13, | 1600 13, |
1601 "non_existent", | 1601 "non_existent", |
1602 "new file.foo", | 1602 "new file.foo", |
1603 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1603 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1604 base::RunLoop().RunUntilIdle(); | 1604 base::RunLoop().RunUntilIdle(); |
1605 | 1605 |
1606 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1606 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1607 EXPECT_TRUE(upload_location.is_empty()); | 1607 EXPECT_TRUE(upload_location.is_empty()); |
1608 } | 1608 } |
1609 | 1609 |
1610 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile) { | 1610 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile) { |
1611 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1611 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1612 "chromeos/gdata/root_feed.json")); | 1612 "gdata/root_feed.json")); |
1613 | 1613 |
1614 GDataErrorCode error = GDATA_OTHER_ERROR; | 1614 GDataErrorCode error = GDATA_OTHER_ERROR; |
1615 GURL upload_location; | 1615 GURL upload_location; |
1616 fake_service_.InitiateUploadNewFile( | 1616 fake_service_.InitiateUploadNewFile( |
1617 "test/foo", | 1617 "test/foo", |
1618 13, | 1618 13, |
1619 "folder:1_folder_resource_id", | 1619 "folder:1_folder_resource_id", |
1620 "new file.foo", | 1620 "new file.foo", |
1621 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1621 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1622 base::RunLoop().RunUntilIdle(); | 1622 base::RunLoop().RunUntilIdle(); |
1623 | 1623 |
1624 EXPECT_EQ(HTTP_SUCCESS, error); | 1624 EXPECT_EQ(HTTP_SUCCESS, error); |
1625 EXPECT_FALSE(upload_location.is_empty()); | 1625 EXPECT_FALSE(upload_location.is_empty()); |
1626 EXPECT_NE(GURL("https://1_folder_resumable_create_media_link?mode=newfile"), | 1626 EXPECT_NE(GURL("https://1_folder_resumable_create_media_link?mode=newfile"), |
1627 upload_location); | 1627 upload_location); |
1628 } | 1628 } |
1629 | 1629 |
1630 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Offline) { | 1630 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Offline) { |
1631 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1631 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1632 "chromeos/gdata/root_feed.json")); | 1632 "gdata/root_feed.json")); |
1633 fake_service_.set_offline(true); | 1633 fake_service_.set_offline(true); |
1634 | 1634 |
1635 GDataErrorCode error = GDATA_OTHER_ERROR; | 1635 GDataErrorCode error = GDATA_OTHER_ERROR; |
1636 GURL upload_location; | 1636 GURL upload_location; |
1637 fake_service_.InitiateUploadExistingFile( | 1637 fake_service_.InitiateUploadExistingFile( |
1638 "test/foo", | 1638 "test/foo", |
1639 13, | 1639 13, |
1640 "file:2_file_resource_id", | 1640 "file:2_file_resource_id", |
1641 std::string(), // etag | 1641 std::string(), // etag |
1642 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1642 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1643 base::RunLoop().RunUntilIdle(); | 1643 base::RunLoop().RunUntilIdle(); |
1644 | 1644 |
1645 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 1645 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
1646 EXPECT_TRUE(upload_location.is_empty()); | 1646 EXPECT_TRUE(upload_location.is_empty()); |
1647 } | 1647 } |
1648 | 1648 |
1649 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_NotFound) { | 1649 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_NotFound) { |
1650 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1650 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1651 "chromeos/gdata/root_feed.json")); | 1651 "gdata/root_feed.json")); |
1652 | 1652 |
1653 GDataErrorCode error = GDATA_OTHER_ERROR; | 1653 GDataErrorCode error = GDATA_OTHER_ERROR; |
1654 GURL upload_location; | 1654 GURL upload_location; |
1655 fake_service_.InitiateUploadExistingFile( | 1655 fake_service_.InitiateUploadExistingFile( |
1656 "test/foo", | 1656 "test/foo", |
1657 13, | 1657 13, |
1658 "non_existent", | 1658 "non_existent", |
1659 std::string(), // etag | 1659 std::string(), // etag |
1660 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1660 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1661 base::RunLoop().RunUntilIdle(); | 1661 base::RunLoop().RunUntilIdle(); |
1662 | 1662 |
1663 EXPECT_EQ(HTTP_NOT_FOUND, error); | 1663 EXPECT_EQ(HTTP_NOT_FOUND, error); |
1664 EXPECT_TRUE(upload_location.is_empty()); | 1664 EXPECT_TRUE(upload_location.is_empty()); |
1665 } | 1665 } |
1666 | 1666 |
1667 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_WrongETag) { | 1667 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_WrongETag) { |
1668 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1668 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1669 "chromeos/gdata/root_feed.json")); | 1669 "gdata/root_feed.json")); |
1670 | 1670 |
1671 GDataErrorCode error = GDATA_OTHER_ERROR; | 1671 GDataErrorCode error = GDATA_OTHER_ERROR; |
1672 GURL upload_location; | 1672 GURL upload_location; |
1673 fake_service_.InitiateUploadExistingFile( | 1673 fake_service_.InitiateUploadExistingFile( |
1674 "text/plain", | 1674 "text/plain", |
1675 13, | 1675 13, |
1676 "file:2_file_resource_id", | 1676 "file:2_file_resource_id", |
1677 "invalid_etag", | 1677 "invalid_etag", |
1678 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1678 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1679 base::RunLoop().RunUntilIdle(); | 1679 base::RunLoop().RunUntilIdle(); |
1680 | 1680 |
1681 EXPECT_EQ(HTTP_PRECONDITION, error); | 1681 EXPECT_EQ(HTTP_PRECONDITION, error); |
1682 EXPECT_TRUE(upload_location.is_empty()); | 1682 EXPECT_TRUE(upload_location.is_empty()); |
1683 } | 1683 } |
1684 | 1684 |
1685 TEST_F(FakeDriveServiceTest, InitiateUpload_ExistingFile) { | 1685 TEST_F(FakeDriveServiceTest, InitiateUpload_ExistingFile) { |
1686 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1686 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1687 "chromeos/gdata/root_feed.json")); | 1687 "gdata/root_feed.json")); |
1688 | 1688 |
1689 GDataErrorCode error = GDATA_OTHER_ERROR; | 1689 GDataErrorCode error = GDATA_OTHER_ERROR; |
1690 GURL upload_location; | 1690 GURL upload_location; |
1691 fake_service_.InitiateUploadExistingFile( | 1691 fake_service_.InitiateUploadExistingFile( |
1692 "text/plain", | 1692 "text/plain", |
1693 13, | 1693 13, |
1694 "file:2_file_resource_id", | 1694 "file:2_file_resource_id", |
1695 "\"HhMOFgxXHit7ImBr\"", | 1695 "\"HhMOFgxXHit7ImBr\"", |
1696 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1696 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1697 base::RunLoop().RunUntilIdle(); | 1697 base::RunLoop().RunUntilIdle(); |
1698 | 1698 |
1699 EXPECT_EQ(HTTP_SUCCESS, error); | 1699 EXPECT_EQ(HTTP_SUCCESS, error); |
1700 EXPECT_TRUE(upload_location.is_valid()); | 1700 EXPECT_TRUE(upload_location.is_valid()); |
1701 } | 1701 } |
1702 | 1702 |
1703 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) { | 1703 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) { |
1704 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1704 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1705 "chromeos/gdata/root_feed.json")); | 1705 "gdata/root_feed.json")); |
1706 | 1706 |
1707 GDataErrorCode error = GDATA_OTHER_ERROR; | 1707 GDataErrorCode error = GDATA_OTHER_ERROR; |
1708 GURL upload_location; | 1708 GURL upload_location; |
1709 fake_service_.InitiateUploadNewFile( | 1709 fake_service_.InitiateUploadNewFile( |
1710 "test/foo", | 1710 "test/foo", |
1711 15, | 1711 15, |
1712 "folder:1_folder_resource_id", | 1712 "folder:1_folder_resource_id", |
1713 "new file.foo", | 1713 "new file.foo", |
1714 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1714 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1715 base::RunLoop().RunUntilIdle(); | 1715 base::RunLoop().RunUntilIdle(); |
(...skipping 14 matching lines...) Expand all Loading... |
1730 test_util::CreateCopyResultCallback(&response, &entry), | 1730 test_util::CreateCopyResultCallback(&response, &entry), |
1731 ProgressCallback()); | 1731 ProgressCallback()); |
1732 base::RunLoop().RunUntilIdle(); | 1732 base::RunLoop().RunUntilIdle(); |
1733 | 1733 |
1734 EXPECT_EQ(GDATA_NO_CONNECTION, response.code); | 1734 EXPECT_EQ(GDATA_NO_CONNECTION, response.code); |
1735 EXPECT_FALSE(entry.get()); | 1735 EXPECT_FALSE(entry.get()); |
1736 } | 1736 } |
1737 | 1737 |
1738 TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) { | 1738 TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) { |
1739 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1739 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1740 "chromeos/gdata/root_feed.json")); | 1740 "gdata/root_feed.json")); |
1741 | 1741 |
1742 GDataErrorCode error = GDATA_OTHER_ERROR; | 1742 GDataErrorCode error = GDATA_OTHER_ERROR; |
1743 GURL upload_location; | 1743 GURL upload_location; |
1744 fake_service_.InitiateUploadNewFile( | 1744 fake_service_.InitiateUploadNewFile( |
1745 "test/foo", | 1745 "test/foo", |
1746 15, | 1746 15, |
1747 "folder:1_folder_resource_id", | 1747 "folder:1_folder_resource_id", |
1748 "new file.foo", | 1748 "new file.foo", |
1749 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1749 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1750 base::RunLoop().RunUntilIdle(); | 1750 base::RunLoop().RunUntilIdle(); |
(...skipping 16 matching lines...) Expand all Loading... |
1767 | 1767 |
1768 TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) { | 1768 TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) { |
1769 base::ScopedTempDir temp_dir; | 1769 base::ScopedTempDir temp_dir; |
1770 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 1770 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
1771 base::FilePath local_file_path = | 1771 base::FilePath local_file_path = |
1772 temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt")); | 1772 temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt")); |
1773 std::string contents("hogefugapiyo"); | 1773 std::string contents("hogefugapiyo"); |
1774 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); | 1774 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); |
1775 | 1775 |
1776 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1776 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1777 "chromeos/gdata/root_feed.json")); | 1777 "gdata/root_feed.json")); |
1778 | 1778 |
1779 GDataErrorCode error = GDATA_OTHER_ERROR; | 1779 GDataErrorCode error = GDATA_OTHER_ERROR; |
1780 GURL upload_location; | 1780 GURL upload_location; |
1781 fake_service_.InitiateUploadExistingFile( | 1781 fake_service_.InitiateUploadExistingFile( |
1782 "text/plain", | 1782 "text/plain", |
1783 contents.size(), | 1783 contents.size(), |
1784 "file:2_file_resource_id", | 1784 "file:2_file_resource_id", |
1785 "\"HhMOFgxXHit7ImBr\"", | 1785 "\"HhMOFgxXHit7ImBr\"", |
1786 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1786 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1787 base::RunLoop().RunUntilIdle(); | 1787 base::RunLoop().RunUntilIdle(); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1833 | 1833 |
1834 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) { | 1834 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) { |
1835 base::ScopedTempDir temp_dir; | 1835 base::ScopedTempDir temp_dir; |
1836 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); | 1836 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
1837 base::FilePath local_file_path = | 1837 base::FilePath local_file_path = |
1838 temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo")); | 1838 temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo")); |
1839 std::string contents("hogefugapiyo"); | 1839 std::string contents("hogefugapiyo"); |
1840 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); | 1840 ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents)); |
1841 | 1841 |
1842 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1842 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1843 "chromeos/gdata/root_feed.json")); | 1843 "gdata/root_feed.json")); |
1844 | 1844 |
1845 GDataErrorCode error = GDATA_OTHER_ERROR; | 1845 GDataErrorCode error = GDATA_OTHER_ERROR; |
1846 GURL upload_location; | 1846 GURL upload_location; |
1847 fake_service_.InitiateUploadNewFile( | 1847 fake_service_.InitiateUploadNewFile( |
1848 "test/foo", | 1848 "test/foo", |
1849 contents.size(), | 1849 contents.size(), |
1850 "folder:1_folder_resource_id", | 1850 "folder:1_folder_resource_id", |
1851 "new file.foo", | 1851 "new file.foo", |
1852 test_util::CreateCopyResultCallback(&error, &upload_location)); | 1852 test_util::CreateCopyResultCallback(&error, &upload_location)); |
1853 base::RunLoop().RunUntilIdle(); | 1853 base::RunLoop().RunUntilIdle(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1894 ASSERT_TRUE(!upload_progress_values.empty()); | 1894 ASSERT_TRUE(!upload_progress_values.empty()); |
1895 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); | 1895 EXPECT_TRUE(base::STLIsSorted(upload_progress_values)); |
1896 EXPECT_LE(0, upload_progress_values.front().first); | 1896 EXPECT_LE(0, upload_progress_values.front().first); |
1897 EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2), | 1897 EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2), |
1898 upload_progress_values.back().first); | 1898 upload_progress_values.back().first); |
1899 EXPECT_EQ(base::MD5String(contents), entry->file_md5()); | 1899 EXPECT_EQ(base::MD5String(contents), entry->file_md5()); |
1900 } | 1900 } |
1901 | 1901 |
1902 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) { | 1902 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) { |
1903 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1903 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1904 "chromeos/gdata/root_feed.json")); | 1904 "gdata/root_feed.json")); |
1905 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1905 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1906 "chromeos/gdata/account_metadata.json")); | 1906 "gdata/account_metadata.json")); |
1907 | 1907 |
1908 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1908 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1909 | 1909 |
1910 const std::string kContentType = "text/plain"; | 1910 const std::string kContentType = "text/plain"; |
1911 const std::string kContentData = "This is some test content."; | 1911 const std::string kContentData = "This is some test content."; |
1912 const std::string kTitle = "new file"; | 1912 const std::string kTitle = "new file"; |
1913 | 1913 |
1914 GDataErrorCode error = GDATA_OTHER_ERROR; | 1914 GDataErrorCode error = GDATA_OTHER_ERROR; |
1915 scoped_ptr<ResourceEntry> resource_entry; | 1915 scoped_ptr<ResourceEntry> resource_entry; |
1916 fake_service_.AddNewFile( | 1916 fake_service_.AddNewFile( |
(...skipping 16 matching lines...) Expand all Loading... |
1933 EXPECT_TRUE(HasParent(resource_entry->resource_id(), | 1933 EXPECT_TRUE(HasParent(resource_entry->resource_id(), |
1934 fake_service_.GetRootResourceId())); | 1934 fake_service_.GetRootResourceId())); |
1935 // Should be incremented as a new directory was created. | 1935 // Should be incremented as a new directory was created. |
1936 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1936 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1937 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1937 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1938 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); | 1938 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); |
1939 } | 1939 } |
1940 | 1940 |
1941 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectoryOnEmptyFileSystem) { | 1941 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectoryOnEmptyFileSystem) { |
1942 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1942 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1943 "chromeos/gdata/empty_feed.json")); | 1943 "gdata/empty_feed.json")); |
1944 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1944 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1945 "chromeos/gdata/account_metadata.json")); | 1945 "gdata/account_metadata.json")); |
1946 | 1946 |
1947 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1947 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1948 | 1948 |
1949 const std::string kContentType = "text/plain"; | 1949 const std::string kContentType = "text/plain"; |
1950 const std::string kContentData = "This is some test content."; | 1950 const std::string kContentData = "This is some test content."; |
1951 const std::string kTitle = "new file"; | 1951 const std::string kTitle = "new file"; |
1952 | 1952 |
1953 GDataErrorCode error = GDATA_OTHER_ERROR; | 1953 GDataErrorCode error = GDATA_OTHER_ERROR; |
1954 scoped_ptr<ResourceEntry> resource_entry; | 1954 scoped_ptr<ResourceEntry> resource_entry; |
1955 fake_service_.AddNewFile( | 1955 fake_service_.AddNewFile( |
(...skipping 16 matching lines...) Expand all Loading... |
1972 EXPECT_TRUE(HasParent(resource_entry->resource_id(), | 1972 EXPECT_TRUE(HasParent(resource_entry->resource_id(), |
1973 fake_service_.GetRootResourceId())); | 1973 fake_service_.GetRootResourceId())); |
1974 // Should be incremented as a new directory was created. | 1974 // Should be incremented as a new directory was created. |
1975 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 1975 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
1976 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 1976 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
1977 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); | 1977 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); |
1978 } | 1978 } |
1979 | 1979 |
1980 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) { | 1980 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) { |
1981 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 1981 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
1982 "chromeos/gdata/root_feed.json")); | 1982 "gdata/root_feed.json")); |
1983 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 1983 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
1984 "chromeos/gdata/account_metadata.json")); | 1984 "gdata/account_metadata.json")); |
1985 | 1985 |
1986 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 1986 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
1987 | 1987 |
1988 const std::string kContentType = "text/plain"; | 1988 const std::string kContentType = "text/plain"; |
1989 const std::string kContentData = "This is some test content."; | 1989 const std::string kContentData = "This is some test content."; |
1990 const std::string kTitle = "new file"; | 1990 const std::string kTitle = "new file"; |
1991 const std::string kParentResourceId = "folder:1_folder_resource_id"; | 1991 const std::string kParentResourceId = "folder:1_folder_resource_id"; |
1992 | 1992 |
1993 GDataErrorCode error = GDATA_OTHER_ERROR; | 1993 GDataErrorCode error = GDATA_OTHER_ERROR; |
1994 scoped_ptr<ResourceEntry> resource_entry; | 1994 scoped_ptr<ResourceEntry> resource_entry; |
(...skipping 16 matching lines...) Expand all Loading... |
2011 EXPECT_EQ(kTitle, resource_entry->title()); | 2011 EXPECT_EQ(kTitle, resource_entry->title()); |
2012 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); | 2012 EXPECT_TRUE(HasParent(resource_entry->resource_id(), kParentResourceId)); |
2013 // Should be incremented as a new directory was created. | 2013 // Should be incremented as a new directory was created. |
2014 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 2014 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
2015 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 2015 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
2016 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); | 2016 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); |
2017 } | 2017 } |
2018 | 2018 |
2019 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonexistingDirectory) { | 2019 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonexistingDirectory) { |
2020 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2020 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2021 "chromeos/gdata/root_feed.json")); | 2021 "gdata/root_feed.json")); |
2022 | 2022 |
2023 const std::string kContentType = "text/plain"; | 2023 const std::string kContentType = "text/plain"; |
2024 const std::string kContentData = "This is some test content."; | 2024 const std::string kContentData = "This is some test content."; |
2025 const std::string kTitle = "new file"; | 2025 const std::string kTitle = "new file"; |
2026 const std::string kParentResourceId = "folder:nonexisting_resource_id"; | 2026 const std::string kParentResourceId = "folder:nonexisting_resource_id"; |
2027 | 2027 |
2028 GDataErrorCode error = GDATA_OTHER_ERROR; | 2028 GDataErrorCode error = GDATA_OTHER_ERROR; |
2029 scoped_ptr<ResourceEntry> resource_entry; | 2029 scoped_ptr<ResourceEntry> resource_entry; |
2030 fake_service_.AddNewFile( | 2030 fake_service_.AddNewFile( |
2031 kContentType, | 2031 kContentType, |
2032 kContentData, | 2032 kContentData, |
2033 kParentResourceId, | 2033 kParentResourceId, |
2034 kTitle, | 2034 kTitle, |
2035 false, // shared_with_me | 2035 false, // shared_with_me |
2036 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 2036 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
2037 base::RunLoop().RunUntilIdle(); | 2037 base::RunLoop().RunUntilIdle(); |
2038 | 2038 |
2039 EXPECT_EQ(HTTP_NOT_FOUND, error); | 2039 EXPECT_EQ(HTTP_NOT_FOUND, error); |
2040 EXPECT_FALSE(resource_entry); | 2040 EXPECT_FALSE(resource_entry); |
2041 } | 2041 } |
2042 | 2042 |
2043 TEST_F(FakeDriveServiceTest, AddNewFile_Offline) { | 2043 TEST_F(FakeDriveServiceTest, AddNewFile_Offline) { |
2044 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2044 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2045 "chromeos/gdata/root_feed.json")); | 2045 "gdata/root_feed.json")); |
2046 fake_service_.set_offline(true); | 2046 fake_service_.set_offline(true); |
2047 | 2047 |
2048 const std::string kContentType = "text/plain"; | 2048 const std::string kContentType = "text/plain"; |
2049 const std::string kContentData = "This is some test content."; | 2049 const std::string kContentData = "This is some test content."; |
2050 const std::string kTitle = "new file"; | 2050 const std::string kTitle = "new file"; |
2051 | 2051 |
2052 GDataErrorCode error = GDATA_OTHER_ERROR; | 2052 GDataErrorCode error = GDATA_OTHER_ERROR; |
2053 scoped_ptr<ResourceEntry> resource_entry; | 2053 scoped_ptr<ResourceEntry> resource_entry; |
2054 fake_service_.AddNewFile( | 2054 fake_service_.AddNewFile( |
2055 kContentType, | 2055 kContentType, |
2056 kContentData, | 2056 kContentData, |
2057 fake_service_.GetRootResourceId(), | 2057 fake_service_.GetRootResourceId(), |
2058 kTitle, | 2058 kTitle, |
2059 false, // shared_with_me | 2059 false, // shared_with_me |
2060 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 2060 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
2061 base::RunLoop().RunUntilIdle(); | 2061 base::RunLoop().RunUntilIdle(); |
2062 | 2062 |
2063 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 2063 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
2064 EXPECT_FALSE(resource_entry); | 2064 EXPECT_FALSE(resource_entry); |
2065 } | 2065 } |
2066 | 2066 |
2067 TEST_F(FakeDriveServiceTest, AddNewFile_SharedWithMeLabel) { | 2067 TEST_F(FakeDriveServiceTest, AddNewFile_SharedWithMeLabel) { |
2068 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2068 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2069 "chromeos/gdata/root_feed.json")); | 2069 "gdata/root_feed.json")); |
2070 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( | 2070 ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi( |
2071 "chromeos/gdata/account_metadata.json")); | 2071 "gdata/account_metadata.json")); |
2072 | 2072 |
2073 const std::string kContentType = "text/plain"; | 2073 const std::string kContentType = "text/plain"; |
2074 const std::string kContentData = "This is some test content."; | 2074 const std::string kContentData = "This is some test content."; |
2075 const std::string kTitle = "new file"; | 2075 const std::string kTitle = "new file"; |
2076 | 2076 |
2077 int64 old_largest_change_id = GetLargestChangeByAboutResource(); | 2077 int64 old_largest_change_id = GetLargestChangeByAboutResource(); |
2078 | 2078 |
2079 GDataErrorCode error = GDATA_OTHER_ERROR; | 2079 GDataErrorCode error = GDATA_OTHER_ERROR; |
2080 scoped_ptr<ResourceEntry> resource_entry; | 2080 scoped_ptr<ResourceEntry> resource_entry; |
2081 fake_service_.AddNewFile( | 2081 fake_service_.AddNewFile( |
(...skipping 18 matching lines...) Expand all Loading... |
2100 ASSERT_EQ(1U, resource_entry->labels().size()); | 2100 ASSERT_EQ(1U, resource_entry->labels().size()); |
2101 EXPECT_EQ("shared-with-me", resource_entry->labels()[0]); | 2101 EXPECT_EQ("shared-with-me", resource_entry->labels()[0]); |
2102 // Should be incremented as a new directory was created. | 2102 // Should be incremented as a new directory was created. |
2103 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); | 2103 EXPECT_EQ(old_largest_change_id + 1, fake_service_.largest_changestamp()); |
2104 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); | 2104 EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource()); |
2105 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); | 2105 EXPECT_EQ(base::MD5String(kContentData), resource_entry->file_md5()); |
2106 } | 2106 } |
2107 | 2107 |
2108 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_ExistingFile) { | 2108 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_ExistingFile) { |
2109 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2109 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2110 "chromeos/gdata/root_feed.json")); | 2110 "gdata/root_feed.json")); |
2111 | 2111 |
2112 const std::string kResourceId = "file:2_file_resource_id"; | 2112 const std::string kResourceId = "file:2_file_resource_id"; |
2113 base::Time time; | 2113 base::Time time; |
2114 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); | 2114 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); |
2115 | 2115 |
2116 GDataErrorCode error = GDATA_OTHER_ERROR; | 2116 GDataErrorCode error = GDATA_OTHER_ERROR; |
2117 scoped_ptr<ResourceEntry> resource_entry; | 2117 scoped_ptr<ResourceEntry> resource_entry; |
2118 fake_service_.SetLastModifiedTime( | 2118 fake_service_.SetLastModifiedTime( |
2119 kResourceId, | 2119 kResourceId, |
2120 time, | 2120 time, |
2121 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 2121 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
2122 base::RunLoop().RunUntilIdle(); | 2122 base::RunLoop().RunUntilIdle(); |
2123 | 2123 |
2124 EXPECT_EQ(HTTP_SUCCESS, error); | 2124 EXPECT_EQ(HTTP_SUCCESS, error); |
2125 ASSERT_TRUE(resource_entry); | 2125 ASSERT_TRUE(resource_entry); |
2126 EXPECT_EQ(time, resource_entry->updated_time()); | 2126 EXPECT_EQ(time, resource_entry->updated_time()); |
2127 } | 2127 } |
2128 | 2128 |
2129 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_NonexistingFile) { | 2129 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_NonexistingFile) { |
2130 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2130 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2131 "chromeos/gdata/root_feed.json")); | 2131 "gdata/root_feed.json")); |
2132 | 2132 |
2133 const std::string kResourceId = "file:nonexisting_resource_id"; | 2133 const std::string kResourceId = "file:nonexisting_resource_id"; |
2134 base::Time time; | 2134 base::Time time; |
2135 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); | 2135 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); |
2136 | 2136 |
2137 GDataErrorCode error = GDATA_OTHER_ERROR; | 2137 GDataErrorCode error = GDATA_OTHER_ERROR; |
2138 scoped_ptr<ResourceEntry> resource_entry; | 2138 scoped_ptr<ResourceEntry> resource_entry; |
2139 fake_service_.SetLastModifiedTime( | 2139 fake_service_.SetLastModifiedTime( |
2140 kResourceId, | 2140 kResourceId, |
2141 time, | 2141 time, |
2142 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 2142 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
2143 base::RunLoop().RunUntilIdle(); | 2143 base::RunLoop().RunUntilIdle(); |
2144 | 2144 |
2145 EXPECT_EQ(HTTP_NOT_FOUND, error); | 2145 EXPECT_EQ(HTTP_NOT_FOUND, error); |
2146 EXPECT_FALSE(resource_entry); | 2146 EXPECT_FALSE(resource_entry); |
2147 } | 2147 } |
2148 | 2148 |
2149 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_Offline) { | 2149 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_Offline) { |
2150 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( | 2150 ASSERT_TRUE(fake_service_.LoadResourceListForWapi( |
2151 "chromeos/gdata/root_feed.json")); | 2151 "gdata/root_feed.json")); |
2152 fake_service_.set_offline(true); | 2152 fake_service_.set_offline(true); |
2153 | 2153 |
2154 const std::string kResourceId = "file:2_file_resource_id"; | 2154 const std::string kResourceId = "file:2_file_resource_id"; |
2155 base::Time time; | 2155 base::Time time; |
2156 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); | 2156 ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time)); |
2157 | 2157 |
2158 GDataErrorCode error = GDATA_OTHER_ERROR; | 2158 GDataErrorCode error = GDATA_OTHER_ERROR; |
2159 scoped_ptr<ResourceEntry> resource_entry; | 2159 scoped_ptr<ResourceEntry> resource_entry; |
2160 fake_service_.SetLastModifiedTime( | 2160 fake_service_.SetLastModifiedTime( |
2161 kResourceId, | 2161 kResourceId, |
2162 time, | 2162 time, |
2163 test_util::CreateCopyResultCallback(&error, &resource_entry)); | 2163 test_util::CreateCopyResultCallback(&error, &resource_entry)); |
2164 base::RunLoop().RunUntilIdle(); | 2164 base::RunLoop().RunUntilIdle(); |
2165 | 2165 |
2166 EXPECT_EQ(GDATA_NO_CONNECTION, error); | 2166 EXPECT_EQ(GDATA_NO_CONNECTION, error); |
2167 EXPECT_FALSE(resource_entry); | 2167 EXPECT_FALSE(resource_entry); |
2168 } | 2168 } |
2169 | 2169 |
2170 } // namespace | 2170 } // namespace |
2171 | 2171 |
2172 } // namespace drive | 2172 } // namespace drive |
OLD | NEW |