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.
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"
29 namespace webkit_blob {
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";
43 const char kFileSystemURLOrigin[] = "http://remote";
44 const fileapi::FileSystemType kFileSystemType =
45 fileapi::kFileSystemTypeTemporary;
49 class BlobURLRequestJobTest : public testing::Test {
52 // Test Harness -------------------------------------------------------------
53 // TODO(jianli): share this test harness with AppCacheURLRequestJobTest
55 class MockURLRequestDelegate : public net::URLRequest::Delegate {
57 MockURLRequestDelegate()
58 : received_data_(new net::IOBuffer(kBufferSize)) {}
60 virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {
61 if (request->status().is_success()) {
62 EXPECT_TRUE(request->response_headers());
69 virtual void OnReadCompleted(net::URLRequest* request,
70 int bytes_read) OVERRIDE {
72 ReceiveData(request, bytes_read);
77 const std::string& response_data() const { return response_data_; }
80 void ReadSome(net::URLRequest* request) {
81 if (!request->is_pending()) {
87 if (!request->Read(received_data_.get(), kBufferSize, &bytes_read)) {
88 if (!request->status().is_io_pending()) {
94 ReceiveData(request, bytes_read);
97 void ReceiveData(net::URLRequest* request, int bytes_read) {
99 response_data_.append(received_data_->data(),
100 static_cast<size_t>(bytes_read));
107 void RequestComplete() {
108 base::MessageLoop::current()->Quit();
111 scoped_refptr<net::IOBuffer> received_data_;
112 std::string response_data_;
115 // A simple ProtocolHandler implementation to create BlobURLRequestJob.
116 class MockProtocolHandler :
117 public net::URLRequestJobFactory::ProtocolHandler {
119 MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
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,
127 test_->blob_data_.get(),
128 test_->file_system_context_.get(),
129 base::MessageLoopProxy::current().get());
133 BlobURLRequestJobTest* test_;
136 BlobURLRequestJobTest()
137 : blob_data_(new BlobData()),
138 expected_status_code_(0) {}
140 virtual void SetUp() {
141 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
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;
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;
159 url_request_job_factory_.SetProtocolHandler("blob",
160 new MockProtocolHandler(this));
161 url_request_context_.set_job_factory(&url_request_job_factory_);
164 virtual void TearDown() {
167 void SetUpFileSystem() {
168 // Prepare file system.
169 file_system_context_ = fileapi::CreateFileSystemContextForTesting(
170 NULL, temp_dir_.path());
172 file_system_context_->OpenFileSystem(
173 GURL(kFileSystemURLOrigin),
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());
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_);
194 GURL GetFileSystemURL(const std::string& filename) {
195 return GURL(file_system_root_url_.spec() + filename);
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),
205 base::FilePath().AppendASCII(filename));
207 ASSERT_EQ(base::PLATFORM_FILE_OK,
208 fileapi::AsyncFileTestHelper::CreateFileWithData(
209 file_system_context_, url, buf, buf_size));
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;
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;
227 void TestSuccessRequest(const std::string& expected_response) {
228 expected_status_code_ = 200;
229 expected_response_ = expected_response;
230 TestRequest("GET", net::HttpRequestHeaders());
233 void TestErrorRequest(int expected_status_code) {
234 expected_status_code_ = expected_status_code;
235 expected_response_ = "";
236 TestRequest("GET", net::HttpRequestHeaders());
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);
248 base::MessageLoop::current()->Run();
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());
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);
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_;
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_;
294 int expected_status_code_;
295 std::string expected_response_;
298 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
299 blob_data_->AppendData(kTestData1);
300 TestSuccessRequest(kTestData1);
303 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
304 blob_data_->AppendFile(temp_file1_, 0, -1, base::Time());
305 TestSuccessRequest(kTestFileData1);
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(),
318 blob_data_->AppendFile(large_temp_file, 0, -1, base::Time());
319 TestSuccessRequest(large_data);
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);
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);
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);
342 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
344 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
346 TestSuccessRequest(kTestFileSystemFileData1);
349 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
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));
356 const char kFilename[] = "LargeBlob.dat";
357 WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
359 blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename),
360 0, -1, base::Time());
361 TestSuccessRequest(large_data);
364 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
366 GURL non_existent_file = GetFileSystemURL("non-existent.dat");
367 blob_data_->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
368 TestErrorRequest(404);
371 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
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);
380 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
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);
388 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
391 BuildComplicatedData(&result);
392 TestSuccessRequest(result);
395 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
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);
406 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
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);
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());
425 std::string content_type;
426 EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
427 EXPECT_EQ(kTestContentType, content_type);
429 std::string content_disposition;
430 EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
431 &iter, "Content-Disposition", &content_disposition));
432 EXPECT_EQ(kTestContentDisposition, content_disposition);
435 } // namespace webkit_blob