Add support for setting properties to requests uploading contents.

google_apis/drive/drive_api_requests_unittest.cc

 // Copyright (c) 2013 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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 44 matching lines @@
                    scoped_ptr<std::string> content) {
   EXPECT_EQ(HTTP_SUCCESS, error);
   out->append(*content);
 }
 
 }  // namespace
 
 class DriveApiRequestsTest : public testing::Test {
  public:
   DriveApiRequestsTest() {
+    // Testing properties used by multiple test cases.
+    drive::Property private_property;
+    private_property.set_key("key1");
+    private_property.set_value("value1");
+
+    drive::Property public_property;
+    public_property.set_visibility(drive::Property::VISIBILITY_PUBLIC);
+    public_property.set_key("key2");
+    public_property.set_value("value2");
+
+    testing_properties_.push_back(private_property);
+    testing_properties_.push_back(public_property);

[hashimoto, 2015/02/23 10:16:20]

nit: Initialization order and declaration order should match. It's better to
initialize |testing_properties_| in SetUp() after other members.

[mtomasz, 2015/02/24 02:30:38]

Done.

   }
 
   void SetUp() override {
     request_context_getter_ = new net::TestURLRequestContextGetter(
         message_loop_.message_loop_proxy());
 
     request_sender_.reset(new RequestSender(new DummyAuthService,
                                             request_context_getter_.get(),
                                             message_loop_.message_loop_proxy(),
                                             kTestUserAgent));
@@ skipping 58 matching lines @@
   // These are content and its type in the expected response from the server.
   // See also HandleContentResponse below.
   std::string expected_content_type_;
   std::string expected_content_;
 
   // The incoming HTTP request is saved so tests can verify the request
   // parameters like HTTP method (ex. some requests should use DELETE
   // instead of GET).
   net::test_server::HttpRequest http_request_;
 
+  // Testing properties used by multiple test cases.
+  drive::Properties testing_properties_;
+
  private:
   void ResetExpectedResponse() {
     expected_data_file_path_.clear();
     expected_upload_path_.clear();
     expected_content_type_.clear();
     expected_content_.clear();
   }
 
   // For "Children: delete" request, the server will return "204 No Content"
   // response meaning "success".
@@ skipping 291 matching lines @@
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
     request->set_mime_type("application/vnd.google-apps.folder");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->add_parent("root");
     request->set_title("new directory");
+    request->set_properties(testing_properties_);
     request_sender_->StartRequestWithRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files", http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
-  EXPECT_EQ("{\"lastViewedByMeDate\":\"2013-07-19T15:59:13.123Z\","
-            "\"mimeType\":\"application/vnd.google-apps.folder\","
-            "\"modifiedDate\":\"2012-07-19T15:59:13.123Z\","
-            "\"parents\":[{\"id\":\"root\"}],"
-            "\"title\":\"new directory\"}",
-            http_request_.content);
+  EXPECT_EQ(
+      "{\"lastViewedByMeDate\":\"2013-07-19T15:59:13.123Z\","
+      "\"mimeType\":\"application/vnd.google-apps.folder\","
+      "\"modifiedDate\":\"2012-07-19T15:59:13.123Z\","
+      "\"parents\":[{\"id\":\"root\"}],"
+      "\"properties\":["
+      "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
+      "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}],"
+      "\"title\":\"new directory\"}",
+      http_request_.content);
 
   scoped_ptr<FileResource> expected(
       FileResource::CreateFrom(
           *test_util::LoadJSONFile("drive/directory_entry.json")));
 
   // Sanity check.
   ASSERT_TRUE(file_resource.get());
 
   EXPECT_EQ(expected->file_id(), file_resource->file_id());
   EXPECT_EQ(expected->title(), file_resource->title());
@@ skipping 24 matching lines @@
     request->set_file_id("resource_id");
     request->set_set_modified_date(true);
     request->set_update_viewed_date(false);
 
     request->set_title("new title");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
     request->add_parent("parent_resource_id");
 
-    drive::Property private_property;
-    private_property.set_key("key1");
-    private_property.set_value("value1");
-
-    drive::Property public_property;
-    public_property.set_visibility(drive::Property::VISIBILITY_PUBLIC);
-    public_property.set_key("key2");
-    public_property.set_value("value2");
-
-    drive::Properties properties;
-    properties.push_back(private_property);
-    properties.push_back(public_property);
-    request->set_properties(properties);
-
+    request->set_properties(testing_properties_);
     request_sender_->StartRequestWithRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_PATCH, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id"
             "?setModifiedDate=true&updateViewedDate=false",
             http_request_.relative_url);
 
@@ skipping 419 matching lines @@
         new drive::InitiateUploadNewFileRequest(
             request_sender_.get(),
             *url_generator_,
             kTestContentType,
             kTestContent.size(),
             "parent_resource_id",  // The resource id of the parent directory.
             "new file title",  // The title of the file being uploaded.
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request->set_properties(testing_properties_);
     request_sender_->StartRequestWithRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
   EXPECT_TRUE(http_request_.has_content);
-  EXPECT_EQ("{\"parents\":[{"
-            "\"id\":\"parent_resource_id\","
-            "\"kind\":\"drive#fileLink\""
-            "}],"
-            "\"title\":\"new file title\"}",
-            http_request_.content);
+  EXPECT_EQ(
+      "{\"parents\":[{"
+      "\"id\":\"parent_resource_id\","
+      "\"kind\":\"drive#fileLink\""
+      "}],"
+      "\"properties\":["
+      "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
+      "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}],"
+      "\"title\":\"new file title\"}",
+      http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
@@ skipping 372 matching lines @@
         new drive::InitiateUploadExistingFileRequest(
             request_sender_.get(),
             *url_generator_,
             kTestContentType,
             kTestContent.size(),
             "resource_id",  // The resource id of the file to be overwritten.
             std::string(),  // No etag.
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request->set_properties(testing_properties_);
     request_sender_->StartRequestWithRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
-  EXPECT_TRUE(http_request_.content.empty());
+  EXPECT_EQ(
+      "{\"properties\":["
+      "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
+      "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}]}",
+      http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
@@ skipping 457 matching lines @@
   expected.reset(base::JSONReader::Read(
       "{\"role\":\"writer\", \"type\":\"domain\",\"value\":\"example.com\"}"));
   ASSERT_TRUE(expected);
 
   result.reset(base::JSONReader::Read(http_request_.content));
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(base::Value::Equals(expected.get(), result.get()));
 }
 
 }  // namespace google_apis