Implement GetUploadStatusOperation on GData WAPI.

chrome/browser/google_apis/gdata_wapi_operations_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 207 matching lines @@
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     if (absolute_url.path() ==
         // This is an upload URL of the root directory.
         "/feeds/upload/create-session/default/private/full" ||
         absolute_url.path() ==
         // This is an upload URL of an existing file.
         "/feeds/upload/create-session/default/private/full/file:foo") {
       scoped_ptr<test_server::HttpResponse> http_response(
           new test_server::HttpResponse);
 
+      // Check an ETag.
       std::map<std::string, std::string>::const_iterator found =
           request.headers.find("If-Match");
       if (found != request.headers.end() &&
           found->second != "*" &&
           found->second != kTestETag) {
         http_response->set_code(test_server::PRECONDITION);
         return http_response.Pass();
       }
 
+      // Check if the X-Upload-Content-Length is present. If yes, store the
+      // length of the file.
+      found = request.headers.find("X-Upload-Content-Length");
+      if (found == request.headers.end() ||
+          !base::StringToInt64(found->second, &content_length_)) {
+        return scoped_ptr<test_server::HttpResponse>();
+      }
+      start_position_ = 0;
+      end_position_ = 0;
+
       http_response->set_code(test_server::SUCCESS);
       GURL upload_url;
       // POST is used for a new file, and PUT is used for an existing file.
       if (request.method == test_server::METHOD_POST) {
         upload_url = test_server_.GetURL("/upload_new_file");
       } else if (request.method == test_server::METHOD_PUT) {
         upload_url = test_server_.GetURL("/upload_existing_file");
       } else {
         return scoped_ptr<test_server::HttpResponse>();
       }
@@ skipping 25 matching lines @@
     if (absolute_url.path() == "/upload_new_file")
       response->set_code(test_server::CREATED);
 
     // Check if the Content-Range header is present. This must be present if
     // the request body is not empty.
     if (!request.content.empty()) {
       std::map<std::string, std::string>::const_iterator iter =
           request.headers.find("Content-Range");
       if (iter == request.headers.end())
         return scoped_ptr<test_server::HttpResponse>();
-      int64 start_position = 0;
-      int64 end_position = 0;
       int64 length = 0;
       if (!ParseContentRangeHeader(iter->second,
-                                   &start_position,
-                                   &end_position,
+                                   &start_position_,
+                                   &end_position_,
                                    &length)) {
         return scoped_ptr<test_server::HttpResponse>();
       }
+      EXPECT_EQ(length, content_length_);
+    }
 
-      // Add Range header to the response, based on the values of
-      // Content-Range header in the request.
-      response->AddCustomHeader(
-          "Range",
-          "bytes=" +
-          base::Int64ToString(start_position) + "-" +
-          base::Int64ToString(end_position));
+    // Add Range header to the response, based on the values of
+    // Content-Range header in the request.
+    response->AddCustomHeader(
+        "Range",
+        "bytes=" +
+        base::Int64ToString(start_position_) + "-" +
+        base::Int64ToString(end_position_));
 
-      // Change the code to RESUME_INCOMPLETE if upload is not complete.
-      if (end_position + 1 < length)
-        response->set_code(test_server::RESUME_INCOMPLETE);
-    }
+    // Change the code to RESUME_INCOMPLETE if upload is not complete.
+    if (end_position_ + 1 < content_length_)
+      response->set_code(test_server::RESUME_INCOMPLETE);
 
     return response.Pass();
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
   test_server::HttpServer test_server_;
   scoped_ptr<TestingProfile> profile_;
   OperationRegistry operation_registry_;
   scoped_ptr<GDataWapiUrlGenerator> url_generator_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
 
+  // These fields are used to keep the current upload state during a
+  // test case.
+  int64 start_position_;
+  int64 end_position_;
+  int64 content_length_;

[hashimoto, 2013/02/07 06:56:13]

Do we need to keep the values of start_position and end_position?
nit: Please initialize these variables in the ctor.

[hidehiko, 2013/02/07 07:44:07]

Yes, it is necessary to keep them.
This class is not only text fixture but also the http test server. The request
from ResumeUploadOperation updates these fields, and it is necessary to include
these "previously updated" values to the response for GetUploadOperation to
emulate the server's behavior. Added a bit more comment.


Initialized in SetUp().

[hashimoto, 2013/02/07 07:56:10]

I see, thanks.

+
   // The incoming HTTP request is saved so tests can verify the request
   // parameters like HTTP method (ex. some operations should use DELETE
   // instead of GET).
   test_server::HttpRequest http_request_;
 };
 
 }  // namespace
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_DefaultFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
@@ skipping 531 matching lines @@
 
   // Check the response.
   EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file
   // The start and end positions should be set to -1, if an upload is complete.
   EXPECT_EQ(-1, response.start_position_received);
   EXPECT_EQ(-1, response.end_position_received);
 }
 
 // This test exercises InitiateUploadOperation and ResumeUploadOperation for
 // a scenario of uploading a new *large* file, which requires multiple requests
-// of ResumeUploadOperation.
+// of ResumeUploadOperation. GetUploadOperation is also testes in this test

[hashimoto, 2013/02/07 06:56:13]

nit: s/testes/tested/?

[hidehiko, 2013/02/07 07:44:07]

Good catch. Fixed.

+// case.
 TEST_F(GDataWapiOperationsTest, UploadNewLargeFile) {
   const size_t kMaxNumBytes = 10;
   // This is big enough to cause multiple requests of ResumeUploadOperation
   // as we are going to send at most kMaxNumBytes at a time.
   const std::string kUploadContent(kMaxNumBytes + 1, 'a');
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadParams initiate_params(
@@ skipping 93 matching lines @@
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_EQ(payload, http_request_.content);
 
     // Check the response.
     if (payload.size() == remaining_size) {
       EXPECT_EQ(HTTP_CREATED, response.code);  // Because it's a new file.
       // The start and end positions should be set to -1, if an upload is
       // complete.
       EXPECT_EQ(-1, response.start_position_received);
       EXPECT_EQ(-1, response.end_position_received);
-    } else {
-      EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
-      EXPECT_EQ(static_cast<int64>(start_position),
-                response.start_position_received);
-      EXPECT_EQ(static_cast<int64>(end_position),
-                response.end_position_received);
+      // The upload process is completed, so exit from the loop.
+      break;
     }
+
+    EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
+    EXPECT_EQ(static_cast<int64>(start_position),
+              response.start_position_received);
+    EXPECT_EQ(static_cast<int64>(end_position),
+              response.end_position_received);
+
+    // Check the response by GetUploadStatusOperation.
+    GetUploadStatusOperation* get_upload_status_operation =
+        new GetUploadStatusOperation(
+            &operation_registry_,
+            request_context_getter_.get(),
+            base::Bind(&CopyResultFromUploadRangeCallbackAndQuit,
+                       &response,
+                       &new_entry),
+            UPLOAD_NEW_FILE,
+            FilePath::FromUTF8Unsafe("drive/newfile.txt"),
+            upload_url,
+            kUploadContent.size());

[hashimoto, 2013/02/07 06:56:13]

Could you also test the content_length==1 case?

[hidehiko, 2013/02/07 07:44:07]

Sorry, I don't understand your request now...
The content_length must be shared with the one for InitiateUploadParams. Here,
it is kUploadContent.size().

[hashimoto, 2013/02/07 07:56:10]

Sorry, not 1, -1.
In gdata_wapi_operations.h, you added a comment "|content_length| is the whole
data size to be uploaded, or -1 if it is unknown."
And it seems there is no test for the -1 case.

[kinaba, 2013/02/07 08:01:10]

The case has gone away when the streamed uploading (via DownloadObserver) is
removed.
We can (and should) erase mentions to the -1 case.

[hidehiko, 2013/02/07 08:37:56]

So, I've just removed -1 support from ResumeUploadOperation and
GetUploadStatusOperation.

+    get_upload_status_operation->Start(
+        kTestGDataAuthToken, kTestUserAgent,
+        base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+    MessageLoop::current()->Run();
+
+    // METHOD_PUT should be used to upload data.
+    EXPECT_EQ(test_server::METHOD_PUT, http_request_.method);
+    // Request should go to the upload URL.
+    EXPECT_EQ(upload_url.path(), http_request_.relative_url);
+    // Content-Range header should be added.
+    EXPECT_EQ("bytes */" + base::Int64ToString(kUploadContent.size()),
+              http_request_.headers["Content-Range"]);
+    EXPECT_TRUE(http_request_.has_content);
+    EXPECT_TRUE(http_request_.content.empty());
+
+    // Check the response.
+    EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
+    EXPECT_EQ(static_cast<int64>(start_position),
+              response.start_position_received);
+    EXPECT_EQ(static_cast<int64>(end_position),
+              response.end_position_received);
   }
 
   EXPECT_EQ(kUploadContent.size(), num_bytes_consumed);
 }
 
 // This test exercises InitiateUploadOperation and ResumeUploadOperation for
 // a scenario of uploading a new *empty* file.
 //
 // The test is almost identical to UploadNewFile. The only difference is the
 // expectation for the Content-Range header.
@@ skipping 334 matching lines @@
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ(kWrongETag, http_request_.headers["If-Match"]);
 }
 
 }  // namespace google_apis