OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
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 "base/bind.h" | |
6 #include "base/message_loop/message_loop.h" | |
7 #include "base/run_loop.h" | |
8 #include "blimp/net/blimp_connection.h" | |
9 #include "blimp/net/ssl_client_transport.h" | |
10 #include "net/base/address_list.h" | |
11 #include "net/base/ip_address.h" | |
12 #include "net/base/net_errors.h" | |
13 #include "net/socket/socket_test_util.h" | |
14 #include "testing/gmock/include/gmock/gmock.h" | |
15 #include "testing/gtest/include/gtest/gtest.h" | |
16 | |
17 namespace blimp { | |
18 namespace { | |
19 | |
20 const char kIPV4Address[] = "127.0.0.1"; | |
21 const uint16_t kPort = 6667; | |
22 | |
23 net::IPEndPoint CreateIPEndpointFromLiteral(const std::string& address, | |
24 uint16_t port) { | |
25 net::IPAddress parsed_address; | |
26 CHECK(parsed_address.AssignFromIPLiteral(address)); | |
Ryan Sleevi
2016/02/23 00:49:45
You should NEVER CHECK in unit tests.
Kevin M
2016/02/23 01:58:26
Done.
| |
27 return net::IPEndPoint(parsed_address, port); | |
28 } | |
Ryan Sleevi
2016/02/23 00:49:45
Change kIPV4Address to
const uint8_t kIPV4Address
Kevin M
2016/02/23 01:58:26
Done. Neat.
| |
29 | |
30 } // namespace | |
31 | |
32 class SSLClientTransportTest : public testing::Test { | |
33 public: | |
34 SSLClientTransportTest() {} | |
35 | |
36 ~SSLClientTransportTest() override {} | |
37 | |
38 void TearDown() override { base::RunLoop().RunUntilIdle(); } | |
39 | |
40 MOCK_METHOD1(ConnectComplete, void(int)); | |
41 | |
42 protected: | |
43 // Methods for provisioning simulated connection outcomes. | |
44 void SetupTCPSyncSocketConnect(net::IPEndPoint endpoint, int result) { | |
45 tcp_connect_.set_connect_data( | |
46 net::MockConnect(net::SYNCHRONOUS, result, endpoint)); | |
47 socket_factory_.AddSocketDataProvider(&tcp_connect_); | |
48 } | |
49 | |
50 void SetupTCPAsyncSocketConnect(net::IPEndPoint endpoint, int result) { | |
51 tcp_connect_.set_connect_data( | |
52 net::MockConnect(net::ASYNC, result, endpoint)); | |
53 socket_factory_.AddSocketDataProvider(&tcp_connect_); | |
54 } | |
55 | |
56 void SetupSSLSyncSocketConnect(int result) { | |
57 ssl_connect_.reset( | |
58 new net::SSLSocketDataProvider(net::SYNCHRONOUS, result)); | |
59 socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get()); | |
60 } | |
61 | |
62 void SetupSSLAsyncSocketConnect(int result) { | |
63 ssl_connect_.reset(new net::SSLSocketDataProvider(net::ASYNC, result)); | |
64 socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get()); | |
65 } | |
66 | |
67 void ConfigureTransport(const net::IPEndPoint& ip_endpoint) { | |
68 // The mock does not interact with the cert directly, so just leave it null. | |
69 scoped_refptr<net::X509Certificate> cert; | |
70 transport_.reset(new SSLClientTransport(ip_endpoint, cert, &net_log_)); | |
71 transport_->SetClientSocketFactoryForTest(&socket_factory_); | |
72 } | |
73 | |
74 base::MessageLoop message_loop; | |
75 net::NetLog net_log_; | |
76 net::StaticSocketDataProvider tcp_connect_; | |
77 scoped_ptr<net::SSLSocketDataProvider> ssl_connect_; | |
78 net::MockClientSocketFactory socket_factory_; | |
79 scoped_ptr<SSLClientTransport> transport_; | |
80 }; | |
81 | |
82 TEST_F(SSLClientTransportTest, ConnectSyncOK) { | |
83 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
84 ConfigureTransport(endpoint); | |
85 for (int i = 0; i < 5; ++i) { | |
86 EXPECT_CALL(*this, ConnectComplete(net::OK)); | |
87 SetupTCPSyncSocketConnect(endpoint, net::OK); | |
88 SetupSSLSyncSocketConnect(net::OK); | |
89 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
90 base::Unretained(this))); | |
91 EXPECT_NE(nullptr, transport_->TakeConnection().get()); | |
92 base::RunLoop().RunUntilIdle(); | |
93 } | |
94 } | |
95 | |
96 TEST_F(SSLClientTransportTest, ConnectAsyncOK) { | |
97 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
98 ConfigureTransport(endpoint); | |
99 for (int i = 0; i < 5; ++i) { | |
100 EXPECT_CALL(*this, ConnectComplete(net::OK)); | |
101 SetupTCPAsyncSocketConnect(endpoint, net::OK); | |
102 SetupSSLAsyncSocketConnect(net::OK); | |
103 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
104 base::Unretained(this))); | |
105 base::RunLoop().RunUntilIdle(); | |
106 EXPECT_NE(nullptr, transport_->TakeConnection().get()); | |
107 } | |
108 } | |
109 | |
110 TEST_F(SSLClientTransportTest, ConnectSyncTCPError) { | |
111 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
112 ConfigureTransport(endpoint); | |
113 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); | |
114 SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED); | |
115 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
116 base::Unretained(this))); | |
117 } | |
118 | |
119 TEST_F(SSLClientTransportTest, ConnectAsyncTCPError) { | |
120 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
121 ConfigureTransport(endpoint); | |
122 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); | |
123 SetupTCPAsyncSocketConnect(endpoint, net::ERR_FAILED); | |
124 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
125 base::Unretained(this))); | |
126 } | |
127 | |
128 TEST_F(SSLClientTransportTest, ConnectSyncSSLError) { | |
129 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
130 ConfigureTransport(endpoint); | |
131 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); | |
132 SetupTCPSyncSocketConnect(endpoint, net::OK); | |
133 SetupSSLSyncSocketConnect(net::ERR_FAILED); | |
134 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
135 base::Unretained(this))); | |
136 } | |
137 | |
138 TEST_F(SSLClientTransportTest, ConnectAsyncSSLError) { | |
139 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
140 ConfigureTransport(endpoint); | |
141 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); | |
142 SetupTCPAsyncSocketConnect(endpoint, net::OK); | |
143 SetupSSLAsyncSocketConnect(net::ERR_FAILED); | |
144 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
145 base::Unretained(this))); | |
146 } | |
147 | |
148 TEST_F(SSLClientTransportTest, ConnectAfterError) { | |
149 net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort); | |
150 ConfigureTransport(endpoint); | |
151 | |
152 // TCP connection fails. | |
153 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); | |
154 SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED); | |
155 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
156 base::Unretained(this))); | |
157 base::RunLoop().RunUntilIdle(); | |
158 | |
159 // Subsequent TCP+SSL connections succeed. | |
160 EXPECT_CALL(*this, ConnectComplete(net::OK)); | |
161 SetupTCPSyncSocketConnect(endpoint, net::OK); | |
162 SetupSSLSyncSocketConnect(net::OK); | |
163 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, | |
164 base::Unretained(this))); | |
165 EXPECT_NE(nullptr, transport_->TakeConnection().get()); | |
166 base::RunLoop().RunUntilIdle(); | |
167 } | |
168 | |
169 } // namespace blimp | |
OLD | NEW |