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