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