src/chrome/browser/google_apis/drive_api_requests_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/file_util.h"
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/google_apis/drive_api_parser.h"
  14 #include "chrome/browser/google_apis/drive_api_requests.h"
  15 #include "chrome/browser/google_apis/drive_api_url_generator.h"
  16 #include "chrome/browser/google_apis/dummy_auth_service.h"
  17 #include "chrome/browser/google_apis/request_sender.h"
  18 #include "chrome/browser/google_apis/test_util.h"
  19 #include "net/test/embedded_test_server/embedded_test_server.h"
  20 #include "net/test/embedded_test_server/http_request.h"
  21 #include "net/test/embedded_test_server/http_response.h"
  22 #include "net/url_request/url_request_test_util.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace google_apis {
  26
  27 namespace {
  28
  29 const char kTestETag[] = "test_etag";
  30 const char kTestUserAgent[] = "test-user-agent";
  31
  32 const char kTestChildrenResponse[] =
  33     "{\n"
  34     "\"kind\": \"drive#childReference\",\n"
  35     "\"id\": \"resource_id\",\n"
  36     "\"selfLink\": \"self_link\",\n"
  37     "\"childLink\": \"child_link\",\n"
  38     "}\n";
  39
  40 const char kTestUploadExistingFilePath[] = "/upload/existingfile/path";
  41 const char kTestUploadNewFilePath[] = "/upload/newfile/path";
  42 const char kTestDownloadPathPrefix[] = "/download/";
  43
  44 // Used as a GetContentCallback.
  45 void AppendContent(std::string* out,
  46                    GDataErrorCode error,
  47                    scoped_ptr<std::string> content) {
  48   EXPECT_EQ(HTTP_SUCCESS, error);
  49   out->append(*content);
  50 }
  51
  52 }  // namespace
  53
  54 class DriveApiRequestsTest : public testing::Test {
  55  public:
  56   DriveApiRequestsTest() {
  57   }
  58
  59   virtual void SetUp() OVERRIDE {
  60     request_context_getter_ = new net::TestURLRequestContextGetter(
  61         message_loop_.message_loop_proxy());
  62
  63     request_sender_.reset(new RequestSender(new DummyAuthService,
  64                                             request_context_getter_.get(),
  65                                             message_loop_.message_loop_proxy(),
  66                                             kTestUserAgent));
  67
  68     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  69
  70     ASSERT_TRUE(test_server_.InitializeAndWaitUntilReady());
  71     test_server_.RegisterRequestHandler(
  72         base::Bind(&DriveApiRequestsTest::HandleChildrenDeleteRequest,
  73                    base::Unretained(this)));
  74     test_server_.RegisterRequestHandler(
  75         base::Bind(&DriveApiRequestsTest::HandleDataFileRequest,
  76                    base::Unretained(this)));
  77     test_server_.RegisterRequestHandler(
  78         base::Bind(&DriveApiRequestsTest::HandlePreconditionFailedRequest,
  79                    base::Unretained(this)));
  80     test_server_.RegisterRequestHandler(
  81         base::Bind(&DriveApiRequestsTest::HandleResumeUploadRequest,
  82                    base::Unretained(this)));
  83     test_server_.RegisterRequestHandler(
  84         base::Bind(&DriveApiRequestsTest::HandleInitiateUploadRequest,
  85                    base::Unretained(this)));
  86     test_server_.RegisterRequestHandler(
  87         base::Bind(&DriveApiRequestsTest::HandleContentResponse,
  88                    base::Unretained(this)));
  89     test_server_.RegisterRequestHandler(
  90         base::Bind(&DriveApiRequestsTest::HandleDownloadRequest,
  91                    base::Unretained(this)));
  92
  93     GURL test_base_url = test_util::GetBaseUrlForTesting(test_server_.port());
  94     url_generator_.reset(new DriveApiUrlGenerator(
  95         test_base_url, test_base_url.Resolve(kTestDownloadPathPrefix)));
  96
  97     // Reset the server's expected behavior just in case.
  98     ResetExpectedResponse();
  99     received_bytes_ = 0;
 100     content_length_ = 0;
 101   }
 102
 103   base::MessageLoopForIO message_loop_;  // Test server needs IO thread.
 104   net::test_server::EmbeddedTestServer test_server_;
 105   scoped_ptr<RequestSender> request_sender_;
 106   scoped_ptr<DriveApiUrlGenerator> url_generator_;
 107   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 108   base::ScopedTempDir temp_dir_;
 109
 110   // This is a path to the file which contains expected response from
 111   // the server. See also HandleDataFileRequest below.
 112   base::FilePath expected_data_file_path_;
 113
 114   // This is a path string in the expected response header from the server
 115   // for initiating file uploading.
 116   std::string expected_upload_path_;
 117
 118   // This is a path to the file which contains expected response for
 119   // PRECONDITION_FAILED response.
 120   base::FilePath expected_precondition_failed_file_path_;
 121
 122   // These are content and its type in the expected response from the server.
 123   // See also HandleContentResponse below.
 124   std::string expected_content_type_;
 125   std::string expected_content_;
 126
 127   // The incoming HTTP request is saved so tests can verify the request
 128   // parameters like HTTP method (ex. some requests should use DELETE
 129   // instead of GET).
 130   net::test_server::HttpRequest http_request_;
 131
 132  private:
 133   void ResetExpectedResponse() {
 134     expected_data_file_path_.clear();
 135     expected_upload_path_.clear();
 136     expected_content_type_.clear();
 137     expected_content_.clear();
 138   }
 139
 140   // For "Children: delete" request, the server will return "204 No Content"
 141   // response meaning "success".
 142   scoped_ptr<net::test_server::HttpResponse> HandleChildrenDeleteRequest(
 143       const net::test_server::HttpRequest& request) {
 144     if (request.method != net::test_server::METHOD_DELETE ||
 145         request.relative_url.find("/children/") == string::npos) {
 146       // The request is not the "Children: delete" request. Delegate the
 147       // processing to the next handler.
 148       return scoped_ptr<net::test_server::HttpResponse>();
 149     }
 150
 151     http_request_ = request;
 152
 153     // Return the response with just "204 No Content" status code.
 154     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
 155         new net::test_server::BasicHttpResponse);
 156     http_response->set_code(net::HTTP_NO_CONTENT);
 157     return http_response.PassAs<net::test_server::HttpResponse>();
 158   }
 159
 160   // Reads the data file of |expected_data_file_path_| and returns its content
 161   // for the request.
 162   // To use this method, it is necessary to set |expected_data_file_path_|
 163   // to the appropriate file path before sending the request to the server.
 164   scoped_ptr<net::test_server::HttpResponse> HandleDataFileRequest(
 165       const net::test_server::HttpRequest& request) {
 166     if (expected_data_file_path_.empty()) {
 167       // The file is not specified. Delegate the processing to the next
 168       // handler.
 169       return scoped_ptr<net::test_server::HttpResponse>();
 170     }
 171
 172     http_request_ = request;
 173
 174     // Return the response from the data file.
 175     return test_util::CreateHttpResponseFromFile(
 176         expected_data_file_path_).PassAs<net::test_server::HttpResponse>();
 177   }
 178
 179   // Returns PRECONDITION_FAILED response for ETag mismatching with error JSON
 180   // content specified by |expected_precondition_failed_file_path_|.
 181   // To use this method, it is necessary to set the variable to the appropriate
 182   // file path before sending the request to the server.
 183   scoped_ptr<net::test_server::HttpResponse> HandlePreconditionFailedRequest(
 184       const net::test_server::HttpRequest& request) {
 185     if (expected_precondition_failed_file_path_.empty()) {
 186       // The file is not specified. Delegate the process to the next handler.
 187       return scoped_ptr<net::test_server::HttpResponse>();
 188     }
 189
 190     http_request_ = request;
 191
 192     scoped_ptr<net::test_server::BasicHttpResponse> response(
 193         new net::test_server::BasicHttpResponse);
 194     response->set_code(net::HTTP_PRECONDITION_FAILED);
 195
 196     std::string content;
 197     if (base::ReadFileToString(expected_precondition_failed_file_path_,
 198                                &content)) {
 199       response->set_content(content);
 200       response->set_content_type("application/json");
 201     }
 202
 203     return response.PassAs<net::test_server::HttpResponse>();
 204   }
 205
 206   // Returns the response based on set expected upload url.
 207   // The response contains the url in its "Location: " header. Also, it doesn't
 208   // have any content.
 209   // To use this method, it is necessary to set |expected_upload_path_|
 210   // to the string representation of the url to be returned.
 211   scoped_ptr<net::test_server::HttpResponse> HandleInitiateUploadRequest(
 212       const net::test_server::HttpRequest& request) {
 213     if (request.relative_url == expected_upload_path_ ||
 214         expected_upload_path_.empty()) {
 215       // The request is for resume uploading or the expected upload url is not
 216       // set. Delegate the processing to the next handler.
 217       return scoped_ptr<net::test_server::HttpResponse>();
 218     }
 219
 220     http_request_ = request;
 221
 222     scoped_ptr<net::test_server::BasicHttpResponse> response(
 223         new net::test_server::BasicHttpResponse);
 224
 225     // Check if the X-Upload-Content-Length is present. If yes, store the
 226     // length of the file.
 227     std::map<std::string, std::string>::const_iterator found =
 228         request.headers.find("X-Upload-Content-Length");
 229     if (found == request.headers.end() ||
 230         !base::StringToInt64(found->second, &content_length_)) {
 231       return scoped_ptr<net::test_server::HttpResponse>();
 232     }
 233     received_bytes_ = 0;
 234
 235     response->set_code(net::HTTP_OK);
 236     response->AddCustomHeader(
 237         "Location",
 238         test_server_.base_url().Resolve(expected_upload_path_).spec());
 239     return response.PassAs<net::test_server::HttpResponse>();
 240   }
 241
 242   scoped_ptr<net::test_server::HttpResponse> HandleResumeUploadRequest(
 243       const net::test_server::HttpRequest& request) {
 244     if (request.relative_url != expected_upload_path_) {
 245       // The request path is different from the expected path for uploading.
 246       // Delegate the processing to the next handler.
 247       return scoped_ptr<net::test_server::HttpResponse>();
 248     }
 249
 250     http_request_ = request;
 251
 252     if (!request.content.empty()) {
 253       std::map<std::string, std::string>::const_iterator iter =
 254           request.headers.find("Content-Range");
 255       if (iter == request.headers.end()) {
 256         // The range must be set.
 257         return scoped_ptr<net::test_server::HttpResponse>();
 258       }
 259
 260       int64 length = 0;
 261       int64 start_position = 0;
 262       int64 end_position = 0;
 263       if (!test_util::ParseContentRangeHeader(
 264               iter->second, &start_position, &end_position, &length)) {
 265         // Invalid "Content-Range" value.
 266         return scoped_ptr<net::test_server::HttpResponse>();
 267       }
 268
 269       EXPECT_EQ(start_position, received_bytes_);
 270       EXPECT_EQ(length, content_length_);
 271
 272       // end_position is inclusive, but so +1 to change the range to byte size.
 273       received_bytes_ = end_position + 1;
 274     }
 275
 276     if (received_bytes_ < content_length_) {
 277       scoped_ptr<net::test_server::BasicHttpResponse> response(
 278           new net::test_server::BasicHttpResponse);
 279       // Set RESUME INCOMPLETE (308) status code.
 280       response->set_code(static_cast<net::HttpStatusCode>(308));
 281
 282       // Add Range header to the response, based on the values of
 283       // Content-Range header in the request.
 284       // The header is annotated only when at least one byte is received.
 285       if (received_bytes_ > 0) {
 286         response->AddCustomHeader(
 287             "Range", "bytes=0-" + base::Int64ToString(received_bytes_ - 1));
 288       }
 289
 290       return response.PassAs<net::test_server::HttpResponse>();
 291     }
 292
 293     // All bytes are received. Return the "success" response with the file's
 294     // (dummy) metadata.
 295     scoped_ptr<net::test_server::BasicHttpResponse> response =
 296         test_util::CreateHttpResponseFromFile(
 297             test_util::GetTestFilePath("drive/file_entry.json"));
 298
 299     // The response code is CREATED if it is new file uploading.
 300     if (http_request_.relative_url == kTestUploadNewFilePath) {
 301       response->set_code(net::HTTP_CREATED);
 302     }
 303
 304     return response.PassAs<net::test_server::HttpResponse>();
 305   }
 306
 307   // Returns the response based on set expected content and its type.
 308   // To use this method, both |expected_content_type_| and |expected_content_|
 309   // must be set in advance.
 310   scoped_ptr<net::test_server::HttpResponse> HandleContentResponse(
 311       const net::test_server::HttpRequest& request) {
 312     if (expected_content_type_.empty() || expected_content_.empty()) {
 313       // Expected content is not set. Delegate the processing to the next
 314       // handler.
 315       return scoped_ptr<net::test_server::HttpResponse>();
 316     }
 317
 318     http_request_ = request;
 319
 320     scoped_ptr<net::test_server::BasicHttpResponse> response(
 321         new net::test_server::BasicHttpResponse);
 322     response->set_code(net::HTTP_OK);
 323     response->set_content_type(expected_content_type_);
 324     response->set_content(expected_content_);
 325     return response.PassAs<net::test_server::HttpResponse>();
 326   }
 327
 328   // Handles a request for downloading a file.
 329   scoped_ptr<net::test_server::HttpResponse> HandleDownloadRequest(
 330       const net::test_server::HttpRequest& request) {
 331     http_request_ = request;
 332
 333     const GURL absolute_url = test_server_.GetURL(request.relative_url);
 334     std::string id;
 335     if (!test_util::RemovePrefix(absolute_url.path(),
 336                                  kTestDownloadPathPrefix,
 337                                  &id)) {
 338       return scoped_ptr<net::test_server::HttpResponse>();
 339     }
 340
 341     // For testing, returns a text with |id| repeated 3 times.
 342     scoped_ptr<net::test_server::BasicHttpResponse> response(
 343         new net::test_server::BasicHttpResponse);
 344     response->set_code(net::HTTP_OK);
 345     response->set_content(id + id + id);
 346     response->set_content_type("text/plain");
 347     return response.PassAs<net::test_server::HttpResponse>();
 348   }
 349
 350   // These are for the current upload file status.
 351   int64 received_bytes_;
 352   int64 content_length_;
 353 };
 354
 355 TEST_F(DriveApiRequestsTest, DriveApiDataRequest_Fields) {
 356   // Make sure that "fields" query param is supported by using its subclass,
 357   // AboutGetRequest.
 358
 359   // Set an expected data file containing valid result.
 360   expected_data_file_path_ = test_util::GetTestFilePath(
 361       "drive/about.json");
 362
 363   GDataErrorCode error = GDATA_OTHER_ERROR;
 364   scoped_ptr<AboutResource> about_resource;
 365
 366   {
 367     base::RunLoop run_loop;
 368     drive::AboutGetRequest* request = new drive::AboutGetRequest(
 369         request_sender_.get(),
 370         *url_generator_,
 371         test_util::CreateQuitCallback(
 372             &run_loop,
 373             test_util::CreateCopyResultCallback(&error, &about_resource)));
 374     request->set_fields(
 375         "kind,quotaBytesTotal,quotaBytesUsed,largestChangeId,rootFolderId");
 376     request_sender_->StartRequestWithRetry(request);
 377     run_loop.Run();
 378   }
 379
 380   EXPECT_EQ(HTTP_SUCCESS, error);
 381   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 382   EXPECT_EQ("/drive/v2/about?"
 383             "fields=kind%2CquotaBytesTotal%2CquotaBytesUsed%2C"
 384             "largestChangeId%2CrootFolderId",
 385             http_request_.relative_url);
 386
 387   scoped_ptr<AboutResource> expected(
 388       AboutResource::CreateFrom(
 389           *test_util::LoadJSONFile("drive/about.json")));
 390   ASSERT_TRUE(about_resource.get());
 391   EXPECT_EQ(expected->largest_change_id(), about_resource->largest_change_id());
 392   EXPECT_EQ(expected->quota_bytes_total(), about_resource->quota_bytes_total());
 393   EXPECT_EQ(expected->quota_bytes_used(), about_resource->quota_bytes_used());
 394   EXPECT_EQ(expected->root_folder_id(), about_resource->root_folder_id());
 395 }
 396
 397 TEST_F(DriveApiRequestsTest, FilesInsertRequest) {
 398   // Set an expected data file containing the directory's entry data.
 399   expected_data_file_path_ =
 400       test_util::GetTestFilePath("drive/directory_entry.json");
 401
 402   GDataErrorCode error = GDATA_OTHER_ERROR;
 403   scoped_ptr<FileResource> file_resource;
 404
 405   // Create "new directory" in the root directory.
 406   {
 407     base::RunLoop run_loop;
 408     drive::FilesInsertRequest* request = new drive::FilesInsertRequest(
 409         request_sender_.get(),
 410         *url_generator_,
 411         test_util::CreateQuitCallback(
 412             &run_loop,
 413             test_util::CreateCopyResultCallback(&error, &file_resource)));
 414     request->set_mime_type("application/vnd.google-apps.folder");
 415     request->add_parent("root");
 416     request->set_title("new directory");
 417     request_sender_->StartRequestWithRetry(request);
 418     run_loop.Run();
 419   }
 420
 421   EXPECT_EQ(HTTP_SUCCESS, error);
 422   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 423   EXPECT_EQ("/drive/v2/files", http_request_.relative_url);
 424   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 425
 426   EXPECT_TRUE(http_request_.has_content);
 427
 428   scoped_ptr<FileResource> expected(
 429       FileResource::CreateFrom(
 430           *test_util::LoadJSONFile("drive/directory_entry.json")));
 431
 432   // Sanity check.
 433   ASSERT_TRUE(file_resource.get());
 434
 435   EXPECT_EQ(expected->file_id(), file_resource->file_id());
 436   EXPECT_EQ(expected->title(), file_resource->title());
 437   EXPECT_EQ(expected->mime_type(), file_resource->mime_type());
 438   EXPECT_EQ(expected->parents().size(), file_resource->parents().size());
 439 }
 440
 441 TEST_F(DriveApiRequestsTest, FilesPatchRequest) {
 442   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
 443   const base::Time::Exploded kLastViewedByMeDate =
 444       {2013, 7, 0, 19, 15, 59, 13, 123};
 445
 446   // Set an expected data file containing valid result.
 447   expected_data_file_path_ =
 448       test_util::GetTestFilePath("drive/file_entry.json");
 449
 450   GDataErrorCode error = GDATA_OTHER_ERROR;
 451   scoped_ptr<FileResource> file_resource;
 452
 453   {
 454     base::RunLoop run_loop;
 455     drive::FilesPatchRequest* request = new drive::FilesPatchRequest(
 456         request_sender_.get(),
 457         *url_generator_,
 458         test_util::CreateQuitCallback(
 459             &run_loop,
 460             test_util::CreateCopyResultCallback(&error, &file_resource)));
 461     request->set_file_id("resource_id");
 462     request->set_set_modified_date(true);
 463     request->set_update_viewed_date(false);
 464
 465     request->set_title("new title");
 466     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
 467     request->set_last_viewed_by_me_date(
 468         base::Time::FromUTCExploded(kLastViewedByMeDate));
 469     request->add_parent("parent_resource_id");
 470
 471     request_sender_->StartRequestWithRetry(request);
 472     run_loop.Run();
 473   }
 474
 475   EXPECT_EQ(HTTP_SUCCESS, error);
 476   EXPECT_EQ(net::test_server::METHOD_PATCH, http_request_.method);
 477   EXPECT_EQ("/drive/v2/files/resource_id"
 478             "?setModifiedDate=true&updateViewedDate=false",
 479             http_request_.relative_url);
 480
 481   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 482   EXPECT_TRUE(http_request_.has_content);
 483   EXPECT_EQ("{\"lastViewedByMeDate\":\"2013-07-19T15:59:13.123Z\","
 484             "\"modifiedDate\":\"2012-07-19T15:59:13.123Z\","
 485             "\"parents\":[{\"id\":\"parent_resource_id\"}],"
 486             "\"title\":\"new title\"}",
 487             http_request_.content);
 488   EXPECT_TRUE(file_resource);
 489 }
 490
 491 TEST_F(DriveApiRequestsTest, AboutGetRequest_ValidJson) {
 492   // Set an expected data file containing valid result.
 493   expected_data_file_path_ = test_util::GetTestFilePath(
 494       "drive/about.json");
 495
 496   GDataErrorCode error = GDATA_OTHER_ERROR;
 497   scoped_ptr<AboutResource> about_resource;
 498
 499   {
 500     base::RunLoop run_loop;
 501     drive::AboutGetRequest* request = new drive::AboutGetRequest(
 502         request_sender_.get(),
 503         *url_generator_,
 504         test_util::CreateQuitCallback(
 505             &run_loop,
 506             test_util::CreateCopyResultCallback(&error, &about_resource)));
 507     request_sender_->StartRequestWithRetry(request);
 508     run_loop.Run();
 509   }
 510
 511   EXPECT_EQ(HTTP_SUCCESS, error);
 512   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 513   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
 514
 515   scoped_ptr<AboutResource> expected(
 516       AboutResource::CreateFrom(
 517           *test_util::LoadJSONFile("drive/about.json")));
 518   ASSERT_TRUE(about_resource.get());
 519   EXPECT_EQ(expected->largest_change_id(), about_resource->largest_change_id());
 520   EXPECT_EQ(expected->quota_bytes_total(), about_resource->quota_bytes_total());
 521   EXPECT_EQ(expected->quota_bytes_used(), about_resource->quota_bytes_used());
 522   EXPECT_EQ(expected->root_folder_id(), about_resource->root_folder_id());
 523 }
 524
 525 TEST_F(DriveApiRequestsTest, AboutGetRequest_InvalidJson) {
 526   // Set an expected data file containing invalid result.
 527   expected_data_file_path_ = test_util::GetTestFilePath(
 528       "gdata/testfile.txt");
 529
 530   GDataErrorCode error = GDATA_OTHER_ERROR;
 531   scoped_ptr<AboutResource> about_resource;
 532
 533   {
 534     base::RunLoop run_loop;
 535     drive::AboutGetRequest* request = new drive::AboutGetRequest(
 536         request_sender_.get(),
 537         *url_generator_,
 538         test_util::CreateQuitCallback(
 539             &run_loop,
 540             test_util::CreateCopyResultCallback(&error, &about_resource)));
 541     request_sender_->StartRequestWithRetry(request);
 542     run_loop.Run();
 543   }
 544
 545   // "parse error" should be returned, and the about resource should be NULL.
 546   EXPECT_EQ(GDATA_PARSE_ERROR, error);
 547   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 548   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
 549   EXPECT_FALSE(about_resource);
 550 }
 551
 552 TEST_F(DriveApiRequestsTest, AppsListRequest) {
 553   // Set an expected data file containing valid result.
 554   expected_data_file_path_ = test_util::GetTestFilePath(
 555       "drive/applist.json");
 556
 557   GDataErrorCode error = GDATA_OTHER_ERROR;
 558   scoped_ptr<AppList> app_list;
 559
 560   {
 561     base::RunLoop run_loop;
 562     drive::AppsListRequest* request = new drive::AppsListRequest(
 563         request_sender_.get(),
 564         *url_generator_,
 565         test_util::CreateQuitCallback(
 566             &run_loop,
 567             test_util::CreateCopyResultCallback(&error, &app_list)));
 568     request_sender_->StartRequestWithRetry(request);
 569     run_loop.Run();
 570   }
 571
 572   EXPECT_EQ(HTTP_SUCCESS, error);
 573   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 574   EXPECT_EQ("/drive/v2/apps", http_request_.relative_url);
 575   EXPECT_TRUE(app_list);
 576 }
 577
 578 TEST_F(DriveApiRequestsTest, ChangesListRequest) {
 579   // Set an expected data file containing valid result.
 580   expected_data_file_path_ = test_util::GetTestFilePath(
 581       "drive/changelist.json");
 582
 583   GDataErrorCode error = GDATA_OTHER_ERROR;
 584   scoped_ptr<ChangeList> result;
 585
 586   {
 587     base::RunLoop run_loop;
 588     drive::ChangesListRequest* request = new drive::ChangesListRequest(
 589         request_sender_.get(), *url_generator_,
 590         test_util::CreateQuitCallback(
 591             &run_loop,
 592             test_util::CreateCopyResultCallback(&error, &result)));
 593     request->set_include_deleted(true);
 594     request->set_start_change_id(100);
 595     request->set_max_results(500);
 596     request_sender_->StartRequestWithRetry(request);
 597     run_loop.Run();
 598   }
 599
 600   EXPECT_EQ(HTTP_SUCCESS, error);
 601   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 602   EXPECT_EQ("/drive/v2/changes?maxResults=500&startChangeId=100",
 603             http_request_.relative_url);
 604   EXPECT_TRUE(result);
 605 }
 606
 607 TEST_F(DriveApiRequestsTest, ChangesListNextPageRequest) {
 608   // Set an expected data file containing valid result.
 609   expected_data_file_path_ = test_util::GetTestFilePath(
 610       "drive/changelist.json");
 611
 612   GDataErrorCode error = GDATA_OTHER_ERROR;
 613   scoped_ptr<ChangeList> result;
 614
 615   {
 616     base::RunLoop run_loop;
 617     drive::ChangesListNextPageRequest* request =
 618         new drive::ChangesListNextPageRequest(
 619             request_sender_.get(),
 620             test_util::CreateQuitCallback(
 621                 &run_loop,
 622                 test_util::CreateCopyResultCallback(&error, &result)));
 623     request->set_next_link(test_server_.GetURL("/continue/get/change/list"));
 624     request_sender_->StartRequestWithRetry(request);
 625     run_loop.Run();
 626   }
 627
 628   EXPECT_EQ(HTTP_SUCCESS, error);
 629   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 630   EXPECT_EQ("/continue/get/change/list", http_request_.relative_url);
 631   EXPECT_TRUE(result);
 632 }
 633
 634 TEST_F(DriveApiRequestsTest, FilesCopyRequest) {
 635   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
 636
 637   // Set an expected data file containing the dummy file entry data.
 638   // It'd be returned if we copy a file.
 639   expected_data_file_path_ =
 640       test_util::GetTestFilePath("drive/file_entry.json");
 641
 642   GDataErrorCode error = GDATA_OTHER_ERROR;
 643   scoped_ptr<FileResource> file_resource;
 644
 645   // Copy the file to a new file named "new title".
 646   {
 647     base::RunLoop run_loop;
 648     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
 649         request_sender_.get(),
 650         *url_generator_,
 651         test_util::CreateQuitCallback(
 652             &run_loop,
 653             test_util::CreateCopyResultCallback(&error, &file_resource)));
 654     request->set_file_id("resource_id");
 655     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
 656     request->add_parent("parent_resource_id");
 657     request->set_title("new title");
 658     request_sender_->StartRequestWithRetry(request);
 659     run_loop.Run();
 660   }
 661
 662   EXPECT_EQ(HTTP_SUCCESS, error);
 663   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 664   EXPECT_EQ("/drive/v2/files/resource_id/copy", http_request_.relative_url);
 665   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 666
 667   EXPECT_TRUE(http_request_.has_content);
 668   EXPECT_EQ(
 669       "{\"modifiedDate\":\"2012-07-19T15:59:13.123Z\","
 670       "\"parents\":[{\"id\":\"parent_resource_id\"}],\"title\":\"new title\"}",
 671       http_request_.content);
 672   EXPECT_TRUE(file_resource);
 673 }
 674
 675 TEST_F(DriveApiRequestsTest, FilesCopyRequest_EmptyParentResourceId) {
 676   // Set an expected data file containing the dummy file entry data.
 677   // It'd be returned if we copy a file.
 678   expected_data_file_path_ =
 679       test_util::GetTestFilePath("drive/file_entry.json");
 680
 681   GDataErrorCode error = GDATA_OTHER_ERROR;
 682   scoped_ptr<FileResource> file_resource;
 683
 684   // Copy the file to a new file named "new title".
 685   {
 686     base::RunLoop run_loop;
 687     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
 688         request_sender_.get(),
 689         *url_generator_,
 690         test_util::CreateQuitCallback(
 691             &run_loop,
 692             test_util::CreateCopyResultCallback(&error, &file_resource)));
 693     request->set_file_id("resource_id");
 694     request->set_title("new title");
 695     request_sender_->StartRequestWithRetry(request);
 696     run_loop.Run();
 697   }
 698
 699   EXPECT_EQ(HTTP_SUCCESS, error);
 700   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 701   EXPECT_EQ("/drive/v2/files/resource_id/copy", http_request_.relative_url);
 702   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 703
 704   EXPECT_TRUE(http_request_.has_content);
 705   EXPECT_EQ("{\"title\":\"new title\"}", http_request_.content);
 706   EXPECT_TRUE(file_resource);
 707 }
 708
 709 TEST_F(DriveApiRequestsTest, FilesListRequest) {
 710   // Set an expected data file containing valid result.
 711   expected_data_file_path_ = test_util::GetTestFilePath(
 712       "drive/filelist.json");
 713
 714   GDataErrorCode error = GDATA_OTHER_ERROR;
 715   scoped_ptr<FileList> result;
 716
 717   {
 718     base::RunLoop run_loop;
 719     drive::FilesListRequest* request = new drive::FilesListRequest(
 720         request_sender_.get(), *url_generator_,
 721         test_util::CreateQuitCallback(
 722             &run_loop,
 723             test_util::CreateCopyResultCallback(&error, &result)));
 724     request->set_max_results(50);
 725     request->set_q("\"abcde\" in parents");
 726     request_sender_->StartRequestWithRetry(request);
 727     run_loop.Run();
 728   }
 729
 730   EXPECT_EQ(HTTP_SUCCESS, error);
 731   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 732   EXPECT_EQ("/drive/v2/files?maxResults=50&q=%22abcde%22+in+parents",
 733             http_request_.relative_url);
 734   EXPECT_TRUE(result);
 735 }
 736
 737 TEST_F(DriveApiRequestsTest, FilesListNextPageRequest) {
 738   // Set an expected data file containing valid result.
 739   expected_data_file_path_ = test_util::GetTestFilePath(
 740       "drive/filelist.json");
 741
 742   GDataErrorCode error = GDATA_OTHER_ERROR;
 743   scoped_ptr<FileList> result;
 744
 745   {
 746     base::RunLoop run_loop;
 747     drive::FilesListNextPageRequest* request =
 748         new drive::FilesListNextPageRequest(
 749             request_sender_.get(),
 750             test_util::CreateQuitCallback(
 751                 &run_loop,
 752                 test_util::CreateCopyResultCallback(&error, &result)));
 753     request->set_next_link(test_server_.GetURL("/continue/get/file/list"));
 754     request_sender_->StartRequestWithRetry(request);
 755     run_loop.Run();
 756   }
 757
 758   EXPECT_EQ(HTTP_SUCCESS, error);
 759   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
 760   EXPECT_EQ("/continue/get/file/list", http_request_.relative_url);
 761   EXPECT_TRUE(result);
 762 }
 763
 764 TEST_F(DriveApiRequestsTest, FilesTrashRequest) {
 765   // Set data for the expected result. Directory entry should be returned
 766   // if the trashing entry is a directory, so using it here should be fine.
 767   expected_data_file_path_ =
 768       test_util::GetTestFilePath("drive/directory_entry.json");
 769
 770   GDataErrorCode error = GDATA_OTHER_ERROR;
 771   scoped_ptr<FileResource> file_resource;
 772
 773   // Trash a resource with the given resource id.
 774   {
 775     base::RunLoop run_loop;
 776     drive::FilesTrashRequest* request = new drive::FilesTrashRequest(
 777         request_sender_.get(),
 778         *url_generator_,
 779         test_util::CreateQuitCallback(
 780             &run_loop,
 781             test_util::CreateCopyResultCallback(&error, &file_resource)));
 782     request->set_file_id("resource_id");
 783     request_sender_->StartRequestWithRetry(request);
 784     run_loop.Run();
 785   }
 786
 787   EXPECT_EQ(HTTP_SUCCESS, error);
 788   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 789   EXPECT_EQ("/drive/v2/files/resource_id/trash", http_request_.relative_url);
 790   EXPECT_TRUE(http_request_.has_content);
 791   EXPECT_TRUE(http_request_.content.empty());
 792 }
 793
 794 TEST_F(DriveApiRequestsTest, ChildrenInsertRequest) {
 795   // Set an expected data file containing the children entry.
 796   expected_content_type_ = "application/json";
 797   expected_content_ = kTestChildrenResponse;
 798
 799   GDataErrorCode error = GDATA_OTHER_ERROR;
 800
 801   // Add a resource with "resource_id" to a directory with
 802   // "parent_resource_id".
 803   {
 804     base::RunLoop run_loop;
 805     drive::ChildrenInsertRequest* request = new drive::ChildrenInsertRequest(
 806         request_sender_.get(),
 807         *url_generator_,
 808         test_util::CreateQuitCallback(
 809             &run_loop,
 810             test_util::CreateCopyResultCallback(&error)));
 811     request->set_folder_id("parent_resource_id");
 812     request->set_id("resource_id");
 813     request_sender_->StartRequestWithRetry(request);
 814     run_loop.Run();
 815   }
 816
 817   EXPECT_EQ(HTTP_SUCCESS, error);
 818   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 819   EXPECT_EQ("/drive/v2/files/parent_resource_id/children",
 820             http_request_.relative_url);
 821   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 822
 823   EXPECT_TRUE(http_request_.has_content);
 824   EXPECT_EQ("{\"id\":\"resource_id\"}", http_request_.content);
 825 }
 826
 827 TEST_F(DriveApiRequestsTest, ChildrenDeleteRequest) {
 828   GDataErrorCode error = GDATA_OTHER_ERROR;
 829
 830   // Remove a resource with "resource_id" from a directory with
 831   // "parent_resource_id".
 832   {
 833     base::RunLoop run_loop;
 834     drive::ChildrenDeleteRequest* request = new drive::ChildrenDeleteRequest(
 835         request_sender_.get(),
 836         *url_generator_,
 837         test_util::CreateQuitCallback(
 838             &run_loop,
 839             test_util::CreateCopyResultCallback(&error)));
 840     request->set_child_id("resource_id");
 841     request->set_folder_id("parent_resource_id");
 842     request_sender_->StartRequestWithRetry(request);
 843     run_loop.Run();
 844   }
 845
 846   EXPECT_EQ(HTTP_NO_CONTENT, error);
 847   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
 848   EXPECT_EQ("/drive/v2/files/parent_resource_id/children/resource_id",
 849             http_request_.relative_url);
 850   EXPECT_FALSE(http_request_.has_content);
 851 }
 852
 853 TEST_F(DriveApiRequestsTest, UploadNewFileRequest) {
 854   // Set an expected url for uploading.
 855   expected_upload_path_ = kTestUploadNewFilePath;
 856
 857   const char kTestContentType[] = "text/plain";
 858   const std::string kTestContent(100, 'a');
 859   const base::FilePath kTestFilePath =
 860       temp_dir_.path().AppendASCII("upload_file.txt");
 861   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 862
 863   GDataErrorCode error = GDATA_OTHER_ERROR;
 864   GURL upload_url;
 865
 866   // Initiate uploading a new file to the directory with
 867   // "parent_resource_id".
 868   {
 869     base::RunLoop run_loop;
 870     drive::InitiateUploadNewFileRequest* request =
 871         new drive::InitiateUploadNewFileRequest(
 872             request_sender_.get(),
 873             *url_generator_,
 874             kTestContentType,
 875             kTestContent.size(),
 876             "parent_resource_id",  // The resource id of the parent directory.
 877             "new file title",  // The title of the file being uploaded.
 878             test_util::CreateQuitCallback(
 879                 &run_loop,
 880                 test_util::CreateCopyResultCallback(&error, &upload_url)));
 881     request_sender_->StartRequestWithRetry(request);
 882     run_loop.Run();
 883   }
 884
 885   EXPECT_EQ(HTTP_SUCCESS, error);
 886   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
 887   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
 888   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
 889             http_request_.headers["X-Upload-Content-Length"]);
 890
 891   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 892   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
 893             http_request_.relative_url);
 894   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 895   EXPECT_TRUE(http_request_.has_content);
 896   EXPECT_EQ("{\"parents\":[{"
 897             "\"id\":\"parent_resource_id\","
 898             "\"kind\":\"drive#fileLink\""
 899             "}],"
 900             "\"title\":\"new file title\"}",
 901             http_request_.content);
 902
 903   // Upload the content to the upload URL.
 904   UploadRangeResponse response;
 905   scoped_ptr<FileResource> new_entry;
 906
 907   {
 908     base::RunLoop run_loop;
 909     drive::ResumeUploadRequest* resume_request =
 910         new drive::ResumeUploadRequest(
 911             request_sender_.get(),
 912             upload_url,
 913             0,  // start_position
 914             kTestContent.size(),  // end_position (exclusive)
 915             kTestContent.size(),  // content_length,
 916             kTestContentType,
 917             kTestFilePath,
 918             test_util::CreateQuitCallback(
 919                 &run_loop,
 920                 test_util::CreateCopyResultCallback(&response, &new_entry)),
 921             ProgressCallback());
 922     request_sender_->StartRequestWithRetry(resume_request);
 923     run_loop.Run();
 924   }
 925
 926   // METHOD_PUT should be used to upload data.
 927   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
 928   // Request should go to the upload URL.
 929   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
 930   // Content-Range header should be added.
 931   EXPECT_EQ("bytes 0-" +
 932             base::Int64ToString(kTestContent.size() - 1) + "/" +
 933             base::Int64ToString(kTestContent.size()),
 934             http_request_.headers["Content-Range"]);
 935   // The upload content should be set in the HTTP request.
 936   EXPECT_TRUE(http_request_.has_content);
 937   EXPECT_EQ(kTestContent, http_request_.content);
 938
 939   // Check the response.
 940   EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file
 941   // The start and end positions should be set to -1, if an upload is complete.
 942   EXPECT_EQ(-1, response.start_position_received);
 943   EXPECT_EQ(-1, response.end_position_received);
 944 }
 945
 946 TEST_F(DriveApiRequestsTest, UploadNewEmptyFileRequest) {
 947   // Set an expected url for uploading.
 948   expected_upload_path_ = kTestUploadNewFilePath;
 949
 950   const char kTestContentType[] = "text/plain";
 951   const char kTestContent[] = "";
 952   const base::FilePath kTestFilePath =
 953       temp_dir_.path().AppendASCII("empty_file.txt");
 954   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 955
 956   GDataErrorCode error = GDATA_OTHER_ERROR;
 957   GURL upload_url;
 958
 959   // Initiate uploading a new file to the directory with "parent_resource_id".
 960   {
 961     base::RunLoop run_loop;
 962     drive::InitiateUploadNewFileRequest* request =
 963         new drive::InitiateUploadNewFileRequest(
 964             request_sender_.get(),
 965             *url_generator_,
 966             kTestContentType,
 967             0,
 968             "parent_resource_id",  // The resource id of the parent directory.
 969             "new file title",  // The title of the file being uploaded.
 970             test_util::CreateQuitCallback(
 971                 &run_loop,
 972                 test_util::CreateCopyResultCallback(&error, &upload_url)));
 973     request_sender_->StartRequestWithRetry(request);
 974     run_loop.Run();
 975   }
 976
 977   EXPECT_EQ(HTTP_SUCCESS, error);
 978   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
 979   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
 980   EXPECT_EQ("0", http_request_.headers["X-Upload-Content-Length"]);
 981
 982   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
 983   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
 984             http_request_.relative_url);
 985   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 986   EXPECT_TRUE(http_request_.has_content);
 987   EXPECT_EQ("{\"parents\":[{"
 988             "\"id\":\"parent_resource_id\","
 989             "\"kind\":\"drive#fileLink\""
 990             "}],"
 991             "\"title\":\"new file title\"}",
 992             http_request_.content);
 993
 994   // Upload the content to the upload URL.
 995   UploadRangeResponse response;
 996   scoped_ptr<FileResource> new_entry;
 997
 998   {
 999     base::RunLoop run_loop;
1000     drive::ResumeUploadRequest* resume_request =
1001         new drive::ResumeUploadRequest(
1002             request_sender_.get(),
1003             upload_url,
1004             0,  // start_position
1005             0,  // end_position (exclusive)
1006             0,  // content_length,
1007             kTestContentType,
1008             kTestFilePath,
1009             test_util::CreateQuitCallback(
1010                 &run_loop,
1011                 test_util::CreateCopyResultCallback(&response, &new_entry)),
1012             ProgressCallback());
1013     request_sender_->StartRequestWithRetry(resume_request);
1014     run_loop.Run();
1015   }
1016
1017   // METHOD_PUT should be used to upload data.
1018   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1019   // Request should go to the upload URL.
1020   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1021   // Content-Range header should NOT be added.
1022   EXPECT_EQ(0U, http_request_.headers.count("Content-Range"));
1023   // The upload content should be set in the HTTP request.
1024   EXPECT_TRUE(http_request_.has_content);
1025   EXPECT_EQ(kTestContent, http_request_.content);
1026
1027   // Check the response.
1028   EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file
1029   // The start and end positions should be set to -1, if an upload is complete.
1030   EXPECT_EQ(-1, response.start_position_received);
1031   EXPECT_EQ(-1, response.end_position_received);
1032 }
1033
1034 TEST_F(DriveApiRequestsTest, UploadNewLargeFileRequest) {
1035   // Set an expected url for uploading.
1036   expected_upload_path_ = kTestUploadNewFilePath;
1037
1038   const char kTestContentType[] = "text/plain";
1039   const size_t kNumChunkBytes = 10;  // Num bytes in a chunk.
1040   const std::string kTestContent(100, 'a');
1041   const base::FilePath kTestFilePath =
1042       temp_dir_.path().AppendASCII("upload_file.txt");
1043   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
1044
1045   GDataErrorCode error = GDATA_OTHER_ERROR;
1046   GURL upload_url;
1047
1048   // Initiate uploading a new file to the directory with "parent_resource_id".
1049   {
1050     base::RunLoop run_loop;
1051     drive::InitiateUploadNewFileRequest* request =
1052         new drive::InitiateUploadNewFileRequest(
1053             request_sender_.get(),
1054             *url_generator_,
1055             kTestContentType,
1056             kTestContent.size(),
1057             "parent_resource_id",  // The resource id of the parent directory.
1058             "new file title",  // The title of the file being uploaded.
1059             test_util::CreateQuitCallback(
1060                 &run_loop,
1061                 test_util::CreateCopyResultCallback(&error, &upload_url)));
1062     request_sender_->StartRequestWithRetry(request);
1063     run_loop.Run();
1064   }
1065
1066   EXPECT_EQ(HTTP_SUCCESS, error);
1067   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
1068   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
1069   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
1070             http_request_.headers["X-Upload-Content-Length"]);
1071
1072   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
1073   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
1074             http_request_.relative_url);
1075   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
1076   EXPECT_TRUE(http_request_.has_content);
1077   EXPECT_EQ("{\"parents\":[{"
1078             "\"id\":\"parent_resource_id\","
1079             "\"kind\":\"drive#fileLink\""
1080             "}],"
1081             "\"title\":\"new file title\"}",
1082             http_request_.content);
1083
1084   // Before sending any data, check the current status.
1085   // This is an edge case test for GetUploadStatusRequest.
1086   {
1087     UploadRangeResponse response;
1088     scoped_ptr<FileResource> new_entry;
1089
1090     // Check the response by GetUploadStatusRequest.
1091     {
1092       base::RunLoop run_loop;
1093       drive::GetUploadStatusRequest* get_upload_status_request =
1094           new drive::GetUploadStatusRequest(
1095               request_sender_.get(),
1096               upload_url,
1097               kTestContent.size(),
1098               test_util::CreateQuitCallback(
1099                   &run_loop,
1100                   test_util::CreateCopyResultCallback(&response, &new_entry)));
1101       request_sender_->StartRequestWithRetry(get_upload_status_request);
1102       run_loop.Run();
1103     }
1104
1105     // METHOD_PUT should be used to upload data.
1106     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1107     // Request should go to the upload URL.
1108     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1109     // Content-Range header should be added.
1110     EXPECT_EQ("bytes */" + base::Int64ToString(kTestContent.size()),
1111               http_request_.headers["Content-Range"]);
1112     EXPECT_TRUE(http_request_.has_content);
1113     EXPECT_TRUE(http_request_.content.empty());
1114
1115     // Check the response.
1116     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
1117     EXPECT_EQ(0, response.start_position_received);
1118     EXPECT_EQ(0, response.end_position_received);
1119   }
1120
1121   // Upload the content to the upload URL.
1122   for (size_t start_position = 0; start_position < kTestContent.size();
1123        start_position += kNumChunkBytes) {
1124     const std::string payload = kTestContent.substr(
1125         start_position,
1126         std::min(kNumChunkBytes, kTestContent.size() - start_position));
1127     const size_t end_position = start_position + payload.size();
1128
1129     UploadRangeResponse response;
1130     scoped_ptr<FileResource> new_entry;
1131
1132     {
1133       base::RunLoop run_loop;
1134       drive::ResumeUploadRequest* resume_request =
1135           new drive::ResumeUploadRequest(
1136               request_sender_.get(),
1137               upload_url,
1138               start_position,
1139               end_position,
1140               kTestContent.size(),  // content_length,
1141               kTestContentType,
1142               kTestFilePath,
1143               test_util::CreateQuitCallback(
1144                   &run_loop,
1145                   test_util::CreateCopyResultCallback(&response, &new_entry)),
1146               ProgressCallback());
1147       request_sender_->StartRequestWithRetry(resume_request);
1148       run_loop.Run();
1149     }
1150
1151     // METHOD_PUT should be used to upload data.
1152     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1153     // Request should go to the upload URL.
1154     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1155     // Content-Range header should be added.
1156     EXPECT_EQ("bytes " +
1157               base::Int64ToString(start_position) + "-" +
1158               base::Int64ToString(end_position - 1) + "/" +
1159               base::Int64ToString(kTestContent.size()),
1160               http_request_.headers["Content-Range"]);
1161     // The upload content should be set in the HTTP request.
1162     EXPECT_TRUE(http_request_.has_content);
1163     EXPECT_EQ(payload, http_request_.content);
1164
1165     if (end_position == kTestContent.size()) {
1166       // Check the response.
1167       EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file
1168       // The start and end positions should be set to -1, if an upload is
1169       // complete.
1170       EXPECT_EQ(-1, response.start_position_received);
1171       EXPECT_EQ(-1, response.end_position_received);
1172       break;
1173     }
1174
1175     // Check the response.
1176     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
1177     EXPECT_EQ(0, response.start_position_received);
1178     EXPECT_EQ(static_cast<int64>(end_position), response.end_position_received);
1179
1180     // Check the response by GetUploadStatusRequest.
1181     {
1182       base::RunLoop run_loop;
1183       drive::GetUploadStatusRequest* get_upload_status_request =
1184           new drive::GetUploadStatusRequest(
1185               request_sender_.get(),
1186               upload_url,
1187               kTestContent.size(),
1188               test_util::CreateQuitCallback(
1189                   &run_loop,
1190                   test_util::CreateCopyResultCallback(&response, &new_entry)));
1191       request_sender_->StartRequestWithRetry(get_upload_status_request);
1192       run_loop.Run();
1193     }
1194
1195     // METHOD_PUT should be used to upload data.
1196     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1197     // Request should go to the upload URL.
1198     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1199     // Content-Range header should be added.
1200     EXPECT_EQ("bytes */" + base::Int64ToString(kTestContent.size()),
1201               http_request_.headers["Content-Range"]);
1202     EXPECT_TRUE(http_request_.has_content);
1203     EXPECT_TRUE(http_request_.content.empty());
1204
1205     // Check the response.
1206     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
1207     EXPECT_EQ(0, response.start_position_received);
1208     EXPECT_EQ(static_cast<int64>(end_position),
1209               response.end_position_received);
1210   }
1211 }
1212
1213 TEST_F(DriveApiRequestsTest, UploadExistingFileRequest) {
1214   // Set an expected url for uploading.
1215   expected_upload_path_ = kTestUploadExistingFilePath;
1216
1217   const char kTestContentType[] = "text/plain";
1218   const std::string kTestContent(100, 'a');
1219   const base::FilePath kTestFilePath =
1220       temp_dir_.path().AppendASCII("upload_file.txt");
1221   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
1222
1223   GDataErrorCode error = GDATA_OTHER_ERROR;
1224   GURL upload_url;
1225
1226   // Initiate uploading a new file to the directory with "parent_resource_id".
1227   {
1228     base::RunLoop run_loop;
1229     drive::InitiateUploadExistingFileRequest* request =
1230         new drive::InitiateUploadExistingFileRequest(
1231             request_sender_.get(),
1232             *url_generator_,
1233             kTestContentType,
1234             kTestContent.size(),
1235             "resource_id",  // The resource id of the file to be overwritten.
1236             std::string(),  // No etag.
1237             test_util::CreateQuitCallback(
1238                 &run_loop,
1239                 test_util::CreateCopyResultCallback(&error, &upload_url)));
1240     request_sender_->StartRequestWithRetry(request);
1241     run_loop.Run();
1242   }
1243
1244   EXPECT_EQ(HTTP_SUCCESS, error);
1245   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
1246   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
1247   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
1248             http_request_.headers["X-Upload-Content-Length"]);
1249   EXPECT_EQ("*", http_request_.headers["If-Match"]);
1250
1251   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1252   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
1253             http_request_.relative_url);
1254   EXPECT_TRUE(http_request_.has_content);
1255   EXPECT_TRUE(http_request_.content.empty());
1256
1257   // Upload the content to the upload URL.
1258   UploadRangeResponse response;
1259   scoped_ptr<FileResource> new_entry;
1260
1261   {
1262     base::RunLoop run_loop;
1263     drive::ResumeUploadRequest* resume_request =
1264         new drive::ResumeUploadRequest(
1265             request_sender_.get(),
1266             upload_url,
1267             0,  // start_position
1268             kTestContent.size(),  // end_position (exclusive)
1269             kTestContent.size(),  // content_length,
1270             kTestContentType,
1271             kTestFilePath,
1272             test_util::CreateQuitCallback(
1273                 &run_loop,
1274                 test_util::CreateCopyResultCallback(&response, &new_entry)),
1275             ProgressCallback());
1276     request_sender_->StartRequestWithRetry(resume_request);
1277     run_loop.Run();
1278   }
1279
1280   // METHOD_PUT should be used to upload data.
1281   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1282   // Request should go to the upload URL.
1283   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1284   // Content-Range header should be added.
1285   EXPECT_EQ("bytes 0-" +
1286             base::Int64ToString(kTestContent.size() - 1) + "/" +
1287             base::Int64ToString(kTestContent.size()),
1288             http_request_.headers["Content-Range"]);
1289   // The upload content should be set in the HTTP request.
1290   EXPECT_TRUE(http_request_.has_content);
1291   EXPECT_EQ(kTestContent, http_request_.content);
1292
1293   // Check the response.
1294   EXPECT_EQ(HTTP_SUCCESS, response.code);  // Because it's an existing file
1295   // The start and end positions should be set to -1, if an upload is complete.
1296   EXPECT_EQ(-1, response.start_position_received);
1297   EXPECT_EQ(-1, response.end_position_received);
1298 }
1299
1300 TEST_F(DriveApiRequestsTest, UploadExistingFileRequestWithETag) {
1301   // Set an expected url for uploading.
1302   expected_upload_path_ = kTestUploadExistingFilePath;
1303
1304   const char kTestContentType[] = "text/plain";
1305   const std::string kTestContent(100, 'a');
1306   const base::FilePath kTestFilePath =
1307       temp_dir_.path().AppendASCII("upload_file.txt");
1308   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
1309
1310   GDataErrorCode error = GDATA_OTHER_ERROR;
1311   GURL upload_url;
1312
1313   // Initiate uploading a new file to the directory with "parent_resource_id".
1314   {
1315     base::RunLoop run_loop;
1316     drive::InitiateUploadExistingFileRequest* request =
1317         new drive::InitiateUploadExistingFileRequest(
1318             request_sender_.get(),
1319             *url_generator_,
1320             kTestContentType,
1321             kTestContent.size(),
1322             "resource_id",  // The resource id of the file to be overwritten.
1323             kTestETag,
1324             test_util::CreateQuitCallback(
1325                 &run_loop,
1326                 test_util::CreateCopyResultCallback(&error, &upload_url)));
1327     request_sender_->StartRequestWithRetry(request);
1328     run_loop.Run();
1329   }
1330
1331   EXPECT_EQ(HTTP_SUCCESS, error);
1332   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
1333   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
1334   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
1335             http_request_.headers["X-Upload-Content-Length"]);
1336   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
1337
1338   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1339   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
1340             http_request_.relative_url);
1341   EXPECT_TRUE(http_request_.has_content);
1342   EXPECT_TRUE(http_request_.content.empty());
1343
1344   // Upload the content to the upload URL.
1345   UploadRangeResponse response;
1346   scoped_ptr<FileResource> new_entry;
1347
1348   {
1349     base::RunLoop run_loop;
1350     drive::ResumeUploadRequest* resume_request =
1351         new drive::ResumeUploadRequest(
1352             request_sender_.get(),
1353             upload_url,
1354             0,  // start_position
1355             kTestContent.size(),  // end_position (exclusive)
1356             kTestContent.size(),  // content_length,
1357             kTestContentType,
1358             kTestFilePath,
1359             test_util::CreateQuitCallback(
1360                 &run_loop,
1361                 test_util::CreateCopyResultCallback(&response, &new_entry)),
1362             ProgressCallback());
1363     request_sender_->StartRequestWithRetry(resume_request);
1364     run_loop.Run();
1365   }
1366
1367   // METHOD_PUT should be used to upload data.
1368   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1369   // Request should go to the upload URL.
1370   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1371   // Content-Range header should be added.
1372   EXPECT_EQ("bytes 0-" +
1373             base::Int64ToString(kTestContent.size() - 1) + "/" +
1374             base::Int64ToString(kTestContent.size()),
1375             http_request_.headers["Content-Range"]);
1376   // The upload content should be set in the HTTP request.
1377   EXPECT_TRUE(http_request_.has_content);
1378   EXPECT_EQ(kTestContent, http_request_.content);
1379
1380   // Check the response.
1381   EXPECT_EQ(HTTP_SUCCESS, response.code);  // Because it's an existing file
1382   // The start and end positions should be set to -1, if an upload is complete.
1383   EXPECT_EQ(-1, response.start_position_received);
1384   EXPECT_EQ(-1, response.end_position_received);
1385 }
1386
1387 TEST_F(DriveApiRequestsTest, UploadExistingFileRequestWithETagConflicting) {
1388   // Set an expected url for uploading.
1389   expected_upload_path_ = kTestUploadExistingFilePath;
1390
1391   // If it turned out that the etag is conflicting, PRECONDITION_FAILED should
1392   // be returned.
1393   expected_precondition_failed_file_path_ =
1394       test_util::GetTestFilePath("drive/error.json");
1395
1396   const char kTestContentType[] = "text/plain";
1397   const std::string kTestContent(100, 'a');
1398
1399   GDataErrorCode error = GDATA_OTHER_ERROR;
1400   GURL upload_url;
1401
1402   // Initiate uploading a new file to the directory with "parent_resource_id".
1403   {
1404     base::RunLoop run_loop;
1405     drive::InitiateUploadExistingFileRequest* request =
1406         new drive::InitiateUploadExistingFileRequest(
1407             request_sender_.get(),
1408             *url_generator_,
1409             kTestContentType,
1410             kTestContent.size(),
1411             "resource_id",  // The resource id of the file to be overwritten.
1412             "Conflicting-etag",
1413             test_util::CreateQuitCallback(
1414                 &run_loop,
1415                 test_util::CreateCopyResultCallback(&error, &upload_url)));
1416     request_sender_->StartRequestWithRetry(request);
1417     run_loop.Run();
1418   }
1419
1420   EXPECT_EQ(HTTP_PRECONDITION, error);
1421   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
1422   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
1423             http_request_.headers["X-Upload-Content-Length"]);
1424   EXPECT_EQ("Conflicting-etag", http_request_.headers["If-Match"]);
1425
1426   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1427   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
1428             http_request_.relative_url);
1429   EXPECT_TRUE(http_request_.has_content);
1430   EXPECT_TRUE(http_request_.content.empty());
1431 }
1432
1433 TEST_F(DriveApiRequestsTest,
1434        UploadExistingFileRequestWithETagConflictOnResumeUpload) {
1435   // Set an expected url for uploading.
1436   expected_upload_path_ = kTestUploadExistingFilePath;
1437
1438   const char kTestContentType[] = "text/plain";
1439   const std::string kTestContent(100, 'a');
1440   const base::FilePath kTestFilePath =
1441       temp_dir_.path().AppendASCII("upload_file.txt");
1442   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
1443
1444   GDataErrorCode error = GDATA_OTHER_ERROR;
1445   GURL upload_url;
1446
1447   // Initiate uploading a new file to the directory with "parent_resource_id".
1448   {
1449     base::RunLoop run_loop;
1450     drive::InitiateUploadExistingFileRequest* request =
1451         new drive::InitiateUploadExistingFileRequest(
1452             request_sender_.get(),
1453             *url_generator_,
1454             kTestContentType,
1455             kTestContent.size(),
1456             "resource_id",  // The resource id of the file to be overwritten.
1457             kTestETag,
1458             test_util::CreateQuitCallback(
1459                 &run_loop,
1460                 test_util::CreateCopyResultCallback(&error, &upload_url)));
1461     request_sender_->StartRequestWithRetry(request);
1462     run_loop.Run();
1463   }
1464
1465   EXPECT_EQ(HTTP_SUCCESS, error);
1466   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
1467   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
1468   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
1469             http_request_.headers["X-Upload-Content-Length"]);
1470   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
1471
1472   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1473   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
1474             http_request_.relative_url);
1475   EXPECT_TRUE(http_request_.has_content);
1476   EXPECT_TRUE(http_request_.content.empty());
1477
1478   // Set PRECONDITION_FAILED to the server. This is the emulation of the
1479   // confliction during uploading.
1480   expected_precondition_failed_file_path_ =
1481       test_util::GetTestFilePath("drive/error.json");
1482
1483   // Upload the content to the upload URL.
1484   UploadRangeResponse response;
1485   scoped_ptr<FileResource> new_entry;
1486
1487   {
1488     base::RunLoop run_loop;
1489     drive::ResumeUploadRequest* resume_request =
1490         new drive::ResumeUploadRequest(
1491             request_sender_.get(),
1492             upload_url,
1493             0,  // start_position
1494             kTestContent.size(),  // end_position (exclusive)
1495             kTestContent.size(),  // content_length,
1496             kTestContentType,
1497             kTestFilePath,
1498             test_util::CreateQuitCallback(
1499                 &run_loop,
1500                 test_util::CreateCopyResultCallback(&response, &new_entry)),
1501             ProgressCallback());
1502     request_sender_->StartRequestWithRetry(resume_request);
1503     run_loop.Run();
1504   }
1505
1506   // METHOD_PUT should be used to upload data.
1507   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
1508   // Request should go to the upload URL.
1509   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
1510   // Content-Range header should be added.
1511   EXPECT_EQ("bytes 0-" +
1512             base::Int64ToString(kTestContent.size() - 1) + "/" +
1513             base::Int64ToString(kTestContent.size()),
1514             http_request_.headers["Content-Range"]);
1515   // The upload content should be set in the HTTP request.
1516   EXPECT_TRUE(http_request_.has_content);
1517   EXPECT_EQ(kTestContent, http_request_.content);
1518
1519   // Check the response.
1520   EXPECT_EQ(HTTP_PRECONDITION, response.code);
1521   // The start and end positions should be set to -1 for error.
1522   EXPECT_EQ(-1, response.start_position_received);
1523   EXPECT_EQ(-1, response.end_position_received);
1524
1525   // New entry should be NULL.
1526   EXPECT_FALSE(new_entry.get());
1527 }
1528
1529 TEST_F(DriveApiRequestsTest, DownloadFileRequest) {
1530   const base::FilePath kDownloadedFilePath =
1531       temp_dir_.path().AppendASCII("cache_file");
1532   const std::string kTestId("dummyId");
1533
1534   GDataErrorCode result_code = GDATA_OTHER_ERROR;
1535   base::FilePath temp_file;
1536   {
1537     base::RunLoop run_loop;
1538     drive::DownloadFileRequest* request = new drive::DownloadFileRequest(
1539         request_sender_.get(),
1540         *url_generator_,
1541         kTestId,
1542         kDownloadedFilePath,
1543         test_util::CreateQuitCallback(
1544             &run_loop,
1545             test_util::CreateCopyResultCallback(&result_code, &temp_file)),
1546         GetContentCallback(),
1547         ProgressCallback());
1548     request_sender_->StartRequestWithRetry(request);
1549     run_loop.Run();
1550   }
1551
1552   std::string contents;
1553   base::ReadFileToString(temp_file, &contents);
1554   base::DeleteFile(temp_file, false);
1555
1556   EXPECT_EQ(HTTP_SUCCESS, result_code);
1557   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
1558   EXPECT_EQ(kTestDownloadPathPrefix + kTestId, http_request_.relative_url);
1559   EXPECT_EQ(kDownloadedFilePath, temp_file);
1560
1561   const std::string expected_contents = kTestId + kTestId + kTestId;
1562   EXPECT_EQ(expected_contents, contents);
1563 }
1564
1565 TEST_F(DriveApiRequestsTest, DownloadFileRequest_GetContentCallback) {
1566   const base::FilePath kDownloadedFilePath =
1567       temp_dir_.path().AppendASCII("cache_file");
1568   const std::string kTestId("dummyId");
1569
1570   GDataErrorCode result_code = GDATA_OTHER_ERROR;
1571   base::FilePath temp_file;
1572   std::string contents;
1573   {
1574     base::RunLoop run_loop;
1575     drive::DownloadFileRequest* request = new drive::DownloadFileRequest(
1576         request_sender_.get(),
1577         *url_generator_,
1578         kTestId,
1579         kDownloadedFilePath,
1580         test_util::CreateQuitCallback(
1581             &run_loop,
1582             test_util::CreateCopyResultCallback(&result_code, &temp_file)),
1583         base::Bind(&AppendContent, &contents),
1584         ProgressCallback());
1585     request_sender_->StartRequestWithRetry(request);
1586     run_loop.Run();
1587   }
1588
1589   base::DeleteFile(temp_file, false);
1590
1591   EXPECT_EQ(HTTP_SUCCESS, result_code);
1592   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
1593   EXPECT_EQ(kTestDownloadPathPrefix + kTestId, http_request_.relative_url);
1594   EXPECT_EQ(kDownloadedFilePath, temp_file);
1595
1596   const std::string expected_contents = kTestId + kTestId + kTestId;
1597   EXPECT_EQ(expected_contents, contents);
1598 }
1599
1600 }  // namespace google_apis