// Copyright 2014 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 "net/http/http_transaction_test_util.h" #include #include "base/bind.h" #include "base/message_loop/message_loop.h" #include "base/strings/stringprintf.h" #include "base/time/time.h" #include "net/base/load_flags.h" #include "net/base/load_timing_info.h" #include "net/base/net_errors.h" #include "net/disk_cache/disk_cache.h" #include "net/http/http_cache.h" #include "net/http/http_request_info.h" #include "net/http/http_response_info.h" #include "net/http/http_transaction.h" #include "testing/gtest/include/gtest/gtest.h" namespace { typedef base::hash_map MockTransactionMap; static MockTransactionMap mock_transactions; } // namespace //----------------------------------------------------------------------------- // mock transaction data const MockTransaction kSimpleGET_Transaction = { "http://www.google.com/", "GET", base::Time(), "", net::LOAD_NORMAL, "HTTP/1.1 200 OK", "Cache-Control: max-age=10000\n", base::Time(), "Google Blah Blah", TEST_MODE_NORMAL, NULL, 0, net::OK }; const MockTransaction kSimplePOST_Transaction = { "http://bugdatabase.com/edit", "POST", base::Time(), "", net::LOAD_NORMAL, "HTTP/1.1 200 OK", "", base::Time(), "Google Blah Blah", TEST_MODE_NORMAL, NULL, 0, net::OK }; const MockTransaction kTypicalGET_Transaction = { "http://www.example.com/~foo/bar.html", "GET", base::Time(), "", net::LOAD_NORMAL, "HTTP/1.1 200 OK", "Date: Wed, 28 Nov 2007 09:40:09 GMT\n" "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n", base::Time(), "Google Blah Blah", TEST_MODE_NORMAL, NULL, 0, net::OK }; const MockTransaction kETagGET_Transaction = { "http://www.google.com/foopy", "GET", base::Time(), "", net::LOAD_NORMAL, "HTTP/1.1 200 OK", "Cache-Control: max-age=10000\n" "Etag: \"foopy\"\n", base::Time(), "Google Blah Blah", TEST_MODE_NORMAL, NULL, 0, net::OK }; const MockTransaction kRangeGET_Transaction = { "http://www.google.com/", "GET", base::Time(), "Range: 0-100\r\n", net::LOAD_NORMAL, "HTTP/1.1 200 OK", "Cache-Control: max-age=10000\n", base::Time(), "Google Blah Blah", TEST_MODE_NORMAL, NULL, 0, net::OK }; static const MockTransaction* const kBuiltinMockTransactions[] = { &kSimpleGET_Transaction, &kSimplePOST_Transaction, &kTypicalGET_Transaction, &kETagGET_Transaction, &kRangeGET_Transaction }; const MockTransaction* FindMockTransaction(const GURL& url) { // look for overrides: MockTransactionMap::const_iterator it = mock_transactions.find(url.spec()); if (it != mock_transactions.end()) return it->second; // look for builtins: for (size_t i = 0; i < arraysize(kBuiltinMockTransactions); ++i) { if (url == GURL(kBuiltinMockTransactions[i]->url)) return kBuiltinMockTransactions[i]; } return NULL; } void AddMockTransaction(const MockTransaction* trans) { mock_transactions[GURL(trans->url).spec()] = trans; } void RemoveMockTransaction(const MockTransaction* trans) { mock_transactions.erase(GURL(trans->url).spec()); } MockHttpRequest::MockHttpRequest(const MockTransaction& t) { url = GURL(t.url); method = t.method; extra_headers.AddHeadersFromString(t.request_headers); load_flags = t.load_flags; } //----------------------------------------------------------------------------- // static int TestTransactionConsumer::quit_counter_ = 0; TestTransactionConsumer::TestTransactionConsumer( net::RequestPriority priority, net::HttpTransactionFactory* factory) : state_(IDLE), error_(net::OK) { // Disregard the error code. factory->CreateTransaction(priority, &trans_); ++quit_counter_; } TestTransactionConsumer::~TestTransactionConsumer() { } void TestTransactionConsumer::Start(const net::HttpRequestInfo* request, const net::BoundNetLog& net_log) { state_ = STARTING; int result = trans_->Start( request, base::Bind(&TestTransactionConsumer::OnIOComplete, base::Unretained(this)), net_log); if (result != net::ERR_IO_PENDING) DidStart(result); } void TestTransactionConsumer::DidStart(int result) { if (result != net::OK) { DidFinish(result); } else { Read(); } } void TestTransactionConsumer::DidRead(int result) { if (result <= 0) { DidFinish(result); } else { content_.append(read_buf_->data(), result); Read(); } } void TestTransactionConsumer::DidFinish(int result) { state_ = DONE; error_ = result; if (--quit_counter_ == 0) base::MessageLoop::current()->Quit(); } void TestTransactionConsumer::Read() { state_ = READING; read_buf_ = new net::IOBuffer(1024); int result = trans_->Read(read_buf_.get(), 1024, base::Bind(&TestTransactionConsumer::OnIOComplete, base::Unretained(this))); if (result != net::ERR_IO_PENDING) DidRead(result); } void TestTransactionConsumer::OnIOComplete(int result) { switch (state_) { case STARTING: DidStart(result); break; case READING: DidRead(result); break; default: NOTREACHED(); } } MockNetworkTransaction::MockNetworkTransaction( net::RequestPriority priority, MockNetworkLayer* factory) : request_(NULL), data_cursor_(0), priority_(priority), websocket_handshake_stream_create_helper_(NULL), transaction_factory_(factory->AsWeakPtr()), received_bytes_(0), socket_log_id_(net::NetLog::Source::kInvalidId), weak_factory_(this) { } MockNetworkTransaction::~MockNetworkTransaction() {} int MockNetworkTransaction::Start(const net::HttpRequestInfo* request, const net::CompletionCallback& callback, const net::BoundNetLog& net_log) { if (request_) return net::ERR_FAILED; request_ = request; return StartInternal(request, callback, net_log); } int MockNetworkTransaction::RestartIgnoringLastError( const net::CompletionCallback& callback) { return net::ERR_FAILED; } int MockNetworkTransaction::RestartWithCertificate( net::X509Certificate* client_cert, const net::CompletionCallback& callback) { return net::ERR_FAILED; } int MockNetworkTransaction::RestartWithAuth( const net::AuthCredentials& credentials, const net::CompletionCallback& callback) { if (!IsReadyToRestartForAuth()) return net::ERR_FAILED; net::HttpRequestInfo auth_request_info = *request_; auth_request_info.extra_headers.AddHeaderFromString("Authorization: Bar"); // Let the MockTransactionHandler worry about this: the only way for this // test to succeed is by using an explicit handler for the transaction so // that server behavior can be simulated. return StartInternal(&auth_request_info, callback, net::BoundNetLog()); } bool MockNetworkTransaction::IsReadyToRestartForAuth() { if (!request_) return false; if (!request_->extra_headers.HasHeader("X-Require-Mock-Auth")) return false; // Allow the mock server to decide whether authentication is required or not. std::string status_line = response_.headers->GetStatusLine(); return status_line.find(" 401 ") != std::string::npos || status_line.find(" 407 ") != std::string::npos; } int MockNetworkTransaction::Read(net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) { int data_len = static_cast(data_.size()); int num = std::min(buf_len, data_len - data_cursor_); if (test_mode_ & TEST_MODE_SLOW_READ) num = std::min(num, 1); if (num) { memcpy(buf->data(), data_.data() + data_cursor_, num); data_cursor_ += num; } if (test_mode_ & TEST_MODE_SYNC_NET_READ) return num; CallbackLater(callback, num); return net::ERR_IO_PENDING; } void MockNetworkTransaction::StopCaching() { if (transaction_factory_.get()) transaction_factory_->TransactionStopCaching(); } bool MockNetworkTransaction::GetFullRequestHeaders( net::HttpRequestHeaders* headers) const { return false; } int64 MockNetworkTransaction::GetTotalReceivedBytes() const { return received_bytes_; } void MockNetworkTransaction::DoneReading() { if (transaction_factory_.get()) transaction_factory_->TransactionDoneReading(); } const net::HttpResponseInfo* MockNetworkTransaction::GetResponseInfo() const { return &response_; } net::LoadState MockNetworkTransaction::GetLoadState() const { if (data_cursor_) return net::LOAD_STATE_READING_RESPONSE; return net::LOAD_STATE_IDLE; } net::UploadProgress MockNetworkTransaction::GetUploadProgress() const { return net::UploadProgress(); } void MockNetworkTransaction::SetQuicServerInfo( net::QuicServerInfo* quic_server_info) {} bool MockNetworkTransaction::GetLoadTimingInfo( net::LoadTimingInfo* load_timing_info) const { if (socket_log_id_ != net::NetLog::Source::kInvalidId) { // The minimal set of times for a request that gets a response, assuming it // gets a new socket. load_timing_info->socket_reused = false; load_timing_info->socket_log_id = socket_log_id_; load_timing_info->connect_timing.connect_start = base::TimeTicks::Now(); load_timing_info->connect_timing.connect_end = base::TimeTicks::Now(); load_timing_info->send_start = base::TimeTicks::Now(); load_timing_info->send_end = base::TimeTicks::Now(); } else { // If there's no valid socket ID, just use the generic socket reused values. // No tests currently depend on this, just should not match the values set // by a cache hit. load_timing_info->socket_reused = true; load_timing_info->send_start = base::TimeTicks::Now(); load_timing_info->send_end = base::TimeTicks::Now(); } return true; } void MockNetworkTransaction::SetPriority(net::RequestPriority priority) { priority_ = priority; } void MockNetworkTransaction::SetWebSocketHandshakeStreamCreateHelper( net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) { websocket_handshake_stream_create_helper_ = create_helper; } int MockNetworkTransaction::StartInternal( const net::HttpRequestInfo* request, const net::CompletionCallback& callback, const net::BoundNetLog& net_log) { const MockTransaction* t = FindMockTransaction(request->url); if (!t) return net::ERR_FAILED; test_mode_ = t->test_mode; // Return immediately if we're returning an error. if (net::OK != t->return_code) { if (test_mode_ & TEST_MODE_SYNC_NET_START) return t->return_code; CallbackLater(callback, t->return_code); return net::ERR_IO_PENDING; } std::string resp_status = t->status; std::string resp_headers = t->response_headers; std::string resp_data = t->data; received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size(); if (t->handler) (t->handler)(request, &resp_status, &resp_headers, &resp_data); std::string header_data = base::StringPrintf( "%s\n%s\n", resp_status.c_str(), resp_headers.c_str()); std::replace(header_data.begin(), header_data.end(), '\n', '\0'); response_.request_time = base::Time::Now(); if (!t->request_time.is_null()) response_.request_time = t->request_time; response_.was_cached = false; response_.network_accessed = true; response_.response_time = base::Time::Now(); if (!t->response_time.is_null()) response_.response_time = t->response_time; response_.headers = new net::HttpResponseHeaders(header_data); response_.vary_data.Init(*request, *response_.headers.get()); response_.ssl_info.cert_status = t->cert_status; data_ = resp_data; if (net_log.net_log()) socket_log_id_ = net_log.net_log()->NextID(); if (test_mode_ & TEST_MODE_SYNC_NET_START) return net::OK; CallbackLater(callback, net::OK); return net::ERR_IO_PENDING; } void MockNetworkTransaction::SetBeforeNetworkStartCallback( const BeforeNetworkStartCallback& callback) { } void MockNetworkTransaction::SetBeforeProxyHeadersSentCallback( const BeforeProxyHeadersSentCallback& callback) { } int MockNetworkTransaction::ResumeNetworkStart() { // Should not get here. return net::ERR_FAILED; } void MockNetworkTransaction::CallbackLater( const net::CompletionCallback& callback, int result) { base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback, weak_factory_.GetWeakPtr(), callback, result)); } void MockNetworkTransaction::RunCallback( const net::CompletionCallback& callback, int result) { callback.Run(result); } MockNetworkLayer::MockNetworkLayer() : transaction_count_(0), done_reading_called_(false), stop_caching_called_(false), last_create_transaction_priority_(net::DEFAULT_PRIORITY) {} MockNetworkLayer::~MockNetworkLayer() {} void MockNetworkLayer::TransactionDoneReading() { done_reading_called_ = true; } void MockNetworkLayer::TransactionStopCaching() { stop_caching_called_ = true; } int MockNetworkLayer::CreateTransaction( net::RequestPriority priority, scoped_ptr* trans) { transaction_count_++; last_create_transaction_priority_ = priority; scoped_ptr mock_transaction( new MockNetworkTransaction(priority, this)); last_transaction_ = mock_transaction->AsWeakPtr(); *trans = mock_transaction.Pass(); return net::OK; } net::HttpCache* MockNetworkLayer::GetCache() { return NULL; } net::HttpNetworkSession* MockNetworkLayer::GetSession() { return NULL; } //----------------------------------------------------------------------------- // helpers int ReadTransaction(net::HttpTransaction* trans, std::string* result) { int rv; net::TestCompletionCallback callback; std::string content; do { scoped_refptr buf(new net::IOBuffer(256)); rv = trans->Read(buf.get(), 256, callback.callback()); if (rv == net::ERR_IO_PENDING) rv = callback.WaitForResult(); if (rv > 0) content.append(buf->data(), rv); else if (rv < 0) return rv; } while (rv > 0); result->swap(content); return net::OK; }