Blimp: add support for SSL connections.

blimp/net/ssl_client_transport_unittest.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "blimp/net/blimp_connection.h"
+#include "blimp/net/ssl_client_transport.h"
+#include "net/base/address_list.h"
+#include "net/base/ip_address.h"
+#include "net/base/net_errors.h"
+#include "net/socket/socket_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blimp {
+namespace {
+
+const char kIPV4Address[] = "127.0.0.1";
+const uint16_t kPort = 6667;
+
+net::IPEndPoint CreateIPEndpointFromLiteral(const std::string& address,
+                                            uint16_t port) {
+  net::IPAddress parsed_address;
+  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.

+  return net::IPEndPoint(parsed_address, port);
+}

[Ryan Sleevi, 2016/02/23 00:49:45]

Change kIPV4Address to

const uint8_t kIPV4Address[] = { 127, 0, 0, 1 };

and you can just do

"net::IPEndPoint(kIPV4Address, port)" (IPAddress is implicitly constructible
from const uint8_t of fixed sizes)

[Kevin M, 2016/02/23 01:58:26]

Done. Neat.

+
+}  // namespace
+
+class SSLClientTransportTest : public testing::Test {
+ public:
+  SSLClientTransportTest() {}
+
+  ~SSLClientTransportTest() override {}
+
+  void TearDown() override { base::RunLoop().RunUntilIdle(); }
+
+  MOCK_METHOD1(ConnectComplete, void(int));
+
+ protected:
+  // Methods for provisioning simulated connection outcomes.
+  void SetupTCPSyncSocketConnect(net::IPEndPoint endpoint, int result) {
+    tcp_connect_.set_connect_data(
+        net::MockConnect(net::SYNCHRONOUS, result, endpoint));
+    socket_factory_.AddSocketDataProvider(&tcp_connect_);
+  }
+
+  void SetupTCPAsyncSocketConnect(net::IPEndPoint endpoint, int result) {
+    tcp_connect_.set_connect_data(
+        net::MockConnect(net::ASYNC, result, endpoint));
+    socket_factory_.AddSocketDataProvider(&tcp_connect_);
+  }
+
+  void SetupSSLSyncSocketConnect(int result) {
+    ssl_connect_.reset(
+        new net::SSLSocketDataProvider(net::SYNCHRONOUS, result));
+    socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get());
+  }
+
+  void SetupSSLAsyncSocketConnect(int result) {
+    ssl_connect_.reset(new net::SSLSocketDataProvider(net::ASYNC, result));
+    socket_factory_.AddSSLSocketDataProvider(ssl_connect_.get());
+  }
+
+  void ConfigureTransport(const net::IPEndPoint& ip_endpoint) {
+    // The mock does not interact with the cert directly, so just leave it null.
+    scoped_refptr<net::X509Certificate> cert;
+    transport_.reset(new SSLClientTransport(ip_endpoint, cert, &net_log_));
+    transport_->SetClientSocketFactoryForTest(&socket_factory_);
+  }
+
+  base::MessageLoop message_loop;
+  net::NetLog net_log_;
+  net::StaticSocketDataProvider tcp_connect_;
+  scoped_ptr<net::SSLSocketDataProvider> ssl_connect_;
+  net::MockClientSocketFactory socket_factory_;
+  scoped_ptr<SSLClientTransport> transport_;
+};
+
+TEST_F(SSLClientTransportTest, ConnectSyncOK) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_CALL(*this, ConnectComplete(net::OK));
+    SetupTCPSyncSocketConnect(endpoint, net::OK);
+    SetupSSLSyncSocketConnect(net::OK);
+    transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                   base::Unretained(this)));
+    EXPECT_NE(nullptr, transport_->TakeConnection().get());
+    base::RunLoop().RunUntilIdle();
+  }
+}
+
+TEST_F(SSLClientTransportTest, ConnectAsyncOK) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_CALL(*this, ConnectComplete(net::OK));
+    SetupTCPAsyncSocketConnect(endpoint, net::OK);
+    SetupSSLAsyncSocketConnect(net::OK);
+    transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                   base::Unretained(this)));
+    base::RunLoop().RunUntilIdle();
+    EXPECT_NE(nullptr, transport_->TakeConnection().get());
+  }
+}
+
+TEST_F(SSLClientTransportTest, ConnectSyncTCPError) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED));
+  SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+}
+
+TEST_F(SSLClientTransportTest, ConnectAsyncTCPError) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED));
+  SetupTCPAsyncSocketConnect(endpoint, net::ERR_FAILED);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+}
+
+TEST_F(SSLClientTransportTest, ConnectSyncSSLError) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED));
+  SetupTCPSyncSocketConnect(endpoint, net::OK);
+  SetupSSLSyncSocketConnect(net::ERR_FAILED);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+}
+
+TEST_F(SSLClientTransportTest, ConnectAsyncSSLError) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+  EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED));
+  SetupTCPAsyncSocketConnect(endpoint, net::OK);
+  SetupSSLAsyncSocketConnect(net::ERR_FAILED);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+}
+
+TEST_F(SSLClientTransportTest, ConnectAfterError) {
+  net::IPEndPoint endpoint = CreateIPEndpointFromLiteral(kIPV4Address, kPort);
+  ConfigureTransport(endpoint);
+
+  // TCP connection fails.
+  EXPECT_CALL(*this, ConnectComplete(net::ERR_FAILED));
+  SetupTCPSyncSocketConnect(endpoint, net::ERR_FAILED);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+  base::RunLoop().RunUntilIdle();
+
+  // Subsequent TCP+SSL connections succeed.
+  EXPECT_CALL(*this, ConnectComplete(net::OK));
+  SetupTCPSyncSocketConnect(endpoint, net::OK);
+  SetupSSLSyncSocketConnect(net::OK);
+  transport_->Connect(base::Bind(&SSLClientTransportTest::ConnectComplete,
+                                 base::Unretained(this)));
+  EXPECT_NE(nullptr, transport_->TakeConnection().get());
+  base::RunLoop().RunUntilIdle();
+}
+
+}  // namespace blimp