net/base/upload_file_element_reader_unittest.cc

   1 // Copyright (c) 2012 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
   5 #include "net/base/upload_file_element_reader.h"
   6
   7 #include "base/files/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "base/run_loop.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/base/test_completion_callback.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "testing/platform_test.h"
  16
  17 namespace net {
  18
  19 class UploadFileElementReaderTest : public PlatformTest {
  20  protected:
  21   void SetUp() override {
  22     PlatformTest::SetUp();
  23     // Some tests (*.ReadPartially) rely on bytes_.size() being even.
  24     const char kData[] = "123456789abcdefghi";
  25     bytes_.assign(kData, kData + arraysize(kData) - 1);
  26
  27     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  28
  29     ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
  30                                                &temp_file_path_));
  31     ASSERT_EQ(
  32         static_cast<int>(bytes_.size()),
  33         base::WriteFile(temp_file_path_, &bytes_[0], bytes_.size()));
  34
  35     reader_.reset(
  36         new UploadFileElementReader(base::MessageLoopProxy::current().get(),
  37                                     temp_file_path_,
  38                                     0,
  39                                     kuint64max,
  40                                     base::Time()));
  41     TestCompletionCallback callback;
  42     ASSERT_EQ(ERR_IO_PENDING, reader_->Init(callback.callback()));
  43     EXPECT_EQ(OK, callback.WaitForResult());
  44     EXPECT_EQ(bytes_.size(), reader_->GetContentLength());
  45     EXPECT_EQ(bytes_.size(), reader_->BytesRemaining());
  46     EXPECT_FALSE(reader_->IsInMemory());
  47   }
  48
  49   ~UploadFileElementReaderTest() override {
  50     reader_.reset();
  51     base::RunLoop().RunUntilIdle();
  52   }
  53
  54   std::vector<char> bytes_;
  55   scoped_ptr<UploadElementReader> reader_;
  56   base::ScopedTempDir temp_dir_;
  57   base::FilePath temp_file_path_;
  58 };
  59
  60 TEST_F(UploadFileElementReaderTest, ReadPartially) {
  61   const size_t kHalfSize = bytes_.size() / 2;
  62   ASSERT_EQ(bytes_.size(), kHalfSize * 2);
  63   std::vector<char> buf(kHalfSize);
  64   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
  65   TestCompletionCallback read_callback1;
  66   ASSERT_EQ(ERR_IO_PENDING,
  67             reader_->Read(
  68                 wrapped_buffer.get(), buf.size(), read_callback1.callback()));
  69   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
  70   EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining());
  71   EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf);
  72
  73   TestCompletionCallback read_callback2;
  74   EXPECT_EQ(ERR_IO_PENDING,
  75             reader_->Read(
  76                 wrapped_buffer.get(), buf.size(), read_callback2.callback()));
  77   EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult());
  78   EXPECT_EQ(0U, reader_->BytesRemaining());
  79   EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf);
  80 }
  81
  82 TEST_F(UploadFileElementReaderTest, ReadAll) {
  83   std::vector<char> buf(bytes_.size());
  84   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
  85   TestCompletionCallback read_callback;
  86   ASSERT_EQ(ERR_IO_PENDING,
  87             reader_->Read(
  88                 wrapped_buffer.get(), buf.size(), read_callback.callback()));
  89   EXPECT_EQ(static_cast<int>(buf.size()), read_callback.WaitForResult());
  90   EXPECT_EQ(0U, reader_->BytesRemaining());
  91   EXPECT_EQ(bytes_, buf);
  92   // Try to read again.
  93   EXPECT_EQ(0,
  94             reader_->Read(
  95                 wrapped_buffer.get(), buf.size(), read_callback.callback()));
  96 }
  97
  98 TEST_F(UploadFileElementReaderTest, ReadTooMuch) {
  99   const size_t kTooLargeSize = bytes_.size() * 2;
 100   std::vector<char> buf(kTooLargeSize);
 101   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 102   TestCompletionCallback read_callback;
 103   ASSERT_EQ(ERR_IO_PENDING,
 104             reader_->Read(
 105                 wrapped_buffer.get(), buf.size(), read_callback.callback()));
 106   EXPECT_EQ(static_cast<int>(bytes_.size()), read_callback.WaitForResult());
 107   EXPECT_EQ(0U, reader_->BytesRemaining());
 108   buf.resize(bytes_.size());  // Resize to compare.
 109   EXPECT_EQ(bytes_, buf);
 110 }
 111
 112 TEST_F(UploadFileElementReaderTest, MultipleInit) {
 113   std::vector<char> buf(bytes_.size());
 114   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 115
 116   // Read all.
 117   TestCompletionCallback read_callback1;
 118   ASSERT_EQ(ERR_IO_PENDING,
 119             reader_->Read(
 120                 wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 121   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
 122   EXPECT_EQ(0U, reader_->BytesRemaining());
 123   EXPECT_EQ(bytes_, buf);
 124
 125   // Call Init() again to reset the state.
 126   TestCompletionCallback init_callback;
 127   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
 128   EXPECT_EQ(OK, init_callback.WaitForResult());
 129   EXPECT_EQ(bytes_.size(), reader_->GetContentLength());
 130   EXPECT_EQ(bytes_.size(), reader_->BytesRemaining());
 131
 132   // Read again.
 133   TestCompletionCallback read_callback2;
 134   ASSERT_EQ(ERR_IO_PENDING,
 135             reader_->Read(
 136                 wrapped_buffer.get(), buf.size(), read_callback2.callback()));
 137   EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult());
 138   EXPECT_EQ(0U, reader_->BytesRemaining());
 139   EXPECT_EQ(bytes_, buf);
 140 }
 141
 142 TEST_F(UploadFileElementReaderTest, InitDuringAsyncOperation) {
 143   std::vector<char> buf(bytes_.size());
 144   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 145
 146   // Start reading all.
 147   TestCompletionCallback read_callback1;
 148   EXPECT_EQ(ERR_IO_PENDING,
 149             reader_->Read(
 150                 wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 151
 152   // Call Init to cancel the previous read.
 153   TestCompletionCallback init_callback1;
 154   EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback1.callback()));
 155
 156   // Call Init again to cancel the previous init.
 157   TestCompletionCallback init_callback2;
 158   EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback2.callback()));
 159   EXPECT_EQ(OK, init_callback2.WaitForResult());
 160   EXPECT_EQ(bytes_.size(), reader_->GetContentLength());
 161   EXPECT_EQ(bytes_.size(), reader_->BytesRemaining());
 162
 163   // Read half.
 164   std::vector<char> buf2(bytes_.size() / 2);
 165   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
 166   TestCompletionCallback read_callback2;
 167   EXPECT_EQ(ERR_IO_PENDING,
 168             reader_->Read(
 169                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
 170   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
 171   EXPECT_EQ(bytes_.size() - buf2.size(), reader_->BytesRemaining());
 172   EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + buf2.size()),
 173             buf2);
 174
 175   // Make sure callbacks are not called for cancelled operations.
 176   EXPECT_FALSE(read_callback1.have_result());
 177   EXPECT_FALSE(init_callback1.have_result());
 178 }
 179
 180 TEST_F(UploadFileElementReaderTest, Range) {
 181   const uint64 kOffset = 2;
 182   const uint64 kLength = bytes_.size() - kOffset * 3;
 183   reader_.reset(
 184       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 185                                   temp_file_path_,
 186                                   kOffset,
 187                                   kLength,
 188                                   base::Time()));
 189   TestCompletionCallback init_callback;
 190   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
 191   EXPECT_EQ(OK, init_callback.WaitForResult());
 192   EXPECT_EQ(kLength, reader_->GetContentLength());
 193   EXPECT_EQ(kLength, reader_->BytesRemaining());
 194   std::vector<char> buf(kLength);
 195   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 196   TestCompletionCallback read_callback;
 197   ASSERT_EQ(
 198       ERR_IO_PENDING,
 199       reader_->Read(wrapped_buffer.get(), kLength, read_callback.callback()));
 200   EXPECT_EQ(static_cast<int>(kLength), read_callback.WaitForResult());
 201   const std::vector<char> expected(bytes_.begin() + kOffset,
 202                                    bytes_.begin() + kOffset + kLength);
 203   EXPECT_EQ(expected, buf);
 204 }
 205
 206 TEST_F(UploadFileElementReaderTest, FileChanged) {
 207   base::File::Info info;
 208   ASSERT_TRUE(base::GetFileInfo(temp_file_path_, &info));
 209
 210   // Expect one second before the actual modification time to simulate change.
 211   const base::Time expected_modification_time =
 212       info.last_modified - base::TimeDelta::FromSeconds(1);
 213   reader_.reset(new UploadFileElementReader(
 214       base::MessageLoopProxy::current().get(), temp_file_path_, 0, kuint64max,
 215       expected_modification_time));
 216   TestCompletionCallback init_callback;
 217   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
 218   EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult());
 219 }
 220
 221 TEST_F(UploadFileElementReaderTest, InexactExpectedTimeStamp) {
 222   base::File::Info info;
 223   ASSERT_TRUE(base::GetFileInfo(temp_file_path_, &info));
 224
 225   const base::Time expected_modification_time =
 226       info.last_modified - base::TimeDelta::FromMilliseconds(900);
 227   reader_.reset(new UploadFileElementReader(
 228       base::MessageLoopProxy::current().get(), temp_file_path_, 0, kuint64max,
 229       expected_modification_time));
 230   TestCompletionCallback init_callback;
 231   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
 232   EXPECT_EQ(OK, init_callback.WaitForResult());
 233 }
 234
 235 TEST_F(UploadFileElementReaderTest, WrongPath) {
 236   const base::FilePath wrong_path(FILE_PATH_LITERAL("wrong_path"));
 237   reader_.reset(
 238       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 239                                   wrong_path, 0, kuint64max, base::Time()));
 240   TestCompletionCallback init_callback;
 241   ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback()));
 242   EXPECT_EQ(ERR_FILE_NOT_FOUND, init_callback.WaitForResult());
 243 }
 244
 245 }  // namespace net