Skip to content

Commit c51eb30

Browse files
shubham-up-47shubham-up-47
committed
fixing code coverage
1 parent dd63f1f commit c51eb30

4 files changed

Lines changed: 178 additions & 6 deletions

File tree

‎google/cloud/storage/async/client_test.cc‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1425,9 +1425,11 @@ TEST(AsyncClient, LoggingEnabled) {
14251425
auto rt = client.ReadObject(BucketName("test-bucket"), "test-object").get();
14261426
ASSERT_STATUS_OK(rt);
14271427
AsyncReader r;
1428+
EXPECT_THAT(r.GetRequestMetadata().headers, IsEmpty());
14281429
AsyncToken t;
1430+
EXPECT_FALSE(t.valid());
14291431
std::tie(r, t) = *std::move(rt);
1430-
EXPECT_TRUE(t.valid());
1432+
ASSERT_TRUE(t.valid());
14311433

14321434
auto read_result = r.Read(std::move(t)).get();
14331435
ASSERT_STATUS_OK(read_result);
@@ -1454,9 +1456,11 @@ TEST(AsyncClient, LoggingDisabled) {
14541456
auto rt = client.ReadObject(BucketName("test-bucket"), "test-object").get();
14551457
ASSERT_STATUS_OK(rt);
14561458
AsyncReader r;
1459+
EXPECT_THAT(r.GetRequestMetadata().headers, IsEmpty());
14571460
AsyncToken t;
1461+
EXPECT_FALSE(t.valid());
14581462
std::tie(r, t) = *std::move(rt);
1459-
EXPECT_TRUE(t.valid());
1463+
ASSERT_TRUE(t.valid());
14601464

14611465
auto read_result = r.Read(std::move(t)).get();
14621466
ASSERT_STATUS_OK(read_result);

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

Lines changed: 158 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,8 @@
2020
#include "google/cloud/storage/mocks/mock_async_connection.h"
2121
#include "google/cloud/storage/mocks/mock_async_object_descriptor_connection.h"
2222
#include "google/cloud/storage/mocks/mock_async_reader_connection.h"
23+
#include "google/cloud/storage/mocks/mock_async_rewriter_connection.h"
24+
#include "google/cloud/storage/mocks/mock_async_writer_connection.h"
2325
#include "google/cloud/storage/testing/canonical_errors.h"
2426
#include "google/cloud/common_options.h"
2527
#include "google/cloud/log.h"
@@ -35,12 +37,17 @@ namespace {
3537

3638
using ::google::cloud::storage::testing::canonical_errors::PermanentError;
3739
using ::google::cloud::storage_experimental::AsyncReaderConnection;
40+
using ::google::cloud::storage_experimental::AsyncWriterConnection;
3841
using ::google::cloud::storage_mocks::MockAsyncConnection;
3942
using ::google::cloud::storage_mocks::MockAsyncReaderConnection;
43+
using ::google::cloud::storage_mocks::MockAsyncRewriterConnection;
44+
using ::google::cloud::storage_mocks::MockAsyncWriterConnection;
4045
using ::google::cloud::testing_util::ScopedLog;
4146
using ::google::cloud::testing_util::StatusIs;
4247
using ::testing::Contains;
4348
using ::testing::HasSubstr;
49+
using ::testing::IsEmpty;
50+
using ::testing::NotNull;
4451
using ::testing::Return;
4552

4653
Options LoggingEnabled() {
@@ -144,6 +151,157 @@ TEST(ConnectionLogging, ReadObjectRangeError) {
144151
EXPECT_THAT(log_lines, Contains(HasSubstr("ReadObjectRange failed")));
145152
}
146153

154+
TEST(ConnectionLogging, ReadObjectRangeNotReady) {
155+
ScopedLog log;
156+
promise<StatusOr<storage_experimental::ReadPayload>> p;
157+
158+
auto mock = std::make_shared<MockAsyncConnection>();
159+
EXPECT_CALL(*mock, ReadObjectRange).WillOnce(Return(p.get_future()));
160+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
161+
162+
auto conn = MakeLoggingAsyncConnection(mock);
163+
auto fut = conn->ReadObjectRange({});
164+
EXPECT_FALSE(fut.is_ready());
165+
p.set_value(storage_experimental::ReadPayload{});
166+
(void)fut.get();
167+
168+
auto const log_lines = log.ExtractLines();
169+
EXPECT_THAT(log_lines,
170+
Contains(HasSubstr("ReadObjectRange(bucket=, object=)")));
171+
EXPECT_THAT(log_lines, Contains(HasSubstr("ReadObjectRange succeeded")));
172+
}
173+
174+
TEST(ConnectionLogging, StartAppendableObjectUpload) {
175+
ScopedLog log;
176+
auto mock = std::make_shared<MockAsyncConnection>();
177+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
178+
EXPECT_CALL(*mock, StartAppendableObjectUpload).WillOnce([] {
179+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
180+
std::make_unique<MockAsyncWriterConnection>()));
181+
});
182+
183+
auto conn = MakeLoggingAsyncConnection(mock);
184+
auto result = conn->StartAppendableObjectUpload({{}, LoggingEnabled()}).get();
185+
ASSERT_STATUS_OK(result);
186+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
187+
}
188+
189+
TEST(ConnectionLogging, ResumeAppendableObjectUpload) {
190+
ScopedLog log;
191+
auto mock = std::make_shared<MockAsyncConnection>();
192+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
193+
EXPECT_CALL(*mock, ResumeAppendableObjectUpload).WillOnce([] {
194+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
195+
std::make_unique<MockAsyncWriterConnection>()));
196+
});
197+
198+
auto conn = MakeLoggingAsyncConnection(mock);
199+
auto result =
200+
conn->ResumeAppendableObjectUpload({{}, LoggingEnabled()}).get();
201+
ASSERT_STATUS_OK(result);
202+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
203+
}
204+
205+
TEST(ConnectionLogging, StartUnbufferedUpload) {
206+
ScopedLog log;
207+
auto mock = std::make_shared<MockAsyncConnection>();
208+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
209+
EXPECT_CALL(*mock, StartUnbufferedUpload).WillOnce([] {
210+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
211+
std::make_unique<MockAsyncWriterConnection>()));
212+
});
213+
214+
auto conn = MakeLoggingAsyncConnection(mock);
215+
auto result = conn->StartUnbufferedUpload({{}, LoggingEnabled()}).get();
216+
ASSERT_STATUS_OK(result);
217+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
218+
}
219+
220+
TEST(ConnectionLogging, StartBufferedUpload) {
221+
ScopedLog log;
222+
auto mock = std::make_shared<MockAsyncConnection>();
223+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
224+
EXPECT_CALL(*mock, StartBufferedUpload).WillOnce([] {
225+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
226+
std::make_unique<MockAsyncWriterConnection>()));
227+
});
228+
229+
auto conn = MakeLoggingAsyncConnection(mock);
230+
auto result = conn->StartBufferedUpload({{}, LoggingEnabled()}).get();
231+
ASSERT_STATUS_OK(result);
232+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
233+
}
234+
235+
TEST(ConnectionLogging, ResumeUnbufferedUpload) {
236+
ScopedLog log;
237+
auto mock = std::make_shared<MockAsyncConnection>();
238+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
239+
EXPECT_CALL(*mock, ResumeUnbufferedUpload).WillOnce([] {
240+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
241+
std::make_unique<MockAsyncWriterConnection>()));
242+
});
243+
244+
auto conn = MakeLoggingAsyncConnection(mock);
245+
auto result = conn->ResumeUnbufferedUpload({{}, LoggingEnabled()}).get();
246+
ASSERT_STATUS_OK(result);
247+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
248+
}
249+
250+
TEST(ConnectionLogging, ResumeBufferedUpload) {
251+
ScopedLog log;
252+
auto mock = std::make_shared<MockAsyncConnection>();
253+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
254+
EXPECT_CALL(*mock, ResumeBufferedUpload).WillOnce([] {
255+
return make_ready_future(StatusOr<std::unique_ptr<AsyncWriterConnection>>(
256+
std::make_unique<MockAsyncWriterConnection>()));
257+
});
258+
259+
auto conn = MakeLoggingAsyncConnection(mock);
260+
auto result = conn->ResumeBufferedUpload({{}, LoggingEnabled()}).get();
261+
ASSERT_STATUS_OK(result);
262+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
263+
}
264+
265+
TEST(ConnectionLogging, ComposeObject) {
266+
ScopedLog log;
267+
auto mock = std::make_shared<MockAsyncConnection>();
268+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
269+
EXPECT_CALL(*mock, ComposeObject)
270+
.WillOnce(Return(
271+
make_ready_future(make_status_or(google::storage::v2::Object{}))));
272+
273+
auto conn = MakeLoggingAsyncConnection(mock);
274+
auto result = conn->ComposeObject({{}, LoggingEnabled()}).get();
275+
ASSERT_STATUS_OK(result);
276+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
277+
}
278+
279+
TEST(ConnectionLogging, DeleteObject) {
280+
ScopedLog log;
281+
auto mock = std::make_shared<MockAsyncConnection>();
282+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
283+
EXPECT_CALL(*mock, DeleteObject)
284+
.WillOnce(Return(make_ready_future(Status{})));
285+
286+
auto conn = MakeLoggingAsyncConnection(mock);
287+
auto result = conn->DeleteObject({{}, LoggingEnabled()}).get();
288+
ASSERT_STATUS_OK(result);
289+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
290+
}
291+
292+
TEST(ConnectionLogging, RewriteObject) {
293+
ScopedLog log;
294+
auto mock = std::make_shared<MockAsyncConnection>();
295+
EXPECT_CALL(*mock, options).WillRepeatedly(Return(LoggingEnabled()));
296+
EXPECT_CALL(*mock, RewriteObject)
297+
.WillOnce(Return(std::make_shared<MockAsyncRewriterConnection>()));
298+
299+
auto conn = MakeLoggingAsyncConnection(mock);
300+
auto result = conn->RewriteObject({{}, LoggingEnabled()});
301+
ASSERT_THAT(result, NotNull());
302+
EXPECT_THAT(log.ExtractLines(), IsEmpty());
303+
}
304+
147305
} // namespace
148306
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
149307
} // namespace storage_internal

‎google/cloud/storage/internal/async/object_descriptor_connection_logging.cc‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -50,10 +50,7 @@ class ObjectDescriptorConnectionLogging : public ObjectDescriptorConnection {
5050
return MakeLoggingReaderConnection(options(), std::move(conn));
5151
}
5252

53-
void MakeSubsequentStream() override {
54-
GCP_LOG(INFO) << "ObjectDescriptorConnection::MakeSubsequentStream()";
55-
child_->MakeSubsequentStream();
56-
}
53+
void MakeSubsequentStream() override { child_->MakeSubsequentStream(); }
5754

5855
private:
5956
std::shared_ptr<ObjectDescriptorConnection> child_;

‎google/cloud/storage/internal/async/object_descriptor_connection_logging_test.cc‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,19 @@ TEST(ObjectDescriptorConnectionLogging, Metadata) {
108108
EXPECT_THAT(log_lines, Not(Contains(HasSubstr("metadata"))));
109109
}
110110

111+
TEST(ObjectDescriptorConnectionLogging, MakeSubsequentStream) {
112+
ScopedLog log;
113+
114+
auto mock = std::make_shared<MockAsyncObjectDescriptorConnection>();
115+
EXPECT_CALL(*mock, MakeSubsequentStream).WillOnce([] { return; });
116+
117+
auto actual = MakeLoggingObjectDescriptorConnection(mock, LoggingEnabled());
118+
(void)actual->MakeSubsequentStream();
119+
120+
auto const log_lines = log.ExtractLines();
121+
EXPECT_THAT(log_lines, Not(Contains(HasSubstr("MakeSubsequentStream"))));
122+
}
123+
111124
} // namespace
112125
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
113126
} // namespace storage_internal

0 commit comments

Comments
 (0)