chunked_data_stream_uploader_unittest.cc 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231
  1. // Copyright (c) 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ios/net/chunked_data_stream_uploader.h"
  5. #include <array>
  6. #include <memory>
  7. #include "base/bind.h"
  8. #include "net/base/io_buffer.h"
  9. #include "net/base/net_errors.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. #include "testing/platform_test.h"
  12. namespace net {
  13. namespace {
  14. const int kDefaultIOBufferSize = 1024;
  15. }
  16. // Mock delegate to provide data from its internal buffer.
  17. class MockChunkedDataStreamUploaderDelegate
  18. : public ChunkedDataStreamUploader::Delegate {
  19. public:
  20. MockChunkedDataStreamUploaderDelegate() : data_length_(0) {}
  21. ~MockChunkedDataStreamUploaderDelegate() override {}
  22. int OnRead(char* buffer, int buffer_length) override {
  23. int bytes_read = 0;
  24. if (data_length_ > 0) {
  25. CHECK_GE(buffer_length, data_length_);
  26. memcpy(buffer, data_, data_length_);
  27. bytes_read = data_length_;
  28. data_length_ = 0;
  29. }
  30. return bytes_read;
  31. }
  32. void SetReadData(const char* data, int data_length) {
  33. CHECK_GE(sizeof(data_), static_cast<size_t>(data_length));
  34. memcpy(data_, data, data_length);
  35. data_length_ = data_length;
  36. CHECK(!memcmp(data_, data, data_length));
  37. }
  38. private:
  39. char data_[kDefaultIOBufferSize];
  40. int data_length_;
  41. };
  42. class ChunkedDataStreamUploaderTest : public PlatformTest {
  43. public:
  44. ChunkedDataStreamUploaderTest() : callback_count(0) {
  45. delegate_ = std::make_unique<MockChunkedDataStreamUploaderDelegate>();
  46. uploader_owner_ =
  47. std::make_unique<ChunkedDataStreamUploader>(delegate_.get());
  48. uploader_ = uploader_owner_->GetWeakPtr();
  49. uploader_owner_->Init(base::BindRepeating([](int) {}),
  50. net::NetLogWithSource());
  51. }
  52. void CompletionCallback(int result) { ++callback_count; }
  53. protected:
  54. std::unique_ptr<MockChunkedDataStreamUploaderDelegate> delegate_;
  55. std::unique_ptr<ChunkedDataStreamUploader> uploader_owner_;
  56. base::WeakPtr<ChunkedDataStreamUploader> uploader_;
  57. // Completion callback counter for each case.
  58. int callback_count;
  59. };
  60. // Tests that data from the application layer become ready before the network
  61. // layer callback.
  62. TEST_F(ChunkedDataStreamUploaderTest, ExternalDataReadyFirst) {
  63. // Application layer data is ready.
  64. const char kTestData[] = "Hello world!";
  65. delegate_->SetReadData(kTestData, sizeof(kTestData));
  66. uploader_->UploadWhenReady(false);
  67. // Network layer callback is called next, and the application data is expected
  68. // to be read to the |buffer|.
  69. auto buffer = base::MakeRefCounted<net::IOBuffer>(kDefaultIOBufferSize);
  70. int bytes_read = uploader_->Read(
  71. buffer.get(), kDefaultIOBufferSize,
  72. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  73. base::Unretained(this)));
  74. EXPECT_EQ(sizeof(kTestData), static_cast<size_t>(bytes_read));
  75. EXPECT_FALSE(
  76. memcmp(kTestData, buffer->data(), static_cast<size_t>(bytes_read)));
  77. // Application finishes data upload. Called after all data has been uploaded.
  78. delegate_->SetReadData("", 0);
  79. uploader_->UploadWhenReady(true);
  80. bytes_read = uploader_->Read(
  81. buffer.get(), kDefaultIOBufferSize,
  82. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  83. base::Unretained(this)));
  84. EXPECT_EQ(0, bytes_read);
  85. EXPECT_TRUE(uploader_->IsEOF());
  86. // No completion callback is called because Read() call should return
  87. // directly.
  88. EXPECT_EQ(0, callback_count);
  89. }
  90. // Tests that callback from the network layer is called before the application
  91. // layer data available.
  92. TEST_F(ChunkedDataStreamUploaderTest, InternalReadReadyFirst) {
  93. // Network layer callback is called and the request is pending.
  94. auto buffer = base::MakeRefCounted<net::IOBuffer>(kDefaultIOBufferSize);
  95. int ret = uploader_->Read(
  96. buffer.get(), kDefaultIOBufferSize,
  97. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  98. base::Unretained(this)));
  99. EXPECT_EQ(ERR_IO_PENDING, ret);
  100. // The data is writen into |buffer| once the application layer data is ready.
  101. const char kTestData[] = "Hello world!";
  102. delegate_->SetReadData(kTestData, sizeof(kTestData));
  103. uploader_->UploadWhenReady(false);
  104. EXPECT_FALSE(memcmp(kTestData, buffer->data(), sizeof(kTestData)));
  105. // Callback is called again after a successful read.
  106. ret = uploader_->Read(
  107. buffer.get(), kDefaultIOBufferSize,
  108. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  109. base::Unretained(this)));
  110. EXPECT_EQ(ERR_IO_PENDING, ret);
  111. // No more data is available, and the upload will be finished.
  112. delegate_->SetReadData("", 0);
  113. uploader_->UploadWhenReady(true);
  114. EXPECT_TRUE(uploader_->IsEOF());
  115. EXPECT_EQ(2, callback_count);
  116. }
  117. // Tests that null data is correctly handled when the callback comes first.
  118. TEST_F(ChunkedDataStreamUploaderTest, NullContentWithReadFirst) {
  119. auto buffer = base::MakeRefCounted<net::IOBuffer>(kDefaultIOBufferSize);
  120. int ret = uploader_->Read(
  121. buffer.get(), kDefaultIOBufferSize,
  122. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  123. base::Unretained(this)));
  124. EXPECT_EQ(ERR_IO_PENDING, ret);
  125. delegate_->SetReadData("", 0);
  126. uploader_->UploadWhenReady(true);
  127. EXPECT_TRUE(uploader_->IsEOF());
  128. EXPECT_EQ(1, callback_count);
  129. }
  130. // Tests that null data is correctly handled when data is available first.
  131. TEST_F(ChunkedDataStreamUploaderTest, NullContentWithDataFirst) {
  132. delegate_->SetReadData("", 0);
  133. uploader_->UploadWhenReady(true);
  134. auto buffer = base::MakeRefCounted<net::IOBuffer>(kDefaultIOBufferSize);
  135. int bytes_read = uploader_->Read(
  136. buffer.get(), kDefaultIOBufferSize,
  137. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  138. base::Unretained(this)));
  139. EXPECT_EQ(0, bytes_read);
  140. EXPECT_TRUE(uploader_->IsEOF());
  141. EXPECT_EQ(0, callback_count);
  142. }
  143. // A complex test case that the application layer data and network layer
  144. // callback becomes ready first reciprocally.
  145. TEST_F(ChunkedDataStreamUploaderTest, MixedScenarioTest) {
  146. // Data comes first.
  147. const char kTestData[] = "Hello world!";
  148. delegate_->SetReadData(kTestData, sizeof(kTestData));
  149. uploader_->UploadWhenReady(false);
  150. auto buffer = base::MakeRefCounted<net::IOBuffer>(kDefaultIOBufferSize);
  151. int bytes_read = uploader_->Read(
  152. buffer.get(), kDefaultIOBufferSize,
  153. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  154. base::Unretained(this)));
  155. EXPECT_EQ(sizeof(kTestData), static_cast<size_t>(bytes_read));
  156. EXPECT_FALSE(
  157. memcmp(kTestData, buffer->data(), static_cast<size_t>(bytes_read)));
  158. // Callback comes first.
  159. int ret = uploader_->Read(
  160. buffer.get(), kDefaultIOBufferSize,
  161. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  162. base::Unretained(this)));
  163. EXPECT_EQ(ERR_IO_PENDING, ret);
  164. char test_data_long[kDefaultIOBufferSize];
  165. for (int i = 0; i < static_cast<int>(sizeof(test_data_long)); ++i) {
  166. test_data_long[i] = static_cast<char>(i & 0xFF);
  167. }
  168. delegate_->SetReadData(test_data_long, sizeof(test_data_long));
  169. uploader_->UploadWhenReady(false);
  170. EXPECT_FALSE(memcmp(test_data_long, buffer->data(), sizeof(test_data_long)));
  171. // Callback comes first again.
  172. ret = uploader_->Read(
  173. buffer.get(), kDefaultIOBufferSize,
  174. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  175. base::Unretained(this)));
  176. EXPECT_EQ(ERR_IO_PENDING, ret);
  177. delegate_->SetReadData(kTestData, sizeof(kTestData));
  178. uploader_->UploadWhenReady(false);
  179. EXPECT_FALSE(memcmp(kTestData, buffer->data(), sizeof(kTestData)));
  180. // Finish and data comes first.
  181. delegate_->SetReadData("", 0);
  182. uploader_->UploadWhenReady(true);
  183. bytes_read = uploader_->Read(
  184. buffer.get(), kDefaultIOBufferSize,
  185. base::BindRepeating(&ChunkedDataStreamUploaderTest::CompletionCallback,
  186. base::Unretained(this)));
  187. EXPECT_EQ(0, bytes_read);
  188. EXPECT_TRUE(uploader_->IsEOF());
  189. // Completion callback is called only after Read() returns ERR_IO_PENDING;
  190. EXPECT_EQ(2, callback_count);
  191. }
  192. } // namespace net