src/content/browser/fileapi/blob_url_request_job_unittest.cc

   1 // Copyright 2013 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 "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/files/file_path.h"
   8 #include "base/files/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/numerics/safe_conversions.h"
  13 #include "base/run_loop.h"
  14 #include "base/time/time.h"
  15 #include "content/browser/fileapi/mock_url_request_delegate.h"
  16 #include "content/public/test/async_file_test_helper.h"
  17 #include "content/public/test/test_file_system_context.h"
  18 #include "net/base/request_priority.h"
  19 #include "net/http/http_byte_range.h"
  20 #include "net/http/http_request_headers.h"
  21 #include "net/http/http_response_headers.h"
  22 #include "net/url_request/url_request.h"
  23 #include "net/url_request/url_request_context.h"
  24 #include "net/url_request/url_request_job_factory_impl.h"
  25 #include "storage/browser/blob/blob_url_request_job.h"
  26 #include "storage/browser/fileapi/file_system_context.h"
  27 #include "storage/browser/fileapi/file_system_operation_context.h"
  28 #include "storage/browser/fileapi/file_system_url.h"
  29 #include "storage/common/blob/blob_data.h"
  30 #include "testing/gtest/include/gtest/gtest.h"
  31
  32 using storage::BlobData;
  33 using storage::BlobURLRequestJob;
  34
  35 namespace content {
  36
  37 namespace {
  38
  39 const int kBufferSize = 1024;
  40 const char kTestData1[] = "Hello";
  41 const char kTestData2[] = "Here it is data.";
  42 const char kTestFileData1[] = "0123456789";
  43 const char kTestFileData2[] = "This is sample file.";
  44 const char kTestFileSystemFileData1[] = "abcdefghijklmnop";
  45 const char kTestFileSystemFileData2[] = "File system file test data.";
  46 const char kTestContentType[] = "foo/bar";
  47 const char kTestContentDisposition[] = "attachment; filename=foo.txt";
  48
  49 const char kFileSystemURLOrigin[] = "http://remote";
  50 const storage::FileSystemType kFileSystemType =
  51     storage::kFileSystemTypeTemporary;
  52
  53 }  // namespace
  54
  55 class BlobURLRequestJobTest : public testing::Test {
  56  public:
  57   // A simple ProtocolHandler implementation to create BlobURLRequestJob.
  58   class MockProtocolHandler :
  59       public net::URLRequestJobFactory::ProtocolHandler {
  60    public:
  61     MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
  62
  63     // net::URLRequestJobFactory::ProtocolHandler override.
  64     net::URLRequestJob* MaybeCreateJob(
  65         net::URLRequest* request,
  66         net::NetworkDelegate* network_delegate) const override {
  67       return new BlobURLRequestJob(request,
  68                                    network_delegate,
  69                                    test_->blob_data_.get(),
  70                                    test_->file_system_context_.get(),
  71                                    base::MessageLoopProxy::current().get());
  72     }
  73
  74    private:
  75     BlobURLRequestJobTest* test_;
  76   };
  77
  78   BlobURLRequestJobTest()
  79       : blob_data_(new BlobData()),
  80         expected_status_code_(0) {}
  81
  82   void SetUp() override {
  83     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  84
  85     temp_file1_ = temp_dir_.path().AppendASCII("BlobFile1.dat");
  86     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
  87               base::WriteFile(temp_file1_, kTestFileData1,
  88                                    arraysize(kTestFileData1) - 1));
  89     base::File::Info file_info1;
  90     base::GetFileInfo(temp_file1_, &file_info1);
  91     temp_file_modification_time1_ = file_info1.last_modified;
  92
  93     temp_file2_ = temp_dir_.path().AppendASCII("BlobFile2.dat");
  94     ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1),
  95               base::WriteFile(temp_file2_, kTestFileData2,
  96                                    arraysize(kTestFileData2) - 1));
  97     base::File::Info file_info2;
  98     base::GetFileInfo(temp_file2_, &file_info2);
  99     temp_file_modification_time2_ = file_info2.last_modified;
 100
 101     url_request_job_factory_.SetProtocolHandler("blob",
 102                                                 new MockProtocolHandler(this));
 103     url_request_context_.set_job_factory(&url_request_job_factory_);
 104   }
 105
 106   void TearDown() override {}
 107
 108   void SetUpFileSystem() {
 109     // Prepare file system.
 110     file_system_context_ = CreateFileSystemContextForTesting(
 111         NULL, temp_dir_.path());
 112
 113     file_system_context_->OpenFileSystem(
 114         GURL(kFileSystemURLOrigin),
 115         kFileSystemType,
 116         storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
 117         base::Bind(&BlobURLRequestJobTest::OnValidateFileSystem,
 118                    base::Unretained(this)));
 119     base::RunLoop().RunUntilIdle();
 120     ASSERT_TRUE(file_system_root_url_.is_valid());
 121
 122     // Prepare files on file system.
 123     const char kFilename1[] = "FileSystemFile1.dat";
 124     temp_file_system_file1_ = GetFileSystemURL(kFilename1);
 125     WriteFileSystemFile(kFilename1, kTestFileSystemFileData1,
 126                         arraysize(kTestFileSystemFileData1) - 1,
 127                         &temp_file_system_file_modification_time1_);
 128     const char kFilename2[] = "FileSystemFile2.dat";
 129     temp_file_system_file2_ = GetFileSystemURL(kFilename2);
 130     WriteFileSystemFile(kFilename2, kTestFileSystemFileData2,
 131                         arraysize(kTestFileSystemFileData2) - 1,
 132                         &temp_file_system_file_modification_time2_);
 133   }
 134
 135   GURL GetFileSystemURL(const std::string& filename) {
 136     return GURL(file_system_root_url_.spec() + filename);
 137   }
 138
 139   void WriteFileSystemFile(const std::string& filename,
 140                            const char* buf, int buf_size,
 141                            base::Time* modification_time) {
 142     storage::FileSystemURL url =
 143         file_system_context_->CreateCrackedFileSystemURL(
 144             GURL(kFileSystemURLOrigin),
 145             kFileSystemType,
 146             base::FilePath().AppendASCII(filename));
 147
 148     ASSERT_EQ(base::File::FILE_OK,
 149               content::AsyncFileTestHelper::CreateFileWithData(
 150                   file_system_context_.get(), url, buf, buf_size));
 151
 152     base::File::Info file_info;
 153     ASSERT_EQ(base::File::FILE_OK,
 154               content::AsyncFileTestHelper::GetMetadata(
 155                   file_system_context_.get(), url, &file_info));
 156     if (modification_time)
 157       *modification_time = file_info.last_modified;
 158   }
 159
 160   void OnValidateFileSystem(const GURL& root,
 161                             const std::string& name,
 162                             base::File::Error result) {
 163     ASSERT_EQ(base::File::FILE_OK, result);
 164     ASSERT_TRUE(root.is_valid());
 165     file_system_root_url_ = root;
 166   }
 167
 168   void TestSuccessNonrangeRequest(const std::string& expected_response,
 169                                   int64 expected_content_length) {
 170     expected_status_code_ = 200;
 171     expected_response_ = expected_response;
 172     TestRequest("GET", net::HttpRequestHeaders());
 173     EXPECT_EQ(expected_content_length,
 174               request_->response_headers()->GetContentLength());
 175   }
 176
 177   void TestErrorRequest(int expected_status_code) {
 178     expected_status_code_ = expected_status_code;
 179     expected_response_ = "";
 180     TestRequest("GET", net::HttpRequestHeaders());
 181   }
 182
 183   void TestRequest(const std::string& method,
 184                    const net::HttpRequestHeaders& extra_headers) {
 185     request_ = url_request_context_.CreateRequest(
 186         GURL("blob:blah"), net::DEFAULT_PRIORITY, &url_request_delegate_, NULL);
 187     request_->set_method(method);
 188     if (!extra_headers.IsEmpty())
 189       request_->SetExtraRequestHeaders(extra_headers);
 190     request_->Start();
 191
 192     base::MessageLoop::current()->Run();
 193
 194     // Verify response.
 195     EXPECT_TRUE(request_->status().is_success());
 196     EXPECT_EQ(expected_status_code_,
 197               request_->response_headers()->response_code());
 198     EXPECT_EQ(expected_response_, url_request_delegate_.response_data());
 199   }
 200
 201   void BuildComplicatedData(std::string* expected_result) {
 202     blob_data_->AppendData(kTestData1 + 1, 2);
 203     blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
 204     blob_data_->AppendFileSystemFile(temp_file_system_file1_, 3, 4,
 205                                      temp_file_system_file_modification_time1_);
 206     blob_data_->AppendData(kTestData2 + 4, 5);
 207     blob_data_->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
 208     blob_data_->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
 209                                      temp_file_system_file_modification_time2_);
 210     *expected_result = std::string(kTestData1 + 1, 2);
 211     *expected_result += std::string(kTestFileData1 + 2, 3);
 212     *expected_result += std::string(kTestFileSystemFileData1 + 3, 4);
 213     *expected_result += std::string(kTestData2 + 4, 5);
 214     *expected_result += std::string(kTestFileData2 + 5, 6);
 215     *expected_result += std::string(kTestFileSystemFileData2 + 6, 7);
 216   }
 217
 218   // This only works if all the Blob items have a definite pre-computed length.
 219   // Otherwise, this will fail a CHECK.
 220   int64 GetTotalBlobLength() const {
 221     int64 total = 0;
 222     const std::vector<BlobData::Item>& items = blob_data_->items();
 223     for (std::vector<BlobData::Item>::const_iterator it = items.begin();
 224          it != items.end(); ++it) {
 225       int64 length = base::checked_cast<int64>(it->length());
 226       CHECK(length <= kint64max - total);
 227       total += length;
 228     }
 229     return total;
 230   }
 231
 232  protected:
 233   base::ScopedTempDir temp_dir_;
 234   base::FilePath temp_file1_;
 235   base::FilePath temp_file2_;
 236   base::Time temp_file_modification_time1_;
 237   base::Time temp_file_modification_time2_;
 238   GURL file_system_root_url_;
 239   GURL temp_file_system_file1_;
 240   GURL temp_file_system_file2_;
 241   base::Time temp_file_system_file_modification_time1_;
 242   base::Time temp_file_system_file_modification_time2_;
 243
 244   base::MessageLoopForIO message_loop_;
 245   scoped_refptr<storage::FileSystemContext> file_system_context_;
 246   scoped_refptr<BlobData> blob_data_;
 247   net::URLRequestJobFactoryImpl url_request_job_factory_;
 248   net::URLRequestContext url_request_context_;
 249   MockURLRequestDelegate url_request_delegate_;
 250   scoped_ptr<net::URLRequest> request_;
 251
 252   int expected_status_code_;
 253   std::string expected_response_;
 254 };
 255
 256 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
 257   blob_data_->AppendData(kTestData1);
 258   TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1);
 259 }
 260
 261 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
 262   blob_data_->AppendFile(temp_file1_, 0, kuint64max, base::Time());
 263   TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1);
 264 }
 265
 266 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
 267   base::FilePath large_temp_file =
 268       temp_dir_.path().AppendASCII("LargeBlob.dat");
 269   std::string large_data;
 270   large_data.reserve(kBufferSize * 5);
 271   for (int i = 0; i < kBufferSize * 5; ++i)
 272     large_data.append(1, static_cast<char>(i % 256));
 273   ASSERT_EQ(static_cast<int>(large_data.size()),
 274             base::WriteFile(large_temp_file, large_data.data(),
 275                                  large_data.size()));
 276   blob_data_->AppendFile(large_temp_file, 0, kuint64max, base::Time());
 277   TestSuccessNonrangeRequest(large_data, large_data.size());
 278 }
 279
 280 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
 281   base::FilePath non_existent_file =
 282       temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
 283   blob_data_->AppendFile(non_existent_file, 0, kuint64max, base::Time());
 284   TestErrorRequest(404);
 285 }
 286
 287 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
 288   base::Time old_time =
 289       temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10);
 290   blob_data_->AppendFile(temp_file1_, 0, 3, old_time);
 291   TestErrorRequest(404);
 292 }
 293
 294 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
 295   blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
 296   std::string result(kTestFileData1 + 2, 4);
 297   TestSuccessNonrangeRequest(result, 4);
 298 }
 299
 300 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
 301   SetUpFileSystem();
 302   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, kuint64max,
 303                                    base::Time());
 304   TestSuccessNonrangeRequest(kTestFileSystemFileData1,
 305                              arraysize(kTestFileSystemFileData1) - 1);
 306 }
 307
 308 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
 309   SetUpFileSystem();
 310   std::string large_data;
 311   large_data.reserve(kBufferSize * 5);
 312   for (int i = 0; i < kBufferSize * 5; ++i)
 313     large_data.append(1, static_cast<char>(i % 256));
 314
 315   const char kFilename[] = "LargeBlob.dat";
 316   WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
 317
 318   blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, kuint64max,
 319                                    base::Time());
 320   TestSuccessNonrangeRequest(large_data, large_data.size());
 321 }
 322
 323 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
 324   SetUpFileSystem();
 325   GURL non_existent_file = GetFileSystemURL("non-existent.dat");
 326   blob_data_->AppendFileSystemFile(non_existent_file, 0, kuint64max,
 327                                    base::Time());
 328   TestErrorRequest(404);
 329 }
 330
 331 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
 332   SetUpFileSystem();
 333   base::Time old_time =
 334       temp_file_system_file_modification_time1_ -
 335       base::TimeDelta::FromSeconds(10);
 336   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
 337   TestErrorRequest(404);
 338 }
 339
 340 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
 341   SetUpFileSystem();
 342   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
 343                                   temp_file_system_file_modification_time1_);
 344   std::string result(kTestFileSystemFileData1 + 2, 4);
 345   TestSuccessNonrangeRequest(result, 4);
 346 }
 347
 348 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
 349   SetUpFileSystem();
 350   std::string result;
 351   BuildComplicatedData(&result);
 352   TestSuccessNonrangeRequest(result, GetTotalBlobLength());
 353 }
 354
 355 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
 356   SetUpFileSystem();
 357   std::string result;
 358   BuildComplicatedData(&result);
 359   net::HttpRequestHeaders extra_headers;
 360   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
 361                           net::HttpByteRange::Bounded(5, 10).GetHeaderValue());
 362   expected_status_code_ = 206;
 363   expected_response_ = result.substr(5, 10 - 5 + 1);
 364   TestRequest("GET", extra_headers);
 365
 366   EXPECT_EQ(6, request_->response_headers()->GetContentLength());
 367
 368   int64 first = 0, last = 0, length = 0;
 369   EXPECT_TRUE(
 370       request_->response_headers()->GetContentRange(&first, &last, &length));
 371   EXPECT_EQ(5, first);
 372   EXPECT_EQ(10, last);
 373   EXPECT_EQ(GetTotalBlobLength(), length);
 374 }
 375
 376 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
 377   SetUpFileSystem();
 378   std::string result;
 379   BuildComplicatedData(&result);
 380   net::HttpRequestHeaders extra_headers;
 381   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
 382                           net::HttpByteRange::Suffix(10).GetHeaderValue());
 383   expected_status_code_ = 206;
 384   expected_response_ = result.substr(result.length() - 10);
 385   TestRequest("GET", extra_headers);
 386
 387   EXPECT_EQ(10, request_->response_headers()->GetContentLength());
 388
 389   int64 total = GetTotalBlobLength();
 390   int64 first = 0, last = 0, length = 0;
 391   EXPECT_TRUE(
 392       request_->response_headers()->GetContentRange(&first, &last, &length));
 393   EXPECT_EQ(total - 10, first);
 394   EXPECT_EQ(total - 1, last);
 395   EXPECT_EQ(total, length);
 396 }
 397
 398 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
 399   blob_data_->set_content_type(kTestContentType);
 400   blob_data_->set_content_disposition(kTestContentDisposition);
 401   blob_data_->AppendData(kTestData1);
 402   expected_status_code_ = 200;
 403   expected_response_ = kTestData1;
 404   TestRequest("GET", net::HttpRequestHeaders());
 405
 406   std::string content_type;
 407   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
 408   EXPECT_EQ(kTestContentType, content_type);
 409   void* iter = NULL;
 410   std::string content_disposition;
 411   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
 412       &iter, "Content-Disposition", &content_disposition));
 413   EXPECT_EQ(kTestContentDisposition, content_disposition);
 414 }
 415
 416 }  // namespace content