Index: net/http/http_proxy_client_socket_pool_unittest.cc |
=================================================================== |
--- net/http/http_proxy_client_socket_pool_unittest.cc (revision 62460) |
+++ net/http/http_proxy_client_socket_pool_unittest.cc (working copy) |
@@ -19,7 +19,9 @@ |
#include "net/socket/client_socket_handle.h" |
#include "net/socket/client_socket_pool_histograms.h" |
#include "net/socket/socket_test_util.h" |
+#include "net/spdy/spdy_protocol.h" |
#include "net/spdy/spdy_session_pool.h" |
+#include "net/spdy/spdy_test_util.h" |
#include "testing/gtest/include/gtest/gtest.h" |
namespace net { |
@@ -28,34 +30,48 @@ |
const int kMaxSockets = 32; |
const int kMaxSocketsPerGroup = 6; |
+const char * const kAuthHeaders[] = { |
+ "proxy-authorization", "Basic Zm9vOmJhcg==" |
+}; |
+const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2; |
enum HttpProxyType { |
HTTP, |
- HTTPS |
+ HTTPS, |
+ SPDY |
}; |
typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam; |
+} // namespace |
+ |
class HttpProxyClientSocketPoolTest : public TestWithHttpParam { |
protected: |
HttpProxyClientSocketPoolTest() |
: ssl_config_(), |
ignored_tcp_socket_params_(new TCPSocketParams( |
- HostPortPair("proxy", 80), MEDIUM, GURL(), false)), |
+ HostPortPair("proxy", 80), LOWEST, GURL(), false)), |
ignored_ssl_socket_params_(new SSLSocketParams( |
ignored_tcp_socket_params_, NULL, NULL, ProxyServer::SCHEME_DIRECT, |
- "host", ssl_config_, 0, false, false)), |
+ "www.google.com", ssl_config_, 0, false, false)), |
tcp_histograms_("MockTCP"), |
tcp_socket_pool_( |
kMaxSockets, kMaxSocketsPerGroup, |
&tcp_histograms_, |
- &tcp_client_socket_factory_), |
+ &socket_factory_), |
ssl_histograms_("MockSSL"), |
+ ssl_config_service_(new SSLConfigServiceDefaults), |
+ host_resolver_(new MockHostResolver), |
ssl_socket_pool_(kMaxSockets, kMaxSocketsPerGroup, |
&ssl_histograms_, |
- &tcp_client_socket_factory_, |
- &tcp_socket_pool_), |
- host_resolver_(new MockHostResolver), |
+ host_resolver_.get(), |
+ NULL /* dnsrr_resolver */, |
+ &socket_factory_, |
+ &tcp_socket_pool_, |
+ NULL, |
+ NULL, |
+ ssl_config_service_.get(), |
+ BoundNetLog().net_log()), |
http_auth_handler_factory_( |
HttpAuthHandlerFactory::CreateDefault(host_resolver_.get())), |
session_(new HttpNetworkSession(host_resolver_.get(), |
@@ -68,6 +84,8 @@ |
NULL, |
NULL)), |
http_proxy_histograms_("HttpProxyUnitTest"), |
+ ssl_data_(NULL), |
+ data_(NULL), |
pool_(kMaxSockets, kMaxSocketsPerGroup, |
&http_proxy_histograms_, |
NULL, |
@@ -87,7 +105,7 @@ |
} |
scoped_refptr<TCPSocketParams> GetTcpParams() { |
- if (GetParam() == HTTPS) |
+ if (GetParam() != HTTP) |
return scoped_refptr<TCPSocketParams>(); |
return ignored_tcp_socket_params_; |
} |
@@ -105,11 +123,13 @@ |
new HttpProxySocketParams( |
GetTcpParams(), |
GetSslParams(), |
- GURL("http://host/"), |
+ GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), |
"", |
- HostPortPair("host", 80), |
+ HostPortPair("www.google.com", tunnel ? 443 : 80), |
session_->auth_cache(), |
session_->http_auth_handler_factory(), |
+ session_->spdy_session_pool(), |
+ session_->mutable_spdy_settings(), |
tunnel)); |
} |
@@ -121,227 +141,363 @@ |
return GetParams(false); |
} |
+ DeterministicMockClientSocketFactory& socket_factory() { |
+ return socket_factory_; |
+ } |
+ |
+ void Initialize(bool async, MockRead* reads, size_t reads_count, |
+ MockWrite* writes, size_t writes_count, |
+ MockRead* spdy_reads, size_t spdy_reads_count, |
+ MockWrite* spdy_writes, size_t spdy_writes_count) { |
+ if (GetParam() == SPDY) |
+ data_ = new DeterministicSocketData(spdy_reads, spdy_reads_count, |
+ spdy_writes, spdy_writes_count); |
+ else |
+ data_ = new DeterministicSocketData(reads, reads_count, writes, |
+ writes_count); |
+ |
+ data_->set_connect_data(MockConnect(async, 0)); |
+ data_->StopAfter(2); // Request / Response |
+ |
+ socket_factory_.AddSocketDataProvider(data_.get()); |
+ |
+ if (GetParam() != HTTP) { |
+ ssl_data_.reset(new SSLSocketDataProvider(async, OK)); |
+ if (GetParam() == SPDY) { |
+ InitializeSpdySsl(); |
+ } |
+ socket_factory_.AddSSLSocketDataProvider(ssl_data_.get()); |
+ } |
+ } |
+ |
+ void InitializeSpdySsl() { |
+ spdy::SpdyFramer::set_enable_compression_default(false); |
+ ssl_data_->next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
+ ssl_data_->next_proto = "spdy/2"; |
+ ssl_data_->was_npn_negotiated = true; |
+ } |
+ |
+ private: |
SSLConfig ssl_config_; |
scoped_refptr<TCPSocketParams> ignored_tcp_socket_params_; |
scoped_refptr<SSLSocketParams> ignored_ssl_socket_params_; |
ClientSocketPoolHistograms tcp_histograms_; |
- MockClientSocketFactory tcp_client_socket_factory_; |
+ DeterministicMockClientSocketFactory socket_factory_; |
MockTCPClientSocketPool tcp_socket_pool_; |
ClientSocketPoolHistograms ssl_histograms_; |
- MockSSLClientSocketPool ssl_socket_pool_; |
+ scoped_refptr<SSLConfigService> ssl_config_service_; |
+ scoped_ptr<HostResolver> host_resolver_; |
+ SSLClientSocketPool ssl_socket_pool_; |
- MockClientSocketFactory socket_factory_; |
- scoped_ptr<HostResolver> host_resolver_; |
scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_; |
scoped_refptr<HttpNetworkSession> session_; |
ClientSocketPoolHistograms http_proxy_histograms_; |
+ |
+ protected: |
+ scoped_ptr<SSLSocketDataProvider> ssl_data_; |
+ scoped_refptr<DeterministicSocketData> data_; |
HttpProxyClientSocketPool pool_; |
+ ClientSocketHandle handle_; |
+ TestCompletionCallback callback_; |
}; |
//----------------------------------------------------------------------------- |
-// All tests are run with three different connection types: SPDY after NPN |
-// negotiation, SPDY without SSL, and SPDY with SSL. |
+// All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY) |
+// and SPDY. |
INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolTests, |
HttpProxyClientSocketPoolTest, |
- ::testing::Values(HTTP, HTTPS)); |
+ ::testing::Values(HTTP, HTTPS, SPDY)); |
TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) { |
- StaticSocketDataProvider data; |
- data.set_connect_data(MockConnect(false, 0)); |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ Initialize(false, NULL, 0, NULL, 0, NULL, 0, NULL, 0); |
- ClientSocketHandle handle; |
- int rv = handle.Init("a", GetNoTunnelParams(), LOW, NULL, &pool_, |
+ int rv = handle_.Init("a", GetNoTunnelParams(), LOW, NULL, &pool_, |
BoundNetLog()); |
EXPECT_EQ(OK, rv); |
- EXPECT_TRUE(handle.is_initialized()); |
- EXPECT_TRUE(handle.socket()); |
+ EXPECT_TRUE(handle_.is_initialized()); |
+ ASSERT_TRUE(handle_.socket()); |
HttpProxyClientSocket* tunnel_socket = |
- static_cast<HttpProxyClientSocket*>(handle.socket()); |
+ static_cast<HttpProxyClientSocket*>(handle_.socket()); |
EXPECT_TRUE(tunnel_socket->IsConnected()); |
} |
TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) { |
MockWrite writes[] = { |
- MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
- "Host: host\r\n" |
- "Proxy-Connection: keep-alive\r\n\r\n"), |
+ MockWrite(true, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n" |
+ "Host: www.google.com\r\n" |
+ "Proxy-Connection: keep-alive\r\n\r\n"), |
}; |
MockRead reads[] = { |
- // No credentials. |
- MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
- MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
- MockRead("Content-Length: 10\r\n\r\n"), |
- MockRead("0123456789"), |
+ // No credentials. |
+ MockRead(true, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"), |
+ MockRead(true, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
+ MockRead(true, 3, "Content-Length: 10\r\n\r\n"), |
+ MockRead(true, 4, "0123456789"), |
}; |
- StaticSocketDataProvider data(reads, arraysize(reads), writes, |
- arraysize(writes)); |
+ scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(NULL, 0, 1)); |
+ scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL)); |
+ MockWrite spdy_writes[] = { |
+ CreateMockWrite(*req, 0, true), |
+ CreateMockWrite(*rst, 2, true), |
+ }; |
+ scoped_ptr<spdy::SpdyFrame> resp( |
+ ConstructSpdySynReplyError("407 Proxy Authentication Required", 1)); |
+ MockRead spdy_reads[] = { |
+ CreateMockWrite(*resp, 1, true), |
+ MockRead(true, 0, 3) |
+ }; |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ Initialize(false, reads, arraysize(reads), writes, arraysize(writes), |
+ spdy_reads, arraysize(spdy_reads), spdy_writes, |
+ arraysize(spdy_writes)); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ data_->StopAfter(4); |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
- EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
- EXPECT_TRUE(handle.is_initialized()); |
- EXPECT_TRUE(handle.socket()); |
- HttpProxyClientSocket* tunnel_socket = |
- static_cast<HttpProxyClientSocket*>(handle.socket()); |
- EXPECT_FALSE(tunnel_socket->IsConnected()); |
+ data_->RunFor(4); |
+ rv = callback_.WaitForResult(); |
+ if (GetParam() != SPDY) { |
+ EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv); |
+ EXPECT_TRUE(handle_.is_initialized()); |
+ ASSERT_TRUE(handle_.socket()); |
+ HttpProxyClientSocket* tunnel_socket = |
+ static_cast<HttpProxyClientSocket*>(handle_.socket()); |
+ EXPECT_FALSE(tunnel_socket->IsConnected()); |
+ EXPECT_FALSE(tunnel_socket->using_spdy()); |
+ } else { |
+ // Proxy auth is not really implemented for SPDY yet |
+ EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
+ } |
} |
TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) { |
+ // It's pretty much impossible to make the SPDY case becave synchronously |
+ // so we skip this test for SPDY |
+ if (GetParam() == SPDY) |
+ return; |
MockWrite writes[] = { |
- MockWrite(false, |
- "CONNECT host:80 HTTP/1.1\r\n" |
- "Host: host\r\n" |
- "Proxy-Connection: keep-alive\r\n" |
- "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
+ MockWrite(false, 0, |
+ "CONNECT www.google.com:443 HTTP/1.1\r\n" |
+ "Host: www.google.com\r\n" |
+ "Proxy-Connection: keep-alive\r\n" |
+ "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
}; |
MockRead reads[] = { |
- MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
+ MockRead(false, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
}; |
- StaticSocketDataProvider data(reads, arraysize(reads), writes, |
- arraysize(writes)); |
- data.set_connect_data(MockConnect(false, 0)); |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ Initialize(false, reads, arraysize(reads), writes, arraysize(writes), NULL, 0, |
+ NULL, 0); |
AddAuthToCache(); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(OK, rv); |
- EXPECT_TRUE(handle.is_initialized()); |
- EXPECT_TRUE(handle.socket()); |
+ EXPECT_TRUE(handle_.is_initialized()); |
+ ASSERT_TRUE(handle_.socket()); |
HttpProxyClientSocket* tunnel_socket = |
- static_cast<HttpProxyClientSocket*>(handle.socket()); |
+ static_cast<HttpProxyClientSocket*>(handle_.socket()); |
EXPECT_TRUE(tunnel_socket->IsConnected()); |
} |
TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { |
MockWrite writes[] = { |
- MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
- "Host: host\r\n" |
- "Proxy-Connection: keep-alive\r\n" |
- "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
+ MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
+ "Host: www.google.com\r\n" |
+ "Proxy-Connection: keep-alive\r\n" |
+ "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
}; |
MockRead reads[] = { |
- MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
+ MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
}; |
- StaticSocketDataProvider data(reads, arraysize(reads), writes, |
- arraysize(writes)); |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(kAuthHeaders, |
+ kAuthHeadersSize, 1)); |
+ MockWrite spdy_writes[] = { |
+ CreateMockWrite(*req, 0, true) |
+ }; |
+ scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1)); |
+ MockRead spdy_reads[] = { |
+ CreateMockRead(*resp, 1, true), |
+ MockRead(true, 0, 2) |
+ }; |
+ |
+ Initialize(false, reads, arraysize(reads), writes, arraysize(writes), |
+ spdy_reads, arraysize(spdy_reads), spdy_writes, |
+ arraysize(spdy_writes)); |
AddAuthToCache(); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
- EXPECT_EQ(OK, callback.WaitForResult()); |
- EXPECT_TRUE(handle.is_initialized()); |
- EXPECT_TRUE(handle.socket()); |
+ data_->RunFor(2); |
+ EXPECT_EQ(OK, callback_.WaitForResult()); |
+ EXPECT_TRUE(handle_.is_initialized()); |
+ ASSERT_TRUE(handle_.socket()); |
HttpProxyClientSocket* tunnel_socket = |
- static_cast<HttpProxyClientSocket*>(handle.socket()); |
+ static_cast<HttpProxyClientSocket*>(handle_.socket()); |
EXPECT_TRUE(tunnel_socket->IsConnected()); |
} |
TEST_P(HttpProxyClientSocketPoolTest, TCPError) { |
- StaticSocketDataProvider data; |
- data.set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); |
+ if (GetParam() == SPDY) return; |
+ data_ = new DeterministicSocketData(NULL, 0, NULL, 0); |
+ data_->set_connect_data(MockConnect(true, ERR_CONNECTION_CLOSED)); |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ socket_factory().AddSocketDataProvider(data_.get()); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
- if (GetParam() == HTTP) |
- EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult()); |
- else |
- EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
+ EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult()); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
} |
+TEST_P(HttpProxyClientSocketPoolTest, SSLError) { |
+ if (GetParam() == HTTP) return; |
+ data_ = new DeterministicSocketData(NULL, 0, NULL, 0); |
+ data_->set_connect_data(MockConnect(true, OK)); |
+ socket_factory().AddSocketDataProvider(data_.get()); |
+ |
+ ssl_data_.reset(new SSLSocketDataProvider(true, |
+ ERR_CERT_AUTHORITY_INVALID)); |
+ if (GetParam() == SPDY) { |
+ InitializeSpdySsl(); |
+ } |
+ socket_factory().AddSSLSocketDataProvider(ssl_data_.get()); |
+ |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
+ BoundNetLog()); |
+ EXPECT_EQ(ERR_IO_PENDING, rv); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
+ |
+ EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult()); |
+ |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
+} |
+ |
+TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) { |
+ if (GetParam() == HTTP) return; |
+ data_ = new DeterministicSocketData(NULL, 0, NULL, 0); |
+ data_->set_connect_data(MockConnect(true, OK)); |
+ socket_factory().AddSocketDataProvider(data_.get()); |
+ |
+ ssl_data_.reset(new SSLSocketDataProvider(true, |
+ ERR_SSL_CLIENT_AUTH_CERT_NEEDED)); |
+ if (GetParam() == SPDY) { |
+ InitializeSpdySsl(); |
+ } |
+ socket_factory().AddSSLSocketDataProvider(ssl_data_.get()); |
+ |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
+ BoundNetLog()); |
+ EXPECT_EQ(ERR_IO_PENDING, rv); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
+ |
+ EXPECT_EQ(ERR_PROXY_AUTH_UNSUPPORTED, callback_.WaitForResult()); |
+ |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
+} |
+ |
TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { |
MockWrite writes[] = { |
- MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
- "Host: host\r\n" |
- "Proxy-Connection: keep-alive\r\n" |
- "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
+ MockWrite(true, 0, |
+ "CONNECT www.google.com:443 HTTP/1.1\r\n" |
+ "Host: www.google.com\r\n" |
+ "Proxy-Connection: keep-alive\r\n" |
+ "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
}; |
MockRead reads[] = { |
- MockRead("HTTP/1.1 200 Conn"), |
- MockRead(true, ERR_CONNECTION_CLOSED), |
+ MockRead(true, 1, "HTTP/1.1 200 Conn"), |
+ MockRead(true, ERR_CONNECTION_CLOSED, 2), |
}; |
- StaticSocketDataProvider data(reads, arraysize(reads), writes, |
- arraysize(writes)); |
+ scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(kAuthHeaders, |
+ kAuthHeadersSize, 1)); |
+ MockWrite spdy_writes[] = { |
+ CreateMockWrite(*req, 0, true) |
+ }; |
+ MockRead spdy_reads[] = { |
+ MockRead(true, ERR_CONNECTION_CLOSED, 1), |
+ }; |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ Initialize(false, reads, arraysize(reads), writes, arraysize(writes), |
+ spdy_reads, arraysize(spdy_reads), spdy_writes, |
+ arraysize(spdy_writes)); |
AddAuthToCache(); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
- EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult()); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ data_->RunFor(3); |
+ EXPECT_EQ(ERR_CONNECTION_CLOSED, callback_.WaitForResult()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
} |
TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) { |
MockWrite writes[] = { |
- MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
- "Host: host\r\n" |
- "Proxy-Connection: keep-alive\r\n" |
- "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
+ MockWrite(true, 0, |
+ "CONNECT www.google.com:443 HTTP/1.1\r\n" |
+ "Host: www.google.com\r\n" |
+ "Proxy-Connection: keep-alive\r\n" |
+ "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
}; |
MockRead reads[] = { |
- MockRead("HTTP/1.1 304 Not Modified\r\n\r\n"), |
+ MockRead(true, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"), |
}; |
- StaticSocketDataProvider data(reads, arraysize(reads), writes, |
- arraysize(writes)); |
+ scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(kAuthHeaders, |
+ kAuthHeadersSize, 1)); |
+ scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL)); |
+ MockWrite spdy_writes[] = { |
+ CreateMockWrite(*req, 0, true), |
+ CreateMockWrite(*rst, 2, true), |
+ }; |
+ scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdySynReplyError(1)); |
+ MockRead spdy_reads[] = { |
+ CreateMockRead(*resp, 1, true), |
+ MockRead(true, 0, 3), |
+ }; |
- tcp_client_socket_factory_.AddSocketDataProvider(&data); |
+ Initialize(false, reads, arraysize(reads), writes, arraysize(writes), |
+ spdy_reads, arraysize(spdy_reads), spdy_writes, |
+ arraysize(spdy_writes)); |
AddAuthToCache(); |
- ClientSocketHandle handle; |
- TestCompletionCallback callback; |
- int rv = handle.Init("a", GetTunnelParams(), LOW, &callback, &pool_, |
+ int rv = handle_.Init("a", GetTunnelParams(), LOW, &callback_, &pool_, |
BoundNetLog()); |
EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
- EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback.WaitForResult()); |
- EXPECT_FALSE(handle.is_initialized()); |
- EXPECT_FALSE(handle.socket()); |
+ data_->RunFor(2); |
+ |
+ EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback_.WaitForResult()); |
+ EXPECT_FALSE(handle_.is_initialized()); |
+ EXPECT_FALSE(handle_.socket()); |
} |
// It would be nice to also test the timeouts in HttpProxyClientSocketPool. |
-} // namespace |
- |
} // namespace net |