buffered_file_writer_unittest.cc 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
  1. // Copyright 2018 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 "remoting/host/file_transfer/buffered_file_writer.h"
  5. #include "base/bind.h"
  6. #include "base/test/task_environment.h"
  7. #include "base/threading/sequenced_task_runner_handle.h"
  8. #include "remoting/host/file_transfer/fake_file_operations.h"
  9. #include "remoting/host/file_transfer/test_byte_vector_utils.h"
  10. #include "remoting/protocol/file_transfer_helpers.h"
  11. #include "testing/gtest/include/gtest/gtest.h"
  12. namespace remoting {
  13. class BufferedFileWriterTest : public testing::Test {
  14. public:
  15. BufferedFileWriterTest();
  16. ~BufferedFileWriterTest() override;
  17. // testing::Test implementation.
  18. void SetUp() override;
  19. void TearDown() override;
  20. protected:
  21. const base::FilePath kTestFilename{FILE_PATH_LITERAL("test-file.txt")};
  22. const std::vector<std::uint8_t> kTestDataOne =
  23. ByteArrayFrom("this is the first test string");
  24. const std::vector<std::uint8_t> kTestDataTwo =
  25. ByteArrayFrom("this is the second test string");
  26. const std::vector<std::uint8_t> kTestDataThree =
  27. ByteArrayFrom("this is the third test string");
  28. void OnCompleted();
  29. void OnError(protocol::FileTransfer_Error error);
  30. bool complete_called_ = false;
  31. absl::optional<protocol::FileTransfer_Error> error_ = absl::nullopt;
  32. base::test::TaskEnvironment task_environment_;
  33. };
  34. BufferedFileWriterTest::BufferedFileWriterTest() = default;
  35. BufferedFileWriterTest::~BufferedFileWriterTest() = default;
  36. void BufferedFileWriterTest::SetUp() {}
  37. void BufferedFileWriterTest::TearDown() {}
  38. void BufferedFileWriterTest::OnCompleted() {
  39. ASSERT_TRUE(!complete_called_ && !error_);
  40. complete_called_ = true;
  41. }
  42. void BufferedFileWriterTest::OnError(protocol::FileTransfer_Error error) {
  43. ASSERT_TRUE(!complete_called_ && !error_);
  44. error_ = std::move(error);
  45. }
  46. // Verifies BufferedFileWriter creates, writes to, and closes a Writer
  47. // without errors.
  48. TEST_F(BufferedFileWriterTest, WritesThreeChunks) {
  49. FakeFileOperations::TestIo test_io;
  50. auto file_operations = std::make_unique<FakeFileOperations>(&test_io);
  51. BufferedFileWriter writer(
  52. file_operations->CreateWriter(),
  53. base::BindOnce(
  54. &BufferedFileWriterTest_WritesThreeChunks_Test::OnCompleted,
  55. base::Unretained(this)),
  56. base::BindOnce(&BufferedFileWriterTest_WritesThreeChunks_Test::OnError,
  57. base::Unretained(this)));
  58. writer.Start(kTestFilename);
  59. task_environment_.RunUntilIdle();
  60. writer.Write(kTestDataOne);
  61. task_environment_.RunUntilIdle();
  62. writer.Write(kTestDataTwo);
  63. task_environment_.RunUntilIdle();
  64. writer.Write(kTestDataThree);
  65. task_environment_.RunUntilIdle();
  66. writer.Close();
  67. ASSERT_EQ(false, complete_called_);
  68. task_environment_.RunUntilIdle();
  69. ASSERT_EQ(true, complete_called_);
  70. ASSERT_EQ(1ul, test_io.files_written.size());
  71. ASSERT_EQ(false, test_io.files_written[0].failed);
  72. std::vector<std::vector<std::uint8_t>> expected_chunks = {
  73. kTestDataOne, kTestDataTwo, kTestDataThree};
  74. ASSERT_EQ(expected_chunks, test_io.files_written[0].chunks);
  75. }
  76. // Verifies BufferedFileWriter properly queues up file operations.
  77. TEST_F(BufferedFileWriterTest, QueuesOperations) {
  78. FakeFileOperations::TestIo test_io;
  79. auto file_operations = std::make_unique<FakeFileOperations>(&test_io);
  80. BufferedFileWriter writer(
  81. file_operations->CreateWriter(),
  82. base::BindOnce(&BufferedFileWriterTest_QueuesOperations_Test::OnCompleted,
  83. base::Unretained(this)),
  84. base::BindOnce(&BufferedFileWriterTest_QueuesOperations_Test::OnError,
  85. base::Unretained(this)));
  86. // FakeFileWriter will CHECK that BufferedFileWriter properly serializes
  87. // file operations.
  88. writer.Start(kTestFilename);
  89. writer.Write(kTestDataOne);
  90. writer.Write(kTestDataTwo);
  91. writer.Write(kTestDataThree);
  92. writer.Close();
  93. ASSERT_EQ(false, complete_called_);
  94. task_environment_.RunUntilIdle();
  95. ASSERT_EQ(true, complete_called_);
  96. ASSERT_EQ(1ul, test_io.files_written.size());
  97. ASSERT_EQ(false, test_io.files_written[0].failed);
  98. std::vector<std::vector<std::uint8_t>> expected_chunks = {
  99. kTestDataOne, kTestDataTwo, kTestDataThree};
  100. ASSERT_EQ(expected_chunks, test_io.files_written[0].chunks);
  101. }
  102. // Verifies BufferedFileWriter calls the error callback in the event of an
  103. // error.
  104. TEST_F(BufferedFileWriterTest, HandlesWriteError) {
  105. FakeFileOperations::TestIo test_io;
  106. auto file_operations = std::make_unique<FakeFileOperations>(&test_io);
  107. BufferedFileWriter writer(
  108. file_operations->CreateWriter(),
  109. base::BindOnce(
  110. &BufferedFileWriterTest_HandlesWriteError_Test::OnCompleted,
  111. base::Unretained(this)),
  112. base::BindOnce(&BufferedFileWriterTest_HandlesWriteError_Test::OnError,
  113. base::Unretained(this)));
  114. protocol::FileTransfer_Error fake_error = protocol::MakeFileTransferError(
  115. FROM_HERE, protocol::FileTransfer_Error_Type_IO_ERROR);
  116. writer.Start(kTestFilename);
  117. writer.Write(kTestDataOne);
  118. writer.Write(kTestDataTwo);
  119. task_environment_.RunUntilIdle();
  120. test_io.io_error = fake_error;
  121. writer.Write(kTestDataThree);
  122. writer.Close();
  123. task_environment_.RunUntilIdle();
  124. ASSERT_TRUE(error_);
  125. ASSERT_EQ(fake_error.SerializeAsString(), error_->SerializeAsString());
  126. ASSERT_EQ(1ul, test_io.files_written.size());
  127. ASSERT_EQ(true, test_io.files_written[0].failed);
  128. std::vector<std::vector<std::uint8_t>> expected_chunks = {kTestDataOne,
  129. kTestDataTwo};
  130. ASSERT_EQ(expected_chunks, test_io.files_written[0].chunks);
  131. }
  132. // Verifies canceling BufferedFileWriter cancels the underlying writer.
  133. TEST_F(BufferedFileWriterTest, CancelsWriter) {
  134. FakeFileOperations::TestIo test_io;
  135. auto file_operations = std::make_unique<FakeFileOperations>(&test_io);
  136. {
  137. BufferedFileWriter writer(
  138. file_operations->CreateWriter(),
  139. base::BindOnce(&BufferedFileWriterTest_CancelsWriter_Test::OnCompleted,
  140. base::Unretained(this)),
  141. base::BindOnce(&BufferedFileWriterTest_CancelsWriter_Test::OnError,
  142. base::Unretained(this)));
  143. protocol::FileTransfer_Error fake_error = protocol::MakeFileTransferError(
  144. FROM_HERE, protocol::FileTransfer_Error_Type_IO_ERROR);
  145. writer.Start(kTestFilename);
  146. writer.Write(kTestDataOne);
  147. writer.Write(kTestDataTwo);
  148. task_environment_.RunUntilIdle();
  149. writer.Write(kTestDataThree);
  150. }
  151. task_environment_.RunUntilIdle();
  152. ASSERT_TRUE(!complete_called_ && !error_);
  153. ASSERT_EQ(1ul, test_io.files_written.size());
  154. ASSERT_EQ(true, test_io.files_written[0].failed);
  155. std::vector<std::vector<std::uint8_t>> expected_chunks = {kTestDataOne,
  156. kTestDataTwo};
  157. ASSERT_EQ(expected_chunks, test_io.files_written[0].chunks);
  158. }
  159. } // namespace remoting