diff options
Diffstat (limited to 'chromium/storage/browser/blob/blob_url_request_job_unittest.cc')
| -rw-r--r-- | chromium/storage/browser/blob/blob_url_request_job_unittest.cc | 608 |
1 files changed, 608 insertions, 0 deletions
diff --git a/chromium/storage/browser/blob/blob_url_request_job_unittest.cc b/chromium/storage/browser/blob/blob_url_request_job_unittest.cc new file mode 100644 index 00000000000..10c31138c55 --- /dev/null +++ b/chromium/storage/browser/blob/blob_url_request_job_unittest.cc @@ -0,0 +1,608 @@ +// Copyright 2013 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include <stdint.h> + +#include <limits> +#include <memory> + +#include "base/bind.h" +#include "base/files/file_path.h" +#include "base/files/file_util.h" +#include "base/files/scoped_temp_dir.h" +#include "base/macros.h" +#include "base/memory/ptr_util.h" +#include "base/memory/ref_counted.h" +#include "base/numerics/safe_conversions.h" +#include "base/run_loop.h" +#include "base/threading/thread_task_runner_handle.h" +#include "base/time/time.h" +#include "net/base/net_errors.h" +#include "net/base/request_priority.h" +#include "net/base/test_completion_callback.h" +#include "net/disk_cache/disk_cache.h" +#include "net/http/http_byte_range.h" +#include "net/http/http_request_headers.h" +#include "net/http/http_response_headers.h" +#include "net/url_request/url_request.h" +#include "net/url_request/url_request_context.h" +#include "net/url_request/url_request_job_factory_impl.h" +#include "net/url_request/url_request_test_util.h" +#include "storage/browser/blob/blob_data_builder.h" +#include "storage/browser/blob/blob_data_handle.h" +#include "storage/browser/blob/blob_data_snapshot.h" +#include "storage/browser/blob/blob_storage_context.h" +#include "storage/browser/blob/blob_url_request_job.h" +#include "storage/browser/fileapi/file_system_context.h" +#include "storage/browser/fileapi/file_system_operation_context.h" +#include "storage/browser/fileapi/file_system_url.h" +#include "storage/browser/test/async_file_test_helper.h" +#include "storage/browser/test/test_file_system_context.h" +#include "testing/gtest/include/gtest/gtest.h" + +using storage::BlobDataSnapshot; +using storage::BlobDataBuilder; +using storage::BlobURLRequestJob; + +namespace content { + +namespace { + +const int kBufferSize = 1024; +const char kTestData1[] = "Hello"; +const char kTestData2[] = "Here it is data."; +const char kTestFileData1[] = "0123456789"; +const char kTestFileData2[] = "This is sample file."; +const char kTestFileSystemFileData1[] = "abcdefghijklmnop"; +const char kTestFileSystemFileData2[] = "File system file test data."; +const char kTestDiskCacheKey1[] = "key1"; +const char kTestDiskCacheKey2[] = "key2"; +const char kTestDiskCacheData1[] = "disk cache test data1."; +const char kTestDiskCacheData2[] = "disk cache test data2."; +const char kTestDiskCacheSideData[] = "test side data"; +const char kTestContentType[] = "foo/bar"; +const char kTestContentDisposition[] = "attachment; filename=foo.txt"; + +const char kFileSystemURLOrigin[] = "http://remote"; +const storage::FileSystemType kFileSystemType = + storage::kFileSystemTypeTemporary; + +const int kTestDiskCacheStreamIndex = 0; +const int kTestDiskCacheSideStreamIndex = 1; + +// Our disk cache tests don't need a real data handle since the tests themselves +// scope the disk cache and entries. +class EmptyDataHandle : public storage::BlobDataBuilder::DataHandle { + private: + ~EmptyDataHandle() override {} +}; + +std::unique_ptr<disk_cache::Backend> CreateInMemoryDiskCache() { + std::unique_ptr<disk_cache::Backend> cache; + net::TestCompletionCallback callback; + int rv = disk_cache::CreateCacheBackend( + net::MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false, + nullptr, nullptr, &cache, callback.callback()); + EXPECT_EQ(net::OK, callback.GetResult(rv)); + + return cache; +} + +disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache, + const char* key, + const std::string& data) { + disk_cache::Entry* temp_entry = nullptr; + net::TestCompletionCallback callback; + int rv = cache->CreateEntry(key, &temp_entry, callback.callback()); + if (callback.GetResult(rv) != net::OK) + return nullptr; + disk_cache::ScopedEntryPtr entry(temp_entry); + + scoped_refptr<net::StringIOBuffer> iobuffer = new net::StringIOBuffer(data); + rv = entry->WriteData(kTestDiskCacheStreamIndex, 0, iobuffer.get(), + iobuffer->size(), callback.callback(), false); + EXPECT_EQ(static_cast<int>(data.size()), callback.GetResult(rv)); + return entry; +} + +disk_cache::ScopedEntryPtr CreateDiskCacheEntryWithSideData( + disk_cache::Backend* cache, + const char* key, + const std::string& data, + const std::string& side_data) { + disk_cache::ScopedEntryPtr entry = CreateDiskCacheEntry(cache, key, data); + scoped_refptr<net::StringIOBuffer> iobuffer = + new net::StringIOBuffer(side_data); + net::TestCompletionCallback callback; + int rv = entry->WriteData(kTestDiskCacheSideStreamIndex, 0, iobuffer.get(), + iobuffer->size(), callback.callback(), false); + EXPECT_EQ(static_cast<int>(side_data.size()), callback.GetResult(rv)); + return entry; +} + +} // namespace + +class BlobURLRequestJobTest : public testing::Test { + public: + // A simple ProtocolHandler implementation to create BlobURLRequestJob. + class MockProtocolHandler + : public net::URLRequestJobFactory::ProtocolHandler { + public: + MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {} + + // net::URLRequestJobFactory::ProtocolHandler override. + net::URLRequestJob* MaybeCreateJob( + net::URLRequest* request, + net::NetworkDelegate* network_delegate) const override { + return new BlobURLRequestJob(request, network_delegate, + test_->GetHandleFromBuilder(), + test_->file_system_context_.get(), + base::ThreadTaskRunnerHandle::Get().get()); + } + + private: + BlobURLRequestJobTest* test_; + }; + + BlobURLRequestJobTest() + : blob_data_(new BlobDataBuilder("uuid")), expected_status_code_(0) {} + + void SetUp() override { + ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); + + temp_file1_ = temp_dir_.GetPath().AppendASCII("BlobFile1.dat"); + ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1), + base::WriteFile(temp_file1_, kTestFileData1, + arraysize(kTestFileData1) - 1)); + base::File::Info file_info1; + base::GetFileInfo(temp_file1_, &file_info1); + temp_file_modification_time1_ = file_info1.last_modified; + + temp_file2_ = temp_dir_.GetPath().AppendASCII("BlobFile2.dat"); + ASSERT_EQ(static_cast<int>(arraysize(kTestFileData2) - 1), + base::WriteFile(temp_file2_, kTestFileData2, + arraysize(kTestFileData2) - 1)); + base::File::Info file_info2; + base::GetFileInfo(temp_file2_, &file_info2); + temp_file_modification_time2_ = file_info2.last_modified; + + disk_cache_backend_ = CreateInMemoryDiskCache(); + disk_cache_entry_ = CreateDiskCacheEntry( + disk_cache_backend_.get(), kTestDiskCacheKey1, kTestDiskCacheData1); + + url_request_job_factory_.SetProtocolHandler( + "blob", base::MakeUnique<MockProtocolHandler>(this)); + url_request_context_.set_job_factory(&url_request_job_factory_); + } + + void TearDown() override { + blob_handle_.reset(); + request_.reset(); + // Clean up for ASAN + base::RunLoop run_loop; + run_loop.RunUntilIdle(); + } + + void SetUpFileSystem() { + // Prepare file system. + file_system_context_ = + CreateFileSystemContextForTesting(NULL, temp_dir_.GetPath()); + + file_system_context_->OpenFileSystem( + GURL(kFileSystemURLOrigin), kFileSystemType, + storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT, + base::Bind(&BlobURLRequestJobTest::OnValidateFileSystem, + base::Unretained(this))); + base::RunLoop().RunUntilIdle(); + ASSERT_TRUE(file_system_root_url_.is_valid()); + + // Prepare files on file system. + const char kFilename1[] = "FileSystemFile1.dat"; + temp_file_system_file1_ = GetFileSystemURL(kFilename1); + WriteFileSystemFile(kFilename1, kTestFileSystemFileData1, + arraysize(kTestFileSystemFileData1) - 1, + &temp_file_system_file_modification_time1_); + const char kFilename2[] = "FileSystemFile2.dat"; + temp_file_system_file2_ = GetFileSystemURL(kFilename2); + WriteFileSystemFile(kFilename2, kTestFileSystemFileData2, + arraysize(kTestFileSystemFileData2) - 1, + &temp_file_system_file_modification_time2_); + } + + GURL GetFileSystemURL(const std::string& filename) { + return GURL(file_system_root_url_.spec() + filename); + } + + void WriteFileSystemFile(const std::string& filename, + const char* buf, + int buf_size, + base::Time* modification_time) { + storage::FileSystemURL url = + file_system_context_->CreateCrackedFileSystemURL( + GURL(kFileSystemURLOrigin), kFileSystemType, + base::FilePath().AppendASCII(filename)); + + ASSERT_EQ(base::File::FILE_OK, + content::AsyncFileTestHelper::CreateFileWithData( + file_system_context_.get(), url, buf, buf_size)); + + base::File::Info file_info; + ASSERT_EQ(base::File::FILE_OK, + content::AsyncFileTestHelper::GetMetadata( + file_system_context_.get(), url, &file_info)); + if (modification_time) + *modification_time = file_info.last_modified; + } + + void OnValidateFileSystem(const GURL& root, + const std::string& name, + base::File::Error result) { + ASSERT_EQ(base::File::FILE_OK, result); + ASSERT_TRUE(root.is_valid()); + file_system_root_url_ = root; + } + + void TestSuccessNonrangeRequest(const std::string& expected_response, + int64_t expected_content_length) { + expected_status_code_ = 200; + expected_response_ = expected_response; + TestRequest("GET", net::HttpRequestHeaders()); + EXPECT_EQ(expected_content_length, + request_->response_headers()->GetContentLength()); + } + + void TestErrorRequest(int expected_status_code) { + expected_status_code_ = expected_status_code; + expected_response_ = ""; + TestRequest("GET", net::HttpRequestHeaders()); + EXPECT_FALSE(request_->response_info().metadata); + } + + void TestRequest(const std::string& method, + const net::HttpRequestHeaders& extra_headers) { + request_ = url_request_context_.CreateRequest( + GURL("blob:blah"), net::DEFAULT_PRIORITY, &url_request_delegate_); + request_->set_method(method); + if (!extra_headers.IsEmpty()) + request_->SetExtraRequestHeaders(extra_headers); + request_->Start(); + + base::RunLoop().Run(); + + // Verify response. + EXPECT_EQ(net::OK, url_request_delegate_.request_status()); + EXPECT_EQ(expected_status_code_, + request_->response_headers()->response_code()); + EXPECT_EQ(expected_response_, url_request_delegate_.data_received()); + } + + void BuildComplicatedData(std::string* expected_result) { + blob_data_->AppendData(kTestData1 + 1, 2); + *expected_result = std::string(kTestData1 + 1, 2); + + blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_); + *expected_result += std::string(kTestFileData1 + 2, 3); + + blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(), + disk_cache_entry_.get(), + kTestDiskCacheStreamIndex); + *expected_result += std::string(kTestDiskCacheData1); + + blob_data_->AppendFileSystemFile(temp_file_system_file1_, 3, 4, + temp_file_system_file_modification_time1_); + *expected_result += std::string(kTestFileSystemFileData1 + 3, 4); + + blob_data_->AppendData(kTestData2 + 4, 5); + *expected_result += std::string(kTestData2 + 4, 5); + + blob_data_->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_); + *expected_result += std::string(kTestFileData2 + 5, 6); + + blob_data_->AppendFileSystemFile(temp_file_system_file2_, 6, 7, + temp_file_system_file_modification_time2_); + *expected_result += std::string(kTestFileSystemFileData2 + 6, 7); + } + + storage::BlobDataHandle* GetHandleFromBuilder() { + if (!blob_handle_) { + blob_handle_ = blob_context_.AddFinishedBlob(blob_data_.get()); + } + return blob_handle_.get(); + } + + // This only works if all the Blob items have a definite pre-computed length. + // Otherwise, this will fail a CHECK. + int64_t GetTotalBlobLength() { + int64_t total = 0; + std::unique_ptr<BlobDataSnapshot> data = + GetHandleFromBuilder()->CreateSnapshot(); + const auto& items = data->items(); + for (const auto& item : items) { + int64_t length = base::checked_cast<int64_t>(item->length()); + CHECK(length <= std::numeric_limits<int64_t>::max() - total); + total += length; + } + return total; + } + + protected: + base::ScopedTempDir temp_dir_; + base::FilePath temp_file1_; + base::FilePath temp_file2_; + base::Time temp_file_modification_time1_; + base::Time temp_file_modification_time2_; + GURL file_system_root_url_; + GURL temp_file_system_file1_; + GURL temp_file_system_file2_; + base::Time temp_file_system_file_modification_time1_; + base::Time temp_file_system_file_modification_time2_; + + std::unique_ptr<disk_cache::Backend> disk_cache_backend_; + disk_cache::ScopedEntryPtr disk_cache_entry_; + + base::MessageLoopForIO message_loop_; + scoped_refptr<storage::FileSystemContext> file_system_context_; + + storage::BlobStorageContext blob_context_; + std::unique_ptr<storage::BlobDataHandle> blob_handle_; + std::unique_ptr<BlobDataBuilder> blob_data_; + std::unique_ptr<BlobDataSnapshot> blob_data_snapshot_; + net::URLRequestJobFactoryImpl url_request_job_factory_; + net::URLRequestContext url_request_context_; + net::TestDelegate url_request_delegate_; + std::unique_ptr<net::URLRequest> request_; + + int expected_status_code_; + std::string expected_response_; +}; + +TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) { + blob_data_->AppendData(kTestData1); + TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1); +} + +TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) { + blob_data_->AppendFile(temp_file1_, 0, std::numeric_limits<uint64_t>::max(), + base::Time()); + TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1); +} + +TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) { + base::FilePath large_temp_file = + temp_dir_.GetPath().AppendASCII("LargeBlob.dat"); + std::string large_data; + large_data.reserve(kBufferSize * 5); + for (int i = 0; i < kBufferSize * 5; ++i) + large_data.append(1, static_cast<char>(i % 256)); + ASSERT_EQ( + static_cast<int>(large_data.size()), + base::WriteFile(large_temp_file, large_data.data(), large_data.size())); + blob_data_->AppendFile(large_temp_file, 0, + std::numeric_limits<uint64_t>::max(), base::Time()); + TestSuccessNonrangeRequest(large_data, large_data.size()); +} + +TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) { + base::FilePath non_existent_file = + temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na")); + blob_data_->AppendFile(non_existent_file, 0, + std::numeric_limits<uint64_t>::max(), base::Time()); + TestErrorRequest(404); +} + +TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) { + base::Time old_time = + temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10); + blob_data_->AppendFile(temp_file1_, 0, 3, old_time); + TestErrorRequest(404); +} + +TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) { + blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_); + std::string result(kTestFileData1 + 2, 4); + TestSuccessNonrangeRequest(result, 4); +} + +TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) { + SetUpFileSystem(); + blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, + std::numeric_limits<uint64_t>::max(), + base::Time()); + TestSuccessNonrangeRequest(kTestFileSystemFileData1, + arraysize(kTestFileSystemFileData1) - 1); +} + +TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) { + SetUpFileSystem(); + std::string large_data; + large_data.reserve(kBufferSize * 5); + for (int i = 0; i < kBufferSize * 5; ++i) + large_data.append(1, static_cast<char>(i % 256)); + + const char kFilename[] = "LargeBlob.dat"; + WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL); + + blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, + std::numeric_limits<uint64_t>::max(), + base::Time()); + TestSuccessNonrangeRequest(large_data, large_data.size()); +} + +TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) { + SetUpFileSystem(); + GURL non_existent_file = GetFileSystemURL("non-existent.dat"); + blob_data_->AppendFileSystemFile( + non_existent_file, 0, std::numeric_limits<uint64_t>::max(), base::Time()); + TestErrorRequest(404); +} + +TEST_F(BlobURLRequestJobTest, TestGetInvalidFileSystemFileRequest) { + SetUpFileSystem(); + GURL invalid_file; + blob_data_->AppendFileSystemFile( + invalid_file, 0, std::numeric_limits<uint64_t>::max(), base::Time()); + TestErrorRequest(500); +} + +TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) { + SetUpFileSystem(); + base::Time old_time = temp_file_system_file_modification_time1_ - + base::TimeDelta::FromSeconds(10); + blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time); + TestErrorRequest(404); +} + +TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) { + SetUpFileSystem(); + blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4, + temp_file_system_file_modification_time1_); + std::string result(kTestFileSystemFileData1 + 2, 4); + TestSuccessNonrangeRequest(result, 4); +} + +TEST_F(BlobURLRequestJobTest, TestGetSimpleDiskCacheRequest) { + blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(), + disk_cache_entry_.get(), + kTestDiskCacheStreamIndex); + TestSuccessNonrangeRequest(kTestDiskCacheData1, + arraysize(kTestDiskCacheData1) - 1); +} + +TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataFileAndDiskCacheRequest) { + SetUpFileSystem(); + std::string result; + BuildComplicatedData(&result); + TestSuccessNonrangeRequest(result, GetTotalBlobLength()); +} + +TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) { + SetUpFileSystem(); + std::string result; + BuildComplicatedData(&result); + net::HttpRequestHeaders extra_headers; + extra_headers.SetHeader(net::HttpRequestHeaders::kRange, + net::HttpByteRange::Bounded(5, 10).GetHeaderValue()); + expected_status_code_ = 206; + expected_response_ = result.substr(5, 10 - 5 + 1); + TestRequest("GET", extra_headers); + + EXPECT_EQ(6, request_->response_headers()->GetContentLength()); + EXPECT_FALSE(request_->response_info().metadata); + + int64_t first = 0, last = 0, length = 0; + EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last, + &length)); + EXPECT_EQ(5, first); + EXPECT_EQ(10, last); + EXPECT_EQ(GetTotalBlobLength(), length); +} + +TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) { + SetUpFileSystem(); + std::string result; + BuildComplicatedData(&result); + net::HttpRequestHeaders extra_headers; + extra_headers.SetHeader(net::HttpRequestHeaders::kRange, + net::HttpByteRange::Suffix(10).GetHeaderValue()); + expected_status_code_ = 206; + expected_response_ = result.substr(result.length() - 10); + TestRequest("GET", extra_headers); + + EXPECT_EQ(10, request_->response_headers()->GetContentLength()); + EXPECT_FALSE(request_->response_info().metadata); + + int64_t total = GetTotalBlobLength(); + int64_t first = 0, last = 0, length = 0; + EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last, + &length)); + EXPECT_EQ(total - 10, first); + EXPECT_EQ(total - 1, last); + EXPECT_EQ(total, length); +} + +TEST_F(BlobURLRequestJobTest, TestGetRangeRequest3) { + SetUpFileSystem(); + std::string result; + BuildComplicatedData(&result); + net::HttpRequestHeaders extra_headers; + extra_headers.SetHeader(net::HttpRequestHeaders::kRange, + net::HttpByteRange::Bounded(0, 2).GetHeaderValue()); + expected_status_code_ = 206; + expected_response_ = result.substr(0, 3); + TestRequest("GET", extra_headers); + + EXPECT_EQ(3, request_->response_headers()->GetContentLength()); + EXPECT_FALSE(request_->response_info().metadata); + + int64_t first = 0, last = 0, length = 0; + EXPECT_TRUE(request_->response_headers()->GetContentRangeFor206(&first, &last, + &length)); + EXPECT_EQ(0, first); + EXPECT_EQ(2, last); + EXPECT_EQ(GetTotalBlobLength(), length); +} + +TEST_F(BlobURLRequestJobTest, TestExtraHeaders) { + blob_data_->set_content_type(kTestContentType); + blob_data_->set_content_disposition(kTestContentDisposition); + blob_data_->AppendData(kTestData1); + expected_status_code_ = 200; + expected_response_ = kTestData1; + TestRequest("GET", net::HttpRequestHeaders()); + + std::string content_type; + EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type)); + EXPECT_EQ(kTestContentType, content_type); + EXPECT_FALSE(request_->response_info().metadata); + size_t iter = 0; + std::string content_disposition; + EXPECT_TRUE(request_->response_headers()->EnumerateHeader( + &iter, "Content-Disposition", &content_disposition)); + EXPECT_EQ(kTestContentDisposition, content_disposition); +} + +TEST_F(BlobURLRequestJobTest, TestSideData) { + disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data = + CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(), + kTestDiskCacheKey2, kTestDiskCacheData2, + kTestDiskCacheSideData); + blob_data_->AppendDiskCacheEntryWithSideData( + new EmptyDataHandle(), disk_cache_entry_with_side_data.get(), + kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex); + expected_status_code_ = 200; + expected_response_ = kTestDiskCacheData2; + TestRequest("GET", net::HttpRequestHeaders()); + EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1), + request_->response_headers()->GetContentLength()); + + ASSERT_TRUE(request_->response_info().metadata); + std::string metadata(request_->response_info().metadata->data(), + request_->response_info().metadata->size()); + EXPECT_EQ(std::string(kTestDiskCacheSideData), metadata); +} + +TEST_F(BlobURLRequestJobTest, TestZeroSizeSideData) { + disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data = + CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(), + kTestDiskCacheKey2, kTestDiskCacheData2, + ""); + blob_data_->AppendDiskCacheEntryWithSideData( + new EmptyDataHandle(), disk_cache_entry_with_side_data.get(), + kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex); + expected_status_code_ = 200; + expected_response_ = kTestDiskCacheData2; + TestRequest("GET", net::HttpRequestHeaders()); + EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1), + request_->response_headers()->GetContentLength()); + + EXPECT_FALSE(request_->response_info().metadata); +} + +TEST_F(BlobURLRequestJobTest, BrokenBlob) { + blob_handle_ = blob_context_.AddBrokenBlob( + "uuid", "", "", storage::BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS); + TestErrorRequest(500); +} + +} // namespace content |