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 uint8_t kIPV4Address[] = {127, 0, 0, 1}; |
| 21 const uint16_t kPort = 6667; |
| 22 |
| 23 } // namespace |
| 24 |
| 25 class SSLClientTransportTest : public testing::Test { |
| 26 public: |
| 27 SSLClientTransportTest() {} |
| 28 |
| 29 ~SSLClientTransportTest() override {} |
| 30 |
| 31 void TearDown() override { base::RunLoop().RunUntilIdle(); } |
| 32 |
| 33 MOCK_METHOD1(ConnectComplete, void(int)); |
| 34 |
| 35 protected: |
| 36 // Methods for provisioning simulated connection outcomes. |
| 37 void SetupTCPSyncSocketConnect(net::IPEndPoint endpoint, int result) { |
| 38 tcp_connect_.set_connect_data( |
| 39 net::MockConnect(net::SYNCHRONOUS, result, endpoint)); |
| 40 socket_factory_.AddSocketDataProvider(&tcp_connect_); |
| 41 } |
| 42 |
| 43 void SetupTCPAsyncSocketConnect(net::IPEndPoint endpoint, int result) { |
| 44 tcp_connect_.set_connect_data( |
| 45 net::MockConnect(net::ASYNC, result, endpoint)); |
| 46 socket_factory_.AddSocketDataProvider(&tcp_connect_); |
| 47 } |
| 48 |
| 49 void SetupSSLSyncSocketConnect(int result) { |
| 50 ssl_connect_.reset( |
| 51 new net::SSLSocketDataProvider(net::SYNCHRONOUS, result)); |
| 52 socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get()); |
| 53 } |
| 54 |
| 55 void SetupSSLAsyncSocketConnect(int result) { |
| 56 ssl_connect_.reset(new net::SSLSocketDataProvider(net::ASYNC, result)); |
| 57 socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get()); |
| 58 } |
| 59 |
| 60 void ConfigureTransport(const net::IPEndPoint& ip_endpoint) { |
| 61 // The mock does not interact with the cert directly, so just leave it null. |
| 62 scoped_refptr<net::X509Certificate> cert; |
| 63 transport_.reset(new SSLClientTransport(ip_endpoint, cert, &net_log_)); |
| 64 transport_->SetClientSocketFactoryForTest(&socket_factory_); |
| 65 } |
| 66 |
| 67 base::MessageLoop message_loop; |
| 68 net::NetLog net_log_; |
| 69 net::StaticSocketDataProvider tcp_connect_; |
| 70 scoped_ptr<net::SSLSocketDataProvider> ssl_connect_; |
| 71 net::MockClientSocketFactory socket_factory_; |
| 72 scoped_ptr<SSLClientTransport> transport_; |
| 73 }; |
| 74 |
| 75 TEST_F(SSLClientTransportTest, ConnectSyncOK) { |
| 76 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 77 ConfigureTransport(endpoint); |
| 78 for (int i = 0; i < 5; ++i) { |
| 79 EXPECT_CALL(*this, ConnectComplete(net::OK)); |
| 80 SetupTCPSyncSocketConnect(endpoint, net::OK); |
| 81 SetupSSLSyncSocketConnect(net::OK); |
| 82 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 83 base::Unretained(this))); |
| 84 EXPECT_NE(nullptr, transport_->TakeConnection().get()); |
| 85 base::RunLoop().RunUntilIdle(); |
| 86 } |
| 87 } |
| 88 |
| 89 TEST_F(SSLClientTransportTest, ConnectAsyncOK) { |
| 90 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 91 ConfigureTransport(endpoint); |
| 92 for (int i = 0; i < 5; ++i) { |
| 93 EXPECT_CALL(*this, ConnectComplete(net::OK)); |
| 94 SetupTCPAsyncSocketConnect(endpoint, net::OK); |
| 95 SetupSSLAsyncSocketConnect(net::OK); |
| 96 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 97 base::Unretained(this))); |
| 98 base::RunLoop().RunUntilIdle(); |
| 99 EXPECT_NE(nullptr, transport_->TakeConnection().get()); |
| 100 } |
| 101 } |
| 102 |
| 103 TEST_F(SSLClientTransportTest, ConnectSyncTCPError) { |
| 104 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 105 ConfigureTransport(endpoint); |
| 106 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); |
| 107 SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED); |
| 108 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 109 base::Unretained(this))); |
| 110 } |
| 111 |
| 112 TEST_F(SSLClientTransportTest, ConnectAsyncTCPError) { |
| 113 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 114 ConfigureTransport(endpoint); |
| 115 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); |
| 116 SetupTCPAsyncSocketConnect(endpoint, net::ERR_FAILED); |
| 117 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 118 base::Unretained(this))); |
| 119 } |
| 120 |
| 121 TEST_F(SSLClientTransportTest, ConnectSyncSSLError) { |
| 122 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 123 ConfigureTransport(endpoint); |
| 124 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); |
| 125 SetupTCPSyncSocketConnect(endpoint, net::OK); |
| 126 SetupSSLSyncSocketConnect(net::ERR_FAILED); |
| 127 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 128 base::Unretained(this))); |
| 129 } |
| 130 |
| 131 TEST_F(SSLClientTransportTest, ConnectAsyncSSLError) { |
| 132 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 133 ConfigureTransport(endpoint); |
| 134 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); |
| 135 SetupTCPAsyncSocketConnect(endpoint, net::OK); |
| 136 SetupSSLAsyncSocketConnect(net::ERR_FAILED); |
| 137 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 138 base::Unretained(this))); |
| 139 } |
| 140 |
| 141 TEST_F(SSLClientTransportTest, ConnectAfterError) { |
| 142 net::IPEndPoint endpoint(kIPV4Address, kPort); |
| 143 ConfigureTransport(endpoint); |
| 144 |
| 145 // TCP connection fails. |
| 146 EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED)); |
| 147 SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED); |
| 148 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 149 base::Unretained(this))); |
| 150 base::RunLoop().RunUntilIdle(); |
| 151 |
| 152 // Subsequent TCP+SSL connections succeed. |
| 153 EXPECT_CALL(*this, ConnectComplete(net::OK)); |
| 154 SetupTCPSyncSocketConnect(endpoint, net::OK); |
| 155 SetupSSLSyncSocketConnect(net::OK); |
| 156 transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete, |
| 157 base::Unretained(this))); |
| 158 EXPECT_NE(nullptr, transport_->TakeConnection().get()); |
| 159 base::RunLoop().RunUntilIdle(); |
| 160 } |
| 161 |
| 162 } // namespace blimp |
OLD | NEW |