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