Chromium Code Reviews Chromium Code Reviews
Issue 2093923004:
[Cast Channel] Add real SSL tests to CastSocketTest (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master| Index: extensions/browser/api/cast_channel/cast_socket_unittest.cc |
| diff --git a/extensions/browser/api/cast_channel/cast_socket_unittest.cc b/extensions/browser/api/cast_channel/cast_socket_unittest.cc |
| index 08b18acf01a56c27b35bf7c3d68164d83f4ea61d..716b43220fa6378925ddd678a931d97941844ae7 100644 |
| --- a/extensions/browser/api/cast_channel/cast_socket_unittest.cc |
| +++ b/extensions/browser/api/cast_channel/cast_socket_unittest.cc |
| @@ -9,6 +9,7 @@ |
| #include <utility> |
| #include <vector> |
| +#include "base/files/file_util.h" |
| #include "base/location.h" |
| #include "base/macros.h" |
| #include "base/memory/ptr_util.h" |
| @@ -21,6 +22,8 @@ |
| #include "base/test/simple_test_clock.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/timer/mock_timer.h" |
| +#include "content/public/test/test_browser_thread_bundle.h" |
| +#include "crypto/rsa_private_key.h" |
| #include "extensions/browser/api/cast_channel/cast_auth_util.h" |
| #include "extensions/browser/api/cast_channel/cast_framer.h" |
| #include "extensions/browser/api/cast_channel/cast_message_util.h" |
| @@ -30,11 +33,15 @@ |
| #include "extensions/common/api/cast_channel/cast_channel.pb.h" |
| #include "net/base/address_list.h" |
| #include "net/base/net_errors.h" |
| +#include "net/cert/pem_tokenizer.h" |
| #include "net/log/test_net_log.h" |
| #include "net/socket/socket_test_util.h" |
| #include "net/socket/ssl_client_socket.h" |
| +#include "net/socket/ssl_server_socket.h" |
| #include "net/socket/tcp_client_socket.h" |
| +#include "net/socket/tcp_server_socket.h" |
| #include "net/ssl/ssl_info.h" |
| +#include "net/ssl/ssl_server_config.h" |
| #include "net/test/cert_test_util.h" |
| #include "net/test/test_data_directory.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| @@ -171,42 +178,26 @@ class CompleteHandler { |
| DISALLOW_COPY_AND_ASSIGN(CompleteHandler); |
| }; |
| -class TestCastSocket : public CastSocketImpl { |
| +class TestCastSocketBase : public CastSocketImpl { |
| public: |
| - static std::unique_ptr<TestCastSocket> Create( |
| - Logger* logger, |
| - uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) { |
| - return std::unique_ptr<TestCastSocket>( |
| - new TestCastSocket(CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL, |
| - kDistantTimeoutMillis, logger, device_capabilities)); |
| - } |
| - |
| - static std::unique_ptr<TestCastSocket> CreateSecure( |
| - Logger* logger, |
| - uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) { |
| - return std::unique_ptr<TestCastSocket>(new TestCastSocket( |
| - CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED, |
| - kDistantTimeoutMillis, logger, device_capabilities)); |
| - } |
| - |
| - TestCastSocket(const net::IPEndPoint& ip_endpoint, |
| - ChannelAuthType channel_auth, |
| - int64_t timeout_ms, |
| - Logger* logger, |
| - uint64_t device_capabilities) |
| - : TestCastSocket(ip_endpoint, |
| - channel_auth, |
| - timeout_ms, |
| - logger, |
| - new net::TestNetLog(), |
| - device_capabilities) {} |
| - |
| - TestCastSocket(const net::IPEndPoint& ip_endpoint, |
| - ChannelAuthType channel_auth, |
| - int64_t timeout_ms, |
| - Logger* logger, |
| - net::TestNetLog* capturing_net_log, |
| - uint64_t device_capabilities) |
| + TestCastSocketBase(const net::IPEndPoint& ip_endpoint, |
| + ChannelAuthType channel_auth, |
| + int64_t timeout_ms, |
| + Logger* logger, |
| + uint64_t device_capabilities) |
| + : TestCastSocketBase(ip_endpoint, |
| + channel_auth, |
| + timeout_ms, |
| + logger, |
| + new net::TestNetLog(), |
| + device_capabilities) {} |
| + |
| + TestCastSocketBase(const net::IPEndPoint& ip_endpoint, |
| + ChannelAuthType channel_auth, |
| + int64_t timeout_ms, |
| + Logger* logger, |
| + net::TestNetLog* capturing_net_log, |
| + uint64_t device_capabilities) |
| : CastSocketImpl("some_extension_id", |
| ip_endpoint, |
| channel_auth, |
| @@ -220,12 +211,103 @@ class TestCastSocket : public CastSocketImpl { |
| extract_cert_result_(true), |
| verify_challenge_result_(true), |
| verify_challenge_disallow_(false), |
| + mock_timer_(new base::MockTimer(false, false)) {} |
| + |
| + ~TestCastSocketBase() override {} |
| + |
| + void SetExtractCertResult(bool value) { extract_cert_result_ = value; } |
|
mark a. foltz
2016/07/28 00:10:01
s/value/extract_result/
btolsch
2016/08/11 22:31:33
Done.
|
| + |
| + void SetVerifyChallengeResult(bool value) { |
|
mark a. foltz
2016/07/28 00:10:01
s/value/verify_challenge/
btolsch
2016/08/11 22:31:33
Done.
|
| + verify_challenge_result_ = value; |
| + } |
| + |
| + void TriggerTimeout() { mock_timer_->Fire(); } |
| + |
| + bool TestVerifyChannelPolicyNone() { |
|
mark a. foltz
2016/07/28 00:10:01
nit: This isn't actually "testing" in the sense th
btolsch
2016/08/11 22:31:33
Done.
|
| + AuthResult authResult; |
| + return VerifyChannelPolicy(authResult); |
| + } |
| + |
| + bool TestVerifyChannelPolicyAudioOnly() { |
|
mark a. foltz
2016/07/28 00:10:01
HasChannelPolicyAudioOnly()
btolsch
2016/08/11 22:31:33
Done.
|
| + AuthResult authResult; |
| + authResult.channel_policies |= AuthResult::POLICY_AUDIO_ONLY; |
| + return VerifyChannelPolicy(authResult); |
| + } |
| + |
| + void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; } |
|
mark a. foltz
2016/07/28 00:10:01
Why not SetDisallowVerifyChallengeResult like the
btolsch
2016/08/11 22:31:33
Copied from original class, and this is actually d
|
| + |
| + protected: |
| + scoped_refptr<net::X509Certificate> ExtractPeerCert() override { |
| + return extract_cert_result_ |
| + ? net::ImportCertFromFile(net::GetTestCertsDirectory(), |
|
mark a. foltz
2016/07/28 00:10:01
Can net::ImportCertFromFile return an error? Shou
btolsch
2016/08/11 22:31:33
Done but with EXPECT, can't use ASSERT in function
|
| + "ok_cert.pem") |
| + : nullptr; |
| + } |
| + |
| + bool VerifyChallengeReply() override { |
| + EXPECT_FALSE(verify_challenge_disallow_); |
|
mark a. foltz
2016/07/28 00:10:01
But this flag is set by the the test fixture, not
btolsch
2016/08/11 22:31:33
ASSERT_* can't be used in functions that return a
|
| + return verify_challenge_result_; |
| + } |
| + |
| + base::Timer* GetTimer() override { return mock_timer_.get(); } |
| + |
| + std::unique_ptr<net::TestNetLog> capturing_net_log_; |
| + net::IPEndPoint ip_; |
| + // Simulated result of peer cert extraction. |
| + bool extract_cert_result_; |
| + // Simulated result of verifying challenge reply. |
| + bool verify_challenge_result_; |
| + bool verify_challenge_disallow_; |
| + std::unique_ptr<base::MockTimer> mock_timer_; |
| + |
| + DISALLOW_COPY_AND_ASSIGN(TestCastSocketBase); |
| +}; |
| + |
| +class MockTestCastSocket : public TestCastSocketBase { |
| + public: |
| + static std::unique_ptr<MockTestCastSocket> Create( |
| + Logger* logger, |
| + uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) { |
| + return std::unique_ptr<MockTestCastSocket>(new MockTestCastSocket( |
| + CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL, kDistantTimeoutMillis, |
|
mark a. foltz
2016/07/28 00:10:01
I wonder if anyone actually uses CHANNEL_AUTH_TYPE
mark a. foltz
2016/07/28 00:11:49
Note, I was thinking this would be a separate patc
btolsch
2016/08/11 22:31:33
Acknowledged.
btolsch
2016/08/11 22:31:33
It looks like there are no legitimate uses so a fo
|
| + logger, device_capabilities)); |
| + } |
| + |
| + static std::unique_ptr<MockTestCastSocket> CreateSecure( |
| + Logger* logger, |
| + uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) { |
| + return std::unique_ptr<MockTestCastSocket>(new MockTestCastSocket( |
| + CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED, |
| + kDistantTimeoutMillis, logger, device_capabilities)); |
| + } |
| + |
| + MockTestCastSocket(const net::IPEndPoint& ip_endpoint, |
| + ChannelAuthType channel_auth, |
| + int64_t timeout_ms, |
| + Logger* logger, |
| + uint64_t device_capabilities) |
| + : MockTestCastSocket(ip_endpoint, |
| + channel_auth, |
| + timeout_ms, |
| + logger, |
| + new net::TestNetLog(), |
| + device_capabilities) {} |
| + |
| + MockTestCastSocket(const net::IPEndPoint& ip_endpoint, |
| + ChannelAuthType channel_auth, |
| + int64_t timeout_ms, |
| + Logger* logger, |
| + net::TestNetLog* capturing_net_log, |
| + uint64_t device_capabilities) |
| + : TestCastSocketBase(ip_endpoint, |
| + channel_auth, |
| + timeout_ms, |
| + logger, |
| + capturing_net_log, |
| + device_capabilities), |
| tcp_unresponsive_(false), |
| - mock_timer_(new base::MockTimer(false, false)), |
| mock_transport_(nullptr) {} |
| - ~TestCastSocket() override {} |
| - |
| void SetupMockTransport() { |
| mock_transport_ = new MockCastTransport; |
| SetTransportForTesting(base::WrapUnique(mock_transport_)); |
| @@ -262,31 +344,6 @@ class TestCastSocket : public CastSocketImpl { |
| // Helpers for modifying other connection-related behaviors. |
| void SetupTcpConnectUnresponsive() { tcp_unresponsive_ = true; } |
| - void SetExtractCertResult(bool value) { |
| - extract_cert_result_ = value; |
| - } |
| - |
| - void SetVerifyChallengeResult(bool value) { |
| - verify_challenge_result_ = value; |
| - } |
| - |
| - void TriggerTimeout() { |
| - mock_timer_->Fire(); |
| - } |
| - |
| - bool TestVerifyChannelPolicyNone() { |
| - AuthResult authResult; |
| - return VerifyChannelPolicy(authResult); |
| - } |
| - |
| - bool TestVerifyChannelPolicyAudioOnly() { |
| - AuthResult authResult; |
| - authResult.channel_policies |= AuthResult::POLICY_AUDIO_ONLY; |
| - return VerifyChannelPolicy(authResult); |
| - } |
| - |
| - void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; } |
| - |
| MockCastTransport* GetMockTransport() { |
| CHECK(mock_transport_); |
| return mock_transport_; |
| @@ -317,22 +374,6 @@ class TestCastSocket : public CastSocketImpl { |
| net::AddressList(), capturing_net_log_.get(), ssl_data_.get())); |
| } |
| - scoped_refptr<net::X509Certificate> ExtractPeerCert() override { |
| - return extract_cert_result_ |
| - ? net::ImportCertFromFile(net::GetTestCertsDirectory(), |
| - "ok_cert.pem") |
| - : nullptr; |
| - } |
| - |
| - bool VerifyChallengeReply() override { |
| - EXPECT_FALSE(verify_challenge_disallow_); |
| - return verify_challenge_result_; |
| - } |
| - |
| - base::Timer* GetTimer() override { return mock_timer_.get(); } |
| - |
| - std::unique_ptr<net::TestNetLog> capturing_net_log_; |
| - net::IPEndPoint ip_; |
| // Simulated connect data |
| std::unique_ptr<net::MockConnect> tcp_connect_data_; |
| std::unique_ptr<net::MockConnect> ssl_connect_data_; |
| @@ -340,27 +381,46 @@ class TestCastSocket : public CastSocketImpl { |
| std::vector<net::MockWrite> writes_; |
| std::vector<net::MockRead> reads_; |
| std::unique_ptr<net::SocketDataProvider> ssl_data_; |
| - // Simulated result of peer cert extraction. |
| - bool extract_cert_result_; |
| - // Simulated result of verifying challenge reply. |
| - bool verify_challenge_result_; |
| - bool verify_challenge_disallow_; |
| // If true, makes TCP connection process stall. For timeout testing. |
| bool tcp_unresponsive_; |
| - std::unique_ptr<base::MockTimer> mock_timer_; |
| MockCastTransport* mock_transport_; |
| +}; |
| + |
| +class SslTestCastSocket : public TestCastSocketBase { |
| + public: |
| + static std::unique_ptr<SslTestCastSocket> Create( |
| + Logger* logger, |
| + uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) { |
| + return std::unique_ptr<SslTestCastSocket>(new SslTestCastSocket( |
| + CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED, |
| + kDistantTimeoutMillis, logger, device_capabilities)); |
| + } |
| + |
| + using TestCastSocketBase::TestCastSocketBase; |
| + |
| + void SetTcpSocket(std::unique_ptr<net::TCPClientSocket> tcp_client_socket) { |
| + tcp_client_socket_ = std::move(tcp_client_socket); |
| + } |
| + |
| + private: |
| + std::unique_ptr<net::TCPClientSocket> CreateTcpSocket() override { |
| + return std::move(tcp_client_socket_); |
| + } |
| + |
| + using CastSocketImpl::CreateSslSocket; |
| - DISALLOW_COPY_AND_ASSIGN(TestCastSocket); |
| + std::unique_ptr<net::TCPClientSocket> tcp_client_socket_; |
| }; |
| -class CastSocketTest : public testing::Test { |
| +class CastSocketTestBase : public testing::Test { |
| public: |
| - CastSocketTest() |
| - : logger_( |
| + CastSocketTestBase() |
| + : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), |
| + logger_( |
| new Logger(base::WrapUnique<base::Clock>(new base::SimpleTestClock), |
| base::Time())), |
| delegate_(new MockDelegate) {} |
| - ~CastSocketTest() override {} |
| + ~CastSocketTestBase() override {} |
| void SetUp() override { EXPECT_CALL(*delegate_, OnMessage(_)).Times(0); } |
| @@ -372,106 +432,232 @@ class CastSocketTest : public testing::Test { |
| } |
| } |
| - void CreateCastSocket() { socket_ = TestCastSocket::Create(logger_); } |
| + protected: |
| + // Runs all pending tasks in the message loop. |
| + void RunPendingTasks() { |
| + base::RunLoop run_loop; |
| + run_loop.RunUntilIdle(); |
| + } |
| + |
| + content::TestBrowserThreadBundle thread_bundle_; |
| + Logger* logger_; |
| + CompleteHandler handler_; |
| + std::unique_ptr<MockDelegate> delegate_; |
| + std::unique_ptr<TestCastSocketBase> socket_; |
| + |
| + private: |
| + DISALLOW_COPY_AND_ASSIGN(CastSocketTestBase); |
|
mark a. foltz
2016/07/28 00:10:01
I don't think test objects are normally copied/ass
btolsch
2016/08/11 22:31:33
Carried over from old code. Removed.
|
| +}; |
| + |
| +class MockCastSocketTest : public CastSocketTestBase { |
| + protected: |
| + void CreateCastSocket() { socket_ = MockTestCastSocket::Create(logger_); } |
| void CreateCastSocketSecure() { |
| - socket_ = TestCastSocket::CreateSecure(logger_); |
| + socket_ = MockTestCastSocket::CreateSecure(logger_); |
| } |
| void HandleAuthHandshake() { |
| - socket_->SetupMockTransport(); |
| + socket()->SetupMockTransport(); |
| CastMessage challenge_proto = CreateAuthChallenge(); |
| - EXPECT_CALL(*socket_->GetMockTransport(), |
| + EXPECT_CALL(*socket()->GetMockTransport(), |
| SendMessage(EqualsProto(challenge_proto), _)) |
| .WillOnce(PostCompletionCallbackTask<1>(net::OK)); |
| - EXPECT_CALL(*socket_->GetMockTransport(), Start()); |
| + EXPECT_CALL(*socket()->GetMockTransport(), Start()); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - socket_->GetMockTransport()->current_delegate()->OnMessage( |
| + socket()->GetMockTransport()->current_delegate()->OnMessage( |
| CreateAuthReply()); |
| RunPendingTasks(); |
| } |
| + MockTestCastSocket* socket() { |
| + return static_cast<MockTestCastSocket*>(socket_.get()); |
| + } |
| +}; |
| + |
| +class SslCastSocketTest : public CastSocketTestBase { |
| protected: |
| - // Runs all pending tasks in the message loop. |
| - void RunPendingTasks() { |
| - base::RunLoop run_loop; |
| - run_loop.RunUntilIdle(); |
| + void CreateSslCastSocket() { socket_ = SslTestCastSocket::Create(logger_); } |
| + |
| + // Initializes the SSLServerSocket |server_socket_| and the TCP socket |
| + // |tcp_client_socket_| to be used by the CastSocket |socket_| as transport |
| + // to |server_socket_|. |
| + void CreateSslSockets() { |
| + server_cert_ = |
| + net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem"); |
| + ASSERT_TRUE(server_cert_); |
| + server_private_key_ = ReadTestKeyFromPEM("ok_cert.pem"); |
| + ASSERT_TRUE(server_private_key_); |
| + server_context_ = CreateSSLServerContext( |
| + server_cert_.get(), *server_private_key_, server_ssl_config_); |
| + |
| + tcp_server_socket_.reset( |
| + new net::TCPServerSocket(nullptr, net::NetLog::Source())); |
| + ASSERT_EQ(net::OK, |
| + tcp_server_socket_->ListenWithAddressAndPort("127.0.0.1", 0, 1)); |
| + net::IPEndPoint server_address; |
| + ASSERT_EQ(net::OK, tcp_server_socket_->GetLocalAddress(&server_address)); |
| + tcp_client_socket_.reset( |
| + new net::TCPClientSocket(net::AddressList(server_address), nullptr, |
| + nullptr, net::NetLog::Source())); |
| + |
| + std::unique_ptr<net::StreamSocket> accepted_socket; |
| + ASSERT_EQ( |
| + net::ERR_IO_PENDING, |
| + tcp_server_socket_->Accept( |
| + &accepted_socket, base::Bind(&SslCastSocketTest::TcpAcceptCallback, |
| + base::Unretained(this)))); |
| + ASSERT_EQ(net::ERR_IO_PENDING, tcp_client_socket_->Connect(base::Bind( |
| + &SslCastSocketTest::TcpConnectCallback, |
| + base::Unretained(this)))); |
| + RunPendingTasks(); |
| + ASSERT_TRUE(accepted_socket); |
| + ASSERT_TRUE(tcp_client_socket_->IsConnected()); |
| + |
| + server_socket_ = |
| + server_context_->CreateSSLServerSocket(std::move(accepted_socket)); |
| + ASSERT_TRUE(server_socket_); |
| } |
| - base::MessageLoop message_loop_; |
| - Logger* logger_; |
| - std::unique_ptr<TestCastSocket> socket_; |
| - CompleteHandler handler_; |
| - std::unique_ptr<MockDelegate> delegate_; |
| + void TcpAcceptCallback(int result) { ASSERT_EQ(net::OK, result); } |
| - private: |
| - DISALLOW_COPY_AND_ASSIGN(CastSocketTest); |
| + void TcpConnectCallback(int result) { ASSERT_EQ(net::OK, result); } |
| + |
| + std::unique_ptr<crypto::RSAPrivateKey> ReadTestKeyFromPEM( |
| + const base::StringPiece& name) { |
| + base::FilePath certs_dir(net::GetTestCertsDirectory()); |
| + base::FilePath key_path = certs_dir.AppendASCII(name); |
| + std::vector<std::string> headers; |
| + headers.push_back("PRIVATE KEY"); |
| + std::string pem_data; |
| + if (!base::ReadFileToString(key_path, &pem_data)) { |
| + return nullptr; |
| + } |
| + net::PEMTokenizer pem_tokenizer(pem_data, headers); |
| + if (!pem_tokenizer.GetNext()) { |
| + return nullptr; |
| + } |
| + std::vector<uint8_t> key_vector(pem_tokenizer.data().begin(), |
| + pem_tokenizer.data().end()); |
| + |
| + std::unique_ptr<crypto::RSAPrivateKey> key( |
| + crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector)); |
| + return key; |
| + } |
| + |
| + int ReadExactLength(net::IOBuffer* buffer, |
| + int buffer_length, |
| + net::Socket* socket) { |
| + scoped_refptr<net::DrainableIOBuffer> draining_buffer( |
| + new net::DrainableIOBuffer(buffer, buffer_length)); |
| + while (draining_buffer->BytesRemaining() > 0) { |
| + net::TestCompletionCallback read_callback; |
| + int read_result = read_callback.GetResult(server_socket_->Read( |
| + draining_buffer.get(), buffer_length, read_callback.callback())); |
| + EXPECT_GT(read_result, 0); |
| + draining_buffer->DidConsume(read_result); |
| + } |
| + return buffer_length; |
| + } |
| + |
| + int WriteExactLength(net::IOBuffer* buffer, |
| + int buffer_length, |
| + net::Socket* socket) { |
| + scoped_refptr<net::DrainableIOBuffer> draining_buffer( |
| + new net::DrainableIOBuffer(buffer, buffer_length)); |
| + while (draining_buffer->BytesRemaining() > 0) { |
| + net::TestCompletionCallback write_callback; |
| + int write_result = write_callback.GetResult(server_socket_->Write( |
| + draining_buffer.get(), buffer_length, write_callback.callback())); |
| + EXPECT_GT(write_result, 0); |
| + draining_buffer->DidConsume(write_result); |
| + } |
| + return buffer_length; |
| + } |
| + |
| + SslTestCastSocket* socket() { |
| + return static_cast<SslTestCastSocket*>(socket_.get()); |
| + } |
| + |
| + // Underlying TCP sockets for |socket_| to communicate with |server_socket_| |
| + // when testing with the real SSL implementation. |
| + std::unique_ptr<net::TCPClientSocket> tcp_client_socket_; |
| + std::unique_ptr<net::TCPServerSocket> tcp_server_socket_; |
| + |
| + // |server_socket_| is used for the *RealSSL tests in order to test the |
| + // CastSocket over a real SSL socket. The other members below are used to |
| + // initialize |server_socket_|. |
| + std::unique_ptr<net::SSLServerSocket> server_socket_; |
| + std::unique_ptr<net::SSLServerContext> server_context_; |
| + std::unique_ptr<crypto::RSAPrivateKey> server_private_key_; |
| + scoped_refptr<net::X509Certificate> server_cert_; |
| + net::SSLServerConfig server_ssl_config_; |
| }; |
| // Tests connecting and closing the socket. |
| -TEST_F(CastSocketTest, TestConnectAndClose) { |
| +TEST_F(MockCastSocketTest, TestConnectAndClose) { |
| CreateCastSocket(); |
| - socket_->SetupMockTransport(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupMockTransport(); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| EXPECT_CALL(handler_, OnCloseComplete(net::OK)); |
| - socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete, |
| - base::Unretained(&handler_))); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + socket()->Close(base::Bind(&CompleteHandler::OnCloseComplete, |
| + base::Unretained(&handler_))); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Tests that the following connection flow works: |
| // - TCP connection succeeds (async) |
| // - SSL connection succeeds (async) |
| -TEST_F(CastSocketTest, TestConnect) { |
| +TEST_F(MockCastSocketTest, TestConnect) { |
| CreateCastSocket(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| - socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Tests that the following connection flow works: |
| // - TCP connection fails (async) |
| -TEST_F(CastSocketTest, TestConnectFails) { |
| +TEST_F(MockCastSocketTest, TestConnectFails) { |
| CreateCastSocket(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED); |
| + socket()->SetupTcpConnect(net::ASYNC, net::ERR_FAILED); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket()->error_state()); |
| EXPECT_EQ(proto::TCP_SOCKET_CONNECT_COMPLETE, |
| - logger_->GetLastErrors(socket_->id()).event_type); |
| + logger_->GetLastErrors(socket()->id()).event_type); |
| EXPECT_EQ(net::ERR_FAILED, |
| - logger_->GetLastErrors(socket_->id()).net_return_value); |
| + logger_->GetLastErrors(socket()->id()).net_return_value); |
| } |
| // Tests that the following connection flow works: |
| @@ -481,15 +667,15 @@ TEST_F(CastSocketTest, TestConnectFails) { |
| // - Challenge request is sent (async) |
| // - Challenge response is received (async) |
| // - Credentials are verified successfuly |
| -TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectFullSecureFlowAsync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| HandleAuthHandshake(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Tests that the following connection flow works: |
| @@ -499,414 +685,541 @@ TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) { |
| // - Challenge request is sent (sync) |
| // - Challenge response is received (sync) |
| // - Credentials are verified successfuly |
| -TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) { |
| +TEST_F(MockCastSocketTest, TestConnectFullSecureFlowSync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| HandleAuthHandshake(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Test that an AuthMessage with a mangled namespace triggers cancelation |
| // of the connection event loop. |
| -TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) { |
| +TEST_F(MockCastSocketTest, TestConnectAuthMessageCorrupted) { |
| CreateCastSocketSecure(); |
| - socket_->SetupMockTransport(); |
| + socket()->SetupMockTransport(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| CastMessage challenge_proto = CreateAuthChallenge(); |
| - EXPECT_CALL(*socket_->GetMockTransport(), |
| + EXPECT_CALL(*socket()->GetMockTransport(), |
| SendMessage(EqualsProto(challenge_proto), _)) |
| .WillOnce(PostCompletionCallbackTask<1>(net::OK)); |
| - EXPECT_CALL(*socket_->GetMockTransport(), Start()); |
| + EXPECT_CALL(*socket()->GetMockTransport(), Start()); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_TRANSPORT_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| CastMessage mangled_auth_reply = CreateAuthReply(); |
| mangled_auth_reply.set_namespace_("BOGUS_NAMESPACE"); |
| - socket_->GetMockTransport()->current_delegate()->OnMessage( |
| + socket()->GetMockTransport()->current_delegate()->OnMessage( |
| mangled_auth_reply); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_TRANSPORT_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| // Verifies that the CastSocket's resources were torn down during channel |
| // close. (see http://crbug.com/504078) |
| - EXPECT_EQ(nullptr, socket_->transport()); |
| + EXPECT_EQ(nullptr, socket()->transport()); |
| } |
| // Test connection error - TCP connect fails (async) |
| -TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectTcpConnectErrorAsync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED); |
| + socket()->SetupTcpConnect(net::ASYNC, net::ERR_FAILED); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket()->error_state()); |
| } |
| // Test connection error - TCP connect fails (sync) |
| -TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) { |
| +TEST_F(MockCastSocketTest, TestConnectTcpConnectErrorSync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket()->error_state()); |
| } |
| // Test connection error - timeout |
| -TEST_F(CastSocketTest, TestConnectTcpTimeoutError) { |
| +TEST_F(MockCastSocketTest, TestConnectTcpTimeoutError) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnectUnresponsive(); |
| + socket()->SetupTcpConnectUnresponsive(); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CONNECTING, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| - socket_->TriggerTimeout(); |
| + EXPECT_EQ(cast_channel::READY_STATE_CONNECTING, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| + socket()->TriggerTimeout(); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| } |
| // Test connection error - TCP socket returns timeout |
| -TEST_F(CastSocketTest, TestConnectTcpSocketTimeoutError) { |
| +TEST_F(MockCastSocketTest, TestConnectTcpSocketTimeoutError) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT, |
| - logger_->GetLastErrors(socket_->id()).net_return_value); |
| + logger_->GetLastErrors(socket()->id()).net_return_value); |
| } |
| // Test connection error - SSL connect fails (async) |
| -TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectSslConnectErrorAsync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| } |
| // Test connection error - SSL connect fails (sync) |
| -TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) { |
| +TEST_F(MockCastSocketTest, TestConnectSslConnectErrorSync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| EXPECT_EQ(net::ERR_FAILED, |
| - logger_->GetLastErrors(socket_->id()).net_return_value); |
| + logger_->GetLastErrors(socket()->id()).net_return_value); |
| } |
| // Test connection error - SSL connect times out (sync) |
| -TEST_F(CastSocketTest, TestConnectSslConnectTimeoutSync) { |
| +TEST_F(MockCastSocketTest, TestConnectSslConnectTimeoutSync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT, |
| - logger_->GetLastErrors(socket_->id()).net_return_value); |
| + logger_->GetLastErrors(socket()->id()).net_return_value); |
| } |
| // Test connection error - SSL connect times out (async) |
| -TEST_F(CastSocketTest, TestConnectSslConnectTimeoutAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectSslConnectTimeoutAsync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| } |
| // Test connection error - cert extraction error (async) |
| -TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectCertExtractionErrorAsync) { |
| CreateCastSocket(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| // Set cert extraction to fail |
| - socket_->SetExtractCertResult(false); |
| + socket()->SetExtractCertResult(false); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| } |
| // Test connection error - cert extraction error (sync) |
| -TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) { |
| +TEST_F(MockCastSocketTest, TestConnectCertExtractionErrorSync) { |
| CreateCastSocket(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| // Set cert extraction to fail |
| - socket_->SetExtractCertResult(false); |
| + socket()->SetExtractCertResult(false); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| } |
| // Test connection error - challenge send fails |
| -TEST_F(CastSocketTest, TestConnectChallengeSendError) { |
| +TEST_F(MockCastSocketTest, TestConnectChallengeSendError) { |
| CreateCastSocketSecure(); |
| - socket_->SetupMockTransport(); |
| + socket()->SetupMockTransport(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| - EXPECT_CALL(*socket_->GetMockTransport(), |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + EXPECT_CALL(*socket()->GetMockTransport(), |
| SendMessage(EqualsProto(CreateAuthChallenge()), _)) |
| .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET)); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket()->error_state()); |
| } |
| // Test connection error - challenge reply receive fails |
| -TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) { |
| +TEST_F(MockCastSocketTest, TestConnectChallengeReplyReceiveError) { |
| CreateCastSocketSecure(); |
| - socket_->SetupMockTransport(); |
| + socket()->SetupMockTransport(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| - EXPECT_CALL(*socket_->GetMockTransport(), |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + EXPECT_CALL(*socket()->GetMockTransport(), |
| SendMessage(EqualsProto(CreateAuthChallenge()), _)) |
| .WillOnce(PostCompletionCallbackTask<1>(net::OK)); |
| - socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED); |
| + socket()->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED); |
| EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR)); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR)); |
| - EXPECT_CALL(*socket_->GetMockTransport(), Start()); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + EXPECT_CALL(*socket()->GetMockTransport(), Start()); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - socket_->GetMockTransport()->current_delegate()->OnError( |
| + socket()->GetMockTransport()->current_delegate()->OnError( |
| CHANNEL_ERROR_SOCKET_ERROR); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket()->error_state()); |
| } |
| -TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) { |
| +TEST_F(MockCastSocketTest, TestConnectChallengeVerificationFails) { |
| CreateCastSocketSecure(); |
| - socket_->SetupMockTransport(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| - socket_->SetVerifyChallengeResult(false); |
| + socket()->SetupMockTransport(); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->SetVerifyChallengeResult(false); |
| EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| CastMessage challenge_proto = CreateAuthChallenge(); |
| - EXPECT_CALL(*socket_->GetMockTransport(), |
| + EXPECT_CALL(*socket()->GetMockTransport(), |
| SendMessage(EqualsProto(challenge_proto), _)) |
| .WillOnce(PostCompletionCallbackTask<1>(net::OK)); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR)); |
| - EXPECT_CALL(*socket_->GetMockTransport(), Start()); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + EXPECT_CALL(*socket()->GetMockTransport(), Start()); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - socket_->GetMockTransport()->current_delegate()->OnMessage(CreateAuthReply()); |
| + socket()->GetMockTransport()->current_delegate()->OnMessage( |
| + CreateAuthReply()); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state()); |
| EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR, |
| - socket_->error_state()); |
| + socket()->error_state()); |
| +} |
| + |
| +// Tests connecting through an actual non-mocked CastTransport object and |
| +// non-mocked SSLClientSocket, testing the components in integration. |
| +TEST_F(SslCastSocketTest, TestConnectEndToEndWithRealSSL) { |
| + CreateSslCastSocket(); |
| + CreateSslSockets(); |
| + socket()->SetTcpSocket(std::move(tcp_client_socket_)); |
| + |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| + |
| + net::TestCompletionCallback handshake_callback; |
| + int server_ret = handshake_callback.GetResult( |
| + server_socket_->Handshake(handshake_callback.callback())); |
| + |
| + ASSERT_EQ(net::OK, server_ret); |
| + |
| + // Set low-level auth challenge expectations. |
| + CastMessage challenge = CreateAuthChallenge(); |
| + std::string challenge_str; |
| + EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str)); |
| + |
| + int challenge_buffer_length = challenge_str.size(); |
| + scoped_refptr<net::IOBuffer> challenge_buffer( |
| + new net::IOBuffer(challenge_buffer_length)); |
| + int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length, |
| + server_socket_.get()); |
| + |
| + EXPECT_EQ(challenge_buffer_length, read); |
| + EXPECT_EQ(challenge_str, |
| + std::string(challenge_buffer->data(), challenge_buffer_length)); |
| + |
| + // Set low-level auth reply expectations. |
| + CastMessage reply = CreateAuthReply(); |
| + std::string reply_str; |
| + EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str)); |
| + |
| + scoped_refptr<net::StringIOBuffer> reply_buffer( |
| + new net::StringIOBuffer(reply_str)); |
| + int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(), |
| + server_socket_.get()); |
| + |
| + EXPECT_EQ(reply_buffer->size(), written); |
| + EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| + RunPendingTasks(); |
| + |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| +} |
| + |
| +// Sends message data through an actual non-mocked CastTransport object and |
| +// non-mocked SSLClientSocket, testing the components in integration. |
| +TEST_F(SslCastSocketTest, TestMessageEndToEndWithRealSSL) { |
| + CreateSslCastSocket(); |
| + CreateSslSockets(); |
| + socket()->SetTcpSocket(std::move(tcp_client_socket_)); |
| + |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| + |
| + net::TestCompletionCallback handshake_callback; |
| + int server_ret = handshake_callback.GetResult( |
| + server_socket_->Handshake(handshake_callback.callback())); |
| + |
| + ASSERT_EQ(net::OK, server_ret); |
| + |
| + // Set low-level auth challenge expectations. |
| + CastMessage challenge = CreateAuthChallenge(); |
| + std::string challenge_str; |
| + EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str)); |
| + |
| + int challenge_buffer_length = challenge_str.size(); |
| + scoped_refptr<net::IOBuffer> challenge_buffer( |
| + new net::IOBuffer(challenge_buffer_length)); |
| + |
| + int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length, |
| + server_socket_.get()); |
| + |
| + EXPECT_EQ(challenge_buffer_length, read); |
| + EXPECT_EQ(challenge_str, |
| + std::string(challenge_buffer->data(), challenge_buffer_length)); |
| + |
| + // Set low-level auth reply expectations. |
| + CastMessage reply = CreateAuthReply(); |
| + std::string reply_str; |
| + EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str)); |
| + |
| + scoped_refptr<net::StringIOBuffer> reply_buffer( |
| + new net::StringIOBuffer(reply_str)); |
| + int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(), |
| + server_socket_.get()); |
| + |
| + EXPECT_EQ(reply_buffer->size(), written); |
| + EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| + RunPendingTasks(); |
| + |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| + |
| + // Send a test message through the ssl socket. |
| + CastMessage test_message = CreateTestMessage(); |
| + std::string test_message_str; |
| + EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str)); |
| + |
| + int test_message_length = test_message_str.size(); |
| + scoped_refptr<net::IOBuffer> test_message_buffer( |
| + new net::IOBuffer(test_message_length)); |
| + |
| + EXPECT_CALL(handler_, OnWriteComplete(net::OK)); |
| + socket()->transport()->SendMessage( |
| + test_message, base::Bind(&CompleteHandler::OnWriteComplete, |
| + base::Unretained(&handler_))); |
| + RunPendingTasks(); |
| + |
| + read = ReadExactLength(test_message_buffer.get(), test_message_length, |
| + server_socket_.get()); |
| + |
| + EXPECT_EQ(test_message_length, read); |
| + EXPECT_EQ(test_message_str, |
| + std::string(test_message_buffer->data(), test_message_length)); |
| + |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Sends message data through an actual non-mocked CastTransport object, |
| // testing the two components in integration. |
| -TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportAsync) { |
| +TEST_F(MockCastSocketTest, TestConnectEndToEndWithRealTransportAsync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::ASYNC, net::OK); |
| - socket_->SetupSslConnect(net::ASYNC, net::OK); |
| + socket()->SetupTcpConnect(net::ASYNC, net::OK); |
| + socket()->SetupSslConnect(net::ASYNC, net::OK); |
| // Set low-level auth challenge expectations. |
| CastMessage challenge = CreateAuthChallenge(); |
| std::string challenge_str; |
| EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str)); |
| - socket_->AddWriteResultForData(net::ASYNC, challenge_str); |
| + socket()->AddWriteResultForData(net::ASYNC, challenge_str); |
| // Set low-level auth reply expectations. |
| CastMessage reply = CreateAuthReply(); |
| std::string reply_str; |
| EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str)); |
| - socket_->AddReadResultForData(net::ASYNC, reply_str); |
| - socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| + socket()->AddReadResultForData(net::ASYNC, reply_str); |
| + socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| CastMessage test_message = CreateTestMessage(); |
| std::string test_message_str; |
| EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str)); |
| - socket_->AddWriteResultForData(net::ASYNC, test_message_str); |
| + socket()->AddWriteResultForData(net::ASYNC, test_message_str); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| // Send the test message through a real transport object. |
| EXPECT_CALL(handler_, OnWriteComplete(net::OK)); |
| - socket_->transport()->SendMessage( |
| + socket()->transport()->SendMessage( |
| test_message, base::Bind(&CompleteHandler::OnWriteComplete, |
| base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Same as TestConnectEndToEndWithRealTransportAsync, except synchronous. |
| -TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportSync) { |
| +TEST_F(MockCastSocketTest, TestConnectEndToEndWithRealTransportSync) { |
| CreateCastSocketSecure(); |
| - socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| - socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK); |
| + socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK); |
| // Set low-level auth challenge expectations. |
| CastMessage challenge = CreateAuthChallenge(); |
| std::string challenge_str; |
| EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str)); |
| - socket_->AddWriteResultForData(net::SYNCHRONOUS, challenge_str); |
| + socket()->AddWriteResultForData(net::SYNCHRONOUS, challenge_str); |
| // Set low-level auth reply expectations. |
| CastMessage reply = CreateAuthReply(); |
| std::string reply_str; |
| EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str)); |
| - socket_->AddReadResultForData(net::SYNCHRONOUS, reply_str); |
| - socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| + socket()->AddReadResultForData(net::SYNCHRONOUS, reply_str); |
| + socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING); |
| CastMessage test_message = CreateTestMessage(); |
| std::string test_message_str; |
| EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str)); |
| - socket_->AddWriteResultForData(net::SYNCHRONOUS, test_message_str); |
| + socket()->AddWriteResultForData(net::SYNCHRONOUS, test_message_str); |
| EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE)); |
| - socket_->Connect(std::move(delegate_), |
| - base::Bind(&CompleteHandler::OnConnectComplete, |
| - base::Unretained(&handler_))); |
| + socket()->Connect(std::move(delegate_), |
| + base::Bind(&CompleteHandler::OnConnectComplete, |
| + base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| // Send the test message through a real transport object. |
| EXPECT_CALL(handler_, OnWriteComplete(net::OK)); |
| - socket_->transport()->SendMessage( |
| + socket()->transport()->SendMessage( |
| test_message, base::Bind(&CompleteHandler::OnWriteComplete, |
| base::Unretained(&handler_))); |
| RunPendingTasks(); |
| - EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state()); |
| - EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state()); |
| + EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state()); |
| + EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state()); |
| } |
| // Tests channel policy verification for device with no capabilities. |
| -TEST_F(CastSocketTest, TestChannelPolicyVerificationCapabilitiesNone) { |
| - socket_ = |
| - TestCastSocket::Create(logger_, cast_channel::CastDeviceCapability::NONE); |
| - EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone()); |
| - EXPECT_TRUE(socket_->TestVerifyChannelPolicyAudioOnly()); |
| +TEST_F(MockCastSocketTest, TestChannelPolicyVerificationCapabilitiesNone) { |
| + socket_ = MockTestCastSocket::Create( |
| + logger_, cast_channel::CastDeviceCapability::NONE); |
| + EXPECT_TRUE(socket()->TestVerifyChannelPolicyNone()); |
| + EXPECT_TRUE(socket()->TestVerifyChannelPolicyAudioOnly()); |
| } |
| // Tests channel policy verification for device with video out capability. |
| -TEST_F(CastSocketTest, TestChannelPolicyVerificationCapabilitiesVideoOut) { |
| - socket_ = TestCastSocket::Create( |
| +TEST_F(MockCastSocketTest, TestChannelPolicyVerificationCapabilitiesVideoOut) { |
| + socket_ = MockTestCastSocket::Create( |
| logger_, cast_channel::CastDeviceCapability::VIDEO_OUT); |
| - EXPECT_FALSE(socket_->audio_only()); |
| - EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone()); |
| - EXPECT_FALSE(socket_->audio_only()); |
| - EXPECT_FALSE(socket_->TestVerifyChannelPolicyAudioOnly()); |
| - EXPECT_TRUE(socket_->audio_only()); |
| + EXPECT_FALSE(socket()->audio_only()); |
| + EXPECT_TRUE(socket()->TestVerifyChannelPolicyNone()); |
| + EXPECT_FALSE(socket()->audio_only()); |
| + EXPECT_FALSE(socket()->TestVerifyChannelPolicyAudioOnly()); |
| + EXPECT_TRUE(socket()->audio_only()); |
| } |
| } // namespace cast_channel |
| } // namespace api |
