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 109 matching lines @@
                    base::Unretained(this)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleCreateSessionRequest,
                    base::Unretained(this)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleUploadRequest,
                    base::Unretained(this)));
 
     url_generator_.reset(new GDataWapiUrlGenerator(
         test_util::GetBaseUrlForTesting(test_server_.port())));
+
+    start_position_ = 0;
+    end_position_ = 0;
+    content_length_ = 0;
   }
 
   virtual void TearDown() OVERRIDE {
     test_server_.ShutdownAndWaitUntilComplete();
     request_context_getter_ = NULL;
   }
 
  protected:
   // Handles a request for fetching a resource feed.
   scoped_ptr<test_server::HttpResponse> HandleResourceFeedRequest(
@@ skipping 78 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;

[kinaba, 2013/02/07 09:06:12]

Theoretically, it should be end_position_ = -1, since we are dealing with
[start,end] range rather than [start,end). By the way, what the real server
returns in case no bytes are uploaded yet? It looks it can indeed happen when
the first chunk uploading returned 5xx.

[hidehiko, 2013/02/08 09:17:00]

Changed to use received_bytes_.

+
       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_) + "-" +

[kinaba, 2013/02/07 09:06:12]

Correct me if I'm wrong,

When data is uploaded, the "Range"'s left hand side value is the start index of
the uploaded data (i.e., the value of Content-Range request header). On the
other hand, for GetUploadStatusOperation case,
https://developers.google.com/drive/manage-uploads says "the Range header in its
response to specify which bytes it has received so far", so to me the left value
is always 0.

If that's the case, two different things are mixed here. Could you clarify this?

[hidehiko, 2013/02/08 09:17:00]

The server will return no Range header, if there is no received bytes. Changed
the this server's behavior, its handling in gdata_wapi_operations.cc and added
its test case (see below).

Thank you for catching it!

+        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. These values are updated by the request from
+  // ResumeUploadOperation, and used to construct the response for
+  // both ResumeUploadOperation and GetUploadStatusOperation, to emulate
+  // the WAPI server.
+  int64 start_position_;
+  int64 end_position_;
+  int64 content_length_;
+
   // 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 tested in this test
+// 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());
+    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