fixing code coverage

Author: shubham-up-47

google/cloud/storage/async/client_test.cc

@@ -1425,14 +1425,19 @@ TEST(AsyncClient, LoggingEnabled) {
   auto rt = client.ReadObject(BucketName("test-bucket"), "test-object").get();
   ASSERT_STATUS_OK(rt);
   AsyncReader r;
-  EXPECT_THAT(r.GetRequestMetadata().headers, IsEmpty());
   AsyncToken t;
-  EXPECT_FALSE(t.valid());
   std::tie(r, t) = *std::move(rt);
   ASSERT_TRUE(t.valid());
 
-  auto read_result = r.Read(std::move(t)).get();
-  ASSERT_STATUS_OK(read_result);
+  auto pt = r.Read(std::move(t)).get();
+  AsyncReaderConnection::ReadResponse p;
+  AsyncToken t2;
+  ASSERT_STATUS_OK(pt);
+  std::tie(p, t2) = *std::move(pt);
+  EXPECT_FALSE(t2.valid());
+  EXPECT_THAT(
+      p, VariantWith<ReadPayload>(ResultOf(
+             "empty response", [](auto const& p) { return p.size(); }, 0)));
 
   auto const log_lines = log.ExtractLines();
   EXPECT_THAT(log_lines, Contains(HasSubstr("ReadObject")));
@@ -1456,14 +1461,19 @@ TEST(AsyncClient, LoggingDisabled) {
   auto rt = client.ReadObject(BucketName("test-bucket"), "test-object").get();
   ASSERT_STATUS_OK(rt);
   AsyncReader r;
-  EXPECT_THAT(r.GetRequestMetadata().headers, IsEmpty());
   AsyncToken t;
-  EXPECT_FALSE(t.valid());
   std::tie(r, t) = *std::move(rt);
   ASSERT_TRUE(t.valid());
 
-  auto read_result = r.Read(std::move(t)).get();
-  ASSERT_STATUS_OK(read_result);
+  auto pt = r.Read(std::move(t)).get();
+  AsyncReaderConnection::ReadResponse p;
+  AsyncToken t2;
+  ASSERT_STATUS_OK(pt);
+  std::tie(p, t2) = *std::move(pt);
+  EXPECT_FALSE(t2.valid());
+  EXPECT_THAT(
+      p, VariantWith<ReadPayload>(ResultOf(
+             "empty response", [](auto const& p) { return p.size(); }, 0)));
 
   EXPECT_THAT(log.ExtractLines(), IsEmpty());
 }

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

@@ -171,6 +171,26 @@ TEST(ConnectionLogging, ReadObjectRangeNotReady) {
   EXPECT_THAT(log_lines, Contains(HasSubstr("ReadObjectRange succeeded")));
 }
 
+TEST(ConnectionLogging, ReadObjectRangeNotReadyWithError) {
+  ScopedLog log;
+  promise<StatusOr<storage_experimental::ReadPayload>> p;
+
+  auto mock = std::make_shared<MockAsyncConnection>();
+  EXPECT_CALL(*mock, ReadObjectRange).WillOnce(Return(p.get_future()));
+  EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
+
+  auto conn = MakeLoggingAsyncConnection(mock);
+  auto fut = conn->ReadObjectRange({});
+  EXPECT_FALSE(fut.is_ready());
+  p.set_value(PermanentError());
+  (void)fut.get();
+
+  auto const log_lines = log.ExtractLines();
+  EXPECT_THAT(log_lines,
+              Contains(HasSubstr("ReadObjectRange(bucket=, object=)")));
+  EXPECT_THAT(log_lines, Contains(HasSubstr("ReadObjectRange failed")));
+}
+
 TEST(ConnectionLogging, StartAppendableObjectUpload) {
   ScopedLog log;
   auto mock = std::make_shared<MockAsyncConnection>();

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

@@ -36,6 +36,8 @@ using ::google::cloud::testing_util::ScopedLog;
 using ::google::cloud::testing_util::StatusIs;
 using ::testing::Contains;
 using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::Return;
 
 Options LoggingEnabled() {
   return Options{}.set<LoggingComponentsOption>({"rpc"});
@@ -110,6 +112,23 @@ TEST(ReaderConnectionLogging, Cancel) {
               Contains(HasSubstr("ReaderConnectionLogging::Cancel()")));
 }
 
+TEST(ReaderConnectionLogging, GetRequestMetadata) {
+  ScopedLog log;
+
+  auto mock = std::make_unique<MockAsyncReaderConnection>();
+  RpcMetadata expected{{{"test-header", "test-value"}}, {}};
+  EXPECT_CALL(*mock, GetRequestMetadata).WillOnce(Return(expected));
+
+  auto actual = MakeLoggingReaderConnection(LoggingEnabled(), std::move(mock));
+  auto metadata = actual->GetRequestMetadata();
+
+  EXPECT_EQ(metadata.headers, expected.headers);
+  EXPECT_EQ(metadata.trailers, expected.trailers);
+
+  auto const log_lines = log.ExtractLines();
+  EXPECT_THAT(log_lines, IsEmpty());
+}
+
 }  // namespace
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage_internal