1 // Copyright 2012 The Chromium Authors
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 "net/http/http_network_layer.h"
6
7 #include <memory>
8 #include <utility>
9
10 #include "base/strings/stringprintf.h"
11 #include "net/cert/mock_cert_verifier.h"
12 #include "net/dns/mock_host_resolver.h"
13 #include "net/http/http_network_session.h"
14 #include "net/http/http_server_properties.h"
15 #include "net/http/http_transaction_test_util.h"
16 #include "net/http/transport_security_state.h"
17 #include "net/log/net_log_with_source.h"
18 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
19 #include "net/quic/quic_context.h"
20 #include "net/socket/socket_test_util.h"
21 #include "net/spdy/spdy_session_pool.h"
22 #include "net/ssl/ssl_config_service_defaults.h"
23 #include "net/test/gtest_util.h"
24 #include "net/test/test_with_task_environment.h"
25 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
26 #include "net/url_request/static_http_user_agent_settings.h"
27 #include "testing/gmock/include/gmock/gmock.h"
28 #include "testing/gtest/include/gtest/gtest.h"
29 #include "testing/platform_test.h"
30
31 using net::test::IsError;
32 using net::test::IsOk;
33
34 namespace net {
35
36 namespace {
37
38 class HttpNetworkLayerTest : public PlatformTest, public WithTaskEnvironment {
39 protected:
HttpNetworkLayerTest()40 HttpNetworkLayerTest()
41 : ssl_config_service_(std::make_unique<SSLConfigServiceDefaults>()) {}
42
SetUp()43 void SetUp() override {
44 ConfigureTestDependencies(ConfiguredProxyResolutionService::CreateDirect());
45 }
46
ConfigureTestDependencies(std::unique_ptr<ConfiguredProxyResolutionService> proxy_resolution_service)47 void ConfigureTestDependencies(
48 std::unique_ptr<ConfiguredProxyResolutionService>
49 proxy_resolution_service) {
50 cert_verifier_ = std::make_unique<MockCertVerifier>();
51 transport_security_state_ = std::make_unique<TransportSecurityState>();
52 proxy_resolution_service_ = std::move(proxy_resolution_service);
53 HttpNetworkSessionContext session_context;
54 session_context.client_socket_factory = &mock_socket_factory_;
55 session_context.host_resolver = &host_resolver_;
56 session_context.cert_verifier = cert_verifier_.get();
57 session_context.transport_security_state = transport_security_state_.get();
58 session_context.proxy_resolution_service = proxy_resolution_service_.get();
59 session_context.ssl_config_service = ssl_config_service_.get();
60 session_context.http_server_properties = &http_server_properties_;
61 session_context.quic_context = &quic_context_;
62 session_context.http_user_agent_settings = &http_user_agent_settings_;
63 network_session_ = std::make_unique<HttpNetworkSession>(
64 HttpNetworkSessionParams(), session_context);
65 factory_ = std::make_unique<HttpNetworkLayer>(network_session_.get());
66 }
67
68 MockClientSocketFactory mock_socket_factory_;
69 MockHostResolver host_resolver_{
70 /*default_result=*/
71 MockHostResolverBase::RuleResolver::GetLocalhostResult()};
72 std::unique_ptr<CertVerifier> cert_verifier_;
73 std::unique_ptr<TransportSecurityState> transport_security_state_;
74 std::unique_ptr<ProxyResolutionService> proxy_resolution_service_;
75 StaticHttpUserAgentSettings http_user_agent_settings_ = {"*", "test-ua"};
76 std::unique_ptr<SSLConfigService> ssl_config_service_;
77 QuicContext quic_context_;
78 std::unique_ptr<HttpNetworkSession> network_session_;
79 std::unique_ptr<HttpNetworkLayer> factory_;
80
81 private:
82 HttpServerProperties http_server_properties_;
83 };
84
TEST_F(HttpNetworkLayerTest,CreateAndDestroy)85 TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
86 std::unique_ptr<HttpTransaction> trans;
87 int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
88 EXPECT_THAT(rv, IsOk());
89 EXPECT_TRUE(trans.get() != nullptr);
90 }
91
TEST_F(HttpNetworkLayerTest,Suspend)92 TEST_F(HttpNetworkLayerTest, Suspend) {
93 std::unique_ptr<HttpTransaction> trans;
94 int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
95 EXPECT_THAT(rv, IsOk());
96
97 trans.reset();
98
99 factory_->OnSuspend();
100
101 rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
102 EXPECT_THAT(rv, IsError(ERR_NETWORK_IO_SUSPENDED));
103
104 ASSERT_TRUE(trans == nullptr);
105
106 factory_->OnResume();
107
108 rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
109 EXPECT_THAT(rv, IsOk());
110 }
111
TEST_F(HttpNetworkLayerTest,GET)112 TEST_F(HttpNetworkLayerTest, GET) {
113 MockRead data_reads[] = {
114 MockRead("HTTP/1.0 200 OK\r\n\r\n"),
115 MockRead("hello world"),
116 MockRead(SYNCHRONOUS, OK),
117 };
118 MockWrite data_writes[] = {
119 MockWrite("GET / HTTP/1.1\r\n"
120 "Host: www.google.com\r\n"
121 "Connection: keep-alive\r\n"
122 "User-Agent: Foo/1.0\r\n\r\n"),
123 };
124 StaticSocketDataProvider data(data_reads, data_writes);
125 mock_socket_factory_.AddSocketDataProvider(&data);
126
127 TestCompletionCallback callback;
128
129 HttpRequestInfo request_info;
130 request_info.url = GURL("http://www.google.com/");
131 request_info.method = "GET";
132 request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
133 "Foo/1.0");
134 request_info.load_flags = LOAD_NORMAL;
135 request_info.traffic_annotation =
136 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
137
138 std::unique_ptr<HttpTransaction> trans;
139 int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
140 EXPECT_THAT(rv, IsOk());
141
142 rv = trans->Start(&request_info, callback.callback(), NetLogWithSource());
143 rv = callback.GetResult(rv);
144 ASSERT_THAT(rv, IsOk());
145
146 std::string contents;
147 rv = ReadTransaction(trans.get(), &contents);
148 EXPECT_THAT(rv, IsOk());
149 EXPECT_EQ("hello world", contents);
150 }
151
TEST_F(HttpNetworkLayerTest,NetworkVerified)152 TEST_F(HttpNetworkLayerTest, NetworkVerified) {
153 MockRead data_reads[] = {
154 MockRead("HTTP/1.0 200 OK\r\n\r\n"),
155 MockRead("hello world"),
156 MockRead(SYNCHRONOUS, OK),
157 };
158 MockWrite data_writes[] = {
159 MockWrite("GET / HTTP/1.1\r\n"
160 "Host: www.google.com\r\n"
161 "Connection: keep-alive\r\n"
162 "User-Agent: Foo/1.0\r\n\r\n"),
163 };
164 StaticSocketDataProvider data(data_reads, data_writes);
165 mock_socket_factory_.AddSocketDataProvider(&data);
166
167 TestCompletionCallback callback;
168
169 HttpRequestInfo request_info;
170 request_info.url = GURL("http://www.google.com/");
171 request_info.method = "GET";
172 request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
173 "Foo/1.0");
174 request_info.load_flags = LOAD_NORMAL;
175 request_info.traffic_annotation =
176 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
177
178 std::unique_ptr<HttpTransaction> trans;
179 int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
180 EXPECT_THAT(rv, IsOk());
181
182 rv = trans->Start(&request_info, callback.callback(), NetLogWithSource());
183 ASSERT_THAT(callback.GetResult(rv), IsOk());
184
185 EXPECT_TRUE(trans->GetResponseInfo()->network_accessed);
186 }
187
TEST_F(HttpNetworkLayerTest,NetworkUnVerified)188 TEST_F(HttpNetworkLayerTest, NetworkUnVerified) {
189 MockRead data_reads[] = {
190 MockRead(ASYNC, ERR_CONNECTION_RESET),
191 };
192 MockWrite data_writes[] = {
193 MockWrite("GET / HTTP/1.1\r\n"
194 "Host: www.google.com\r\n"
195 "Connection: keep-alive\r\n"
196 "User-Agent: Foo/1.0\r\n\r\n"),
197 };
198 StaticSocketDataProvider data(data_reads, data_writes);
199 mock_socket_factory_.AddSocketDataProvider(&data);
200
201 TestCompletionCallback callback;
202
203 HttpRequestInfo request_info;
204 request_info.url = GURL("http://www.google.com/");
205 request_info.method = "GET";
206 request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
207 "Foo/1.0");
208 request_info.load_flags = LOAD_NORMAL;
209 request_info.traffic_annotation =
210 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
211
212 std::unique_ptr<HttpTransaction> trans;
213 int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
214 EXPECT_THAT(rv, IsOk());
215
216 rv = trans->Start(&request_info, callback.callback(), NetLogWithSource());
217 ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_RESET));
218
219 // network_accessed is true; the HTTP stack did try to make a connection.
220 EXPECT_TRUE(trans->GetResponseInfo()->network_accessed);
221 }
222
223 } // namespace
224
225 } // namespace net
226