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())));
+
+    received_bytes_ = 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>();
+      }
+      received_bytes_ = 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 length = 0;
       int64 start_position = 0;
       int64 end_position = 0;
-      int64 length = 0;
       if (!ParseContentRangeHeader(iter->second,
                                    &start_position,
                                    &end_position,
                                    &length)) {
         return scoped_ptr<test_server::HttpResponse>();
       }
+      EXPECT_EQ(start_position, received_bytes_);
+      EXPECT_EQ(length, content_length_);
+      // end_position is inclusive, but so +1 to change the range to byte size.
+      received_bytes_ = end_position + 1;
+    }
 
-      // Add Range header to the response, based on the values of
-      // Content-Range header in the request.
+    // Add Range header to the response, based on the values of
+    // Content-Range header in the request.
+    // The header is annotated only when at least one byte is received.
+    if (received_bytes_ > 0) {
       response->AddCustomHeader(
           "Range",
-          "bytes=" +
-          base::Int64ToString(start_position) + "-" +
-          base::Int64ToString(end_position));
+          "bytes=0-" + base::Int64ToString(received_bytes_ - 1));

[kinaba, 2013/02/08 10:19:43]

Is 0- the expected response when we have non-empty request content? (I think it
is ok for the case when the content is empty and just querying the current
status.)

At least, the expectation below
doesn't look so. I'm unsure about the real behavior of the production server,
but either here or the expectation looks requiring modification.

[hidehiko, 2013/02/08 11:53:10]

The actual server returns 0-end if there is (one or more) received bytes.
Fixed tests below.

+    }
 
-      // 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 (received_bytes_ < 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 received_bytes_;
+  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');

[kinaba, 2013/02/08 10:19:43]

In order to catch the above commented case, could you change the case here to 2
* kMaxNumBytes + 1? Then we can exercise the non-start and non-end case.

[hidehiko, 2013/02/08 11:53:10]

Done.

   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadParams initiate_params(
       UPLOAD_NEW_FILE,
       "New file",
       "text/plain",
       kUploadContent.size(),
       test_server_.GetURL("/feeds/upload/create-session/default/private/full"),
@@ skipping 26 matching lines @@
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <title>New file</title>\n"
             "</entry>\n",
             http_request_.content);
 
-  // 2) Upload the content to the upload URL with multiple requests.
+  // 2) Before sending any data, check the current status.

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

Hmm, the diff looks not good.
What I did is inserting the 2) block here to test no Range header case, and
re-number 2) to 3).

+  // This is an edge case test for GetUploadStatusOperation
+  // (UploadRangeOperationBase).
+  {
+    // 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(0, response.start_position_received);
+    EXPECT_EQ(0, response.end_position_received);
+  }
+
+  // 3) Upload the content to the upload URL with multiple requests.
   size_t num_bytes_consumed = 0;
   for (size_t start_position = 0; start_position < kUploadContent.size();
        start_position += kMaxNumBytes) {
     SCOPED_TRACE(testing::Message("start_position: ") << start_position);
 
     // The payload is at most kMaxNumBytes.
     const size_t remaining_size = kUploadContent.size() - start_position;
     const std::string payload = kUploadContent.substr(
         start_position, std::min(kMaxNumBytes, remaining_size));
     num_bytes_consumed += payload.size();
@@ skipping 41 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