Merge branch 'main' into mark_oauth2_deprecated

Author: shubham-up-47

google/cloud/internal/curl_impl.cc

@@ -369,6 +369,12 @@ Status CurlImpl::MakeRequest(HttpMethod method, RestContext& context,
     status = handle_.SetOption(CURLOPT_PROXYPASSWORD, proxy_password_->c_str());
     if (!status.ok()) return OnTransferError(context, std::move(status));
   }
+
+#if CURL_AT_LEAST_VERSION(7, 19, 4)
+  status = handle_.SetOption(CURLOPT_NOPROXY, "metadata.google.internal");
+  if (!status.ok()) return OnTransferError(context, std::move(status));
+#endif
+
   if (interface_) {
     status = handle_.SetOption(CURLOPT_INTERFACE, interface_->c_str());
     if (!status.ok()) return OnTransferError(context, std::move(status));

google/cloud/storage/examples/storage_object_soft_delete_samples.cc

@@ -28,7 +28,7 @@ void ListSoftDeletedObjects(google::cloud::storage::Client client,
     std::cout << "Listing soft-deleted objects in the bucket: " << bucket_name
               << "\n";
     int object_count = 0;
-    for (auto const& object_metadata :
+    for (auto&& object_metadata :
          client.ListObjects(bucket_name, gcs::SoftDeleted(true))) {
       if (!object_metadata) throw std::move(object_metadata).status();
       std::cout << "Soft-deleted object" << ++object_count << ": "
@@ -46,7 +46,7 @@ void ListSoftDeletedObjectVersions(google::cloud::storage::Client client,
   [](gcs::Client client, std::string const& bucket_name,
      std::string const& object_name) {
     int version_count = 0;
-    for (auto const& object_metadata :
+    for (auto&& object_metadata :
          client.ListObjects(bucket_name, gcs::SoftDeleted(true),
                             gcs::MatchGlob(object_name))) {
       if (!object_metadata) throw std::move(object_metadata).status();
@@ -105,7 +105,7 @@ void RunAll(std::vector<std::string> const& argv) {
   if (!insert_obj_metadata.ok()) throw std::move(insert_obj_metadata).status();
   std::cout << "Deleting the object: " << object_name << std::endl;
   auto obj_delete_status = client.DeleteObject(bucket_name, object_name);
-  if (!obj_delete_status.ok()) throw obj_delete_status;
+  if (!obj_delete_status.ok()) throw std::move(obj_delete_status);
 
   std::cout << "\nRunning the ListSoftDeletedObjects() example" << std::endl;
   ListSoftDeletedObjects(client, {bucket_name});
@@ -114,24 +114,22 @@ void RunAll(std::vector<std::string> const& argv) {
             << std::endl;
   ListSoftDeletedObjectVersions(client, {bucket_name, object_name});
 
-  std::int64_t generation = 0;
-  for (auto const& object_metadata : client.ListObjects(
-           bucket_name, gcs::SoftDeleted(true), gcs::MatchGlob(object_name))) {
-    if (!object_metadata) throw std::move(object_metadata).status();
-    generation = object_metadata->generation();
-    break;
-  }
+  auto objects = client.ListObjects(bucket_name, gcs::SoftDeleted(true),
+                                    gcs::MatchGlob(object_name));
+  auto object_metadata = objects.begin();
+  if (!*object_metadata) throw std::move(*object_metadata).status();
+  std::int64_t generation = (*object_metadata)->generation();
 
   std::cout << "\nRunning the RestoreSoftDeletedObject() example" << std::endl;
   RestoreSoftDeletedObject(
       client, {bucket_name, object_name, std::to_string(generation)});
 
   std::cout << "\nCleanup" << std::endl;
   auto object_delete_status = client.DeleteObject(bucket_name, object_name);
-  if (!object_delete_status.ok()) throw object_delete_status;
+  if (!object_delete_status.ok()) throw std::move(object_delete_status);
   std::cout << "Object deleted successfully.\n";
   auto bucket_delete_status = client.DeleteBucket(bucket_name);
-  if (!bucket_delete_status.ok()) throw bucket_delete_status;
+  if (!bucket_delete_status.ok()) throw std::move(bucket_delete_status);
   std::cout << "Bucket deleted successfully.\n";
 }
 

google/cloud/storage/internal/async/object_descriptor_impl_test.cc

@@ -1037,11 +1037,11 @@ Status PartialFailure(std::int64_t read_id) {
     auto error = google::storage::v2::BidiReadObjectError{};
     auto& range_error = *error.add_read_range_errors();
     range_error.set_read_id(read_id);
-    range_error.mutable_status()->set_code(grpc::INVALID_ARGUMENT);
+    range_error.mutable_status()->set_code(grpc::StatusCode::INVALID_ARGUMENT);
     range_error.mutable_status()->set_message("out of range read");
 
     auto details_proto = google::rpc::Status{};
-    details_proto.set_code(grpc::INVALID_ARGUMENT);
+    details_proto.set_code(grpc::StatusCode::INVALID_ARGUMENT);
     details_proto.set_message("some reads are out of range");
     details_proto.add_details()->PackFrom(error);
 
@@ -1051,7 +1051,7 @@ Status PartialFailure(std::int64_t read_id) {
   };
 
   return google::cloud::MakeStatusFromRpcError(
-      grpc::Status(grpc::INVALID_ARGUMENT, "redirect", details()));
+      grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "redirect", details()));
 }
 
 /// @test When the underlying stream fails with unrecoverable errors all ranges

google/cloud/storage/internal/rest/stub.cc

@@ -183,6 +183,9 @@ StatusOr<ListBucketsResponse> RestStub::ListBuckets(
   if (!headers.ok()) return headers;
   request.AddOptionsToHttpRequest(builder);
   builder.AddQueryParameter("project", request.project_id());
+  if (!request.page_token().empty()) {
+    builder.AddQueryParameter("pageToken", request.page_token());
+  }
   return ParseFromRestResponse<ListBucketsResponse>(
       storage_rest_client_->Get(context, std::move(builder).BuildRequest()));
 }

google/cloud/storage/internal/rest/stub_test.cc

@@ -40,6 +40,7 @@ using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using ::testing::Matcher;
+using ::testing::Not;
 using ::testing::Pair;
 using ::testing::ResultOf;
 using ::testing::Return;
@@ -193,6 +194,42 @@ TEST(RestStubTest, CreateBucket) {
               StatusIs(PermanentError().code(), PermanentError().message()));
 }
 
+TEST(RestStubTest, ListBucketsIncludesPageTokenWhenPresentInRequest) {
+  auto mock = std::make_shared<MockRestClient>();
+  std::string expected_token = "test-page-token";
+  ListBucketsRequest request("test-project-id");
+  request.set_page_token(expected_token);
+
+  EXPECT_CALL(*mock,
+              Get(ExpectedContext(),
+                  ResultOf(
+                      "request parameters contain 'pageToken'",
+                      [](RestRequest const& r) { return r.parameters(); },
+                      Contains(Pair("pageToken", expected_token)))))
+      .WillOnce(Return(PermanentError()));
+
+  auto tested = std::make_unique<RestStub>(Options{}, mock, mock);
+  auto context = TestContext();
+  tested->ListBuckets(context, TestOptions(), request);
+}
+
+TEST(RestStubTest, ListBucketsOmitsPageTokenWhenEmptyInRequest) {
+  auto mock = std::make_shared<MockRestClient>();
+  ListBucketsRequest request("test-project-id");
+
+  EXPECT_CALL(*mock,
+              Get(ExpectedContext(),
+                  ResultOf(
+                      "request parameters do not contain 'pageToken'",
+                      [](RestRequest const& r) { return r.parameters(); },
+                      Not(Contains(Pair("pageToken", _))))))
+      .WillOnce(Return(PermanentError()));
+
+  auto tested = std::make_unique<RestStub>(Options{}, mock, mock);
+  auto context = TestContext();
+  tested->ListBuckets(context, TestOptions(), request);
+}
+
 TEST(RestStubTest, GetBucketMetadata) {
   auto mock = std::make_shared<MockRestClient>();
   EXPECT_CALL(*mock, Get(ExpectedContext(), ExpectedRequest()))