summaryrefslogtreecommitdiff
path: root/src/components/connection_handler/test
diff options
context:
space:
mode:
Diffstat (limited to 'src/components/connection_handler/test')
-rw-r--r--src/components/connection_handler/test/CMakeLists.txt12
-rw-r--r--src/components/connection_handler/test/connection_handler_impl_test.cc906
-rw-r--r--src/components/connection_handler/test/connection_test.cc328
-rw-r--r--src/components/connection_handler/test/device_test.cc4
-rw-r--r--src/components/connection_handler/test/heart_beat_monitor_test.cc126
-rw-r--r--src/components/connection_handler/test/include/connection_handler/connection_handler_observer_mock.h (renamed from src/components/connection_handler/test/include/connection_handler_observer_mock.h)42
6 files changed, 888 insertions, 530 deletions
diff --git a/src/components/connection_handler/test/CMakeLists.txt b/src/components/connection_handler/test/CMakeLists.txt
index 7c0e1b2a98..32da4bdcd8 100644
--- a/src/components/connection_handler/test/CMakeLists.txt
+++ b/src/components/connection_handler/test/CMakeLists.txt
@@ -35,26 +35,22 @@ set(appMain_DIR ${CMAKE_SOURCE_DIR}/src/appMain)
include_directories(
${GMOCK_INCLUDE_DIRECTORY}
${COMPONENTS_DIR}/connection_handler/include
- ${COMPONENTS_DIR}/security_manager/test/include
- ${COMPONENTS_DIR}/protocol_handler/test/include
- ${COMPONENTS_DIR}/security_manager/include
${COMPONENTS_DIR}/connection_handler/test/include
- ${COMPONENTS_DIR}/transport_manager/test/include
+ ${COMPONENTS_DIR}/resumption/include
+ ${JSONCPP_INCLUDE_DIRECTORY}
)
set(LIBRARIES
gmock
connectionHandler
- ConfigProfile
ProtocolHandler
- TransportManager
)
set(SOURCES
- #connection_handler_impl_test.cc
+ connection_handler_impl_test.cc
connection_test.cc
device_test.cc
- #heart_beat_monitor_test.cc
+ heart_beat_monitor_test.cc
)
file(COPY ${appMain_DIR}/smartDeviceLink.ini DESTINATION "./")
diff --git a/src/components/connection_handler/test/connection_handler_impl_test.cc b/src/components/connection_handler/test/connection_handler_impl_test.cc
index 94e4c816fa..3a8aaa70b4 100644
--- a/src/components/connection_handler/test/connection_handler_impl_test.cc
+++ b/src/components/connection_handler/test/connection_handler_impl_test.cc
@@ -30,38 +30,60 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include <gtest/gtest.h>
+#include "gtest/gtest.h"
#include <fstream>
-#include <cstdint>
+#include <stdint.h>
+#include <vector>
#include "connection_handler/connection_handler_impl.h"
#include "protocol/common.h"
-#include "config_profile/profile.h"
// TODO(EZamakhov): move security test
-#include "security_manager_mock.h"
-#include "protocol_handler_mock.h"
-#include "connection_handler_observer_mock.h"
-#include "transport_manager_mock.h"
+#include "security_manager/mock_security_manager.h"
+#include "security_manager/mock_ssl_context.h"
+#include "protocol_handler/mock_protocol_handler.h"
+#include "connection_handler/connection_handler_observer_mock.h"
+#include "connection_handler/mock_connection_handler_settings.h"
+#include "transport_manager/mock_transport_manager.h"
+#include "encryption/hashing.h"
namespace test {
namespace components {
-namespace connection_handle_test {
+namespace connection_handler_test {
using namespace ::connection_handler;
using ::protocol_handler::ServiceType;
using namespace ::protocol_handler;
using ::testing::_;
using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::ReturnRefOfCopy;
+
// For service types and PROTECTION_ON/OFF
+enum UnnamedService { kServedService1 = 0x06, kServedService2 = 0x08 };
+
class ConnectionHandlerTest : public ::testing::Test {
protected:
void SetUp() OVERRIDE {
- connection_handler_ = ConnectionHandlerImpl::instance();
+ connection_handler_ = new ConnectionHandlerImpl(
+ mock_connection_handler_settings, mock_transport_manager);
uid_ = 1u;
connection_key_ = connection_handler_->KeyFromPair(0, 0u);
+ protected_services_.clear();
+ unprotected_services_.clear();
+ SetSpecificServices();
}
void TearDown() OVERRIDE {
- ConnectionHandlerImpl::destroy();
+ delete connection_handler_;
+ }
+
+ void SetSpecificServices() {
+#ifdef ENABLE_SECURITY
+ ON_CALL(mock_connection_handler_settings, force_protected_service())
+ .WillByDefault(ReturnRefOfCopy(protected_services_));
+ ON_CALL(mock_connection_handler_settings, force_unprotected_service())
+ .WillByDefault(ReturnRefOfCopy(unprotected_services_));
+#endif // ENABLE_SECURITY
}
// Additional SetUp
void AddTestDeviceConnection() {
@@ -71,19 +93,18 @@ class ConnectionHandlerTest : public ::testing::Test {
device_name_ = "test_name";
mac_address_ = "test_address";
- const transport_manager::DeviceInfo device_info(device_handle_,
- mac_address_,
- device_name_,
- connection_type_);
+ const transport_manager::DeviceInfo device_info(
+ device_handle_, mac_address_, device_name_, connection_type_);
// Add Device and connection
+ ON_CALL(mock_connection_handler_settings, heart_beat_timeout())
+ .WillByDefault(Return(1000u));
connection_handler_->addDeviceConnection(device_info, uid_);
connection_key_ = connection_handler_->KeyFromPair(uid_, 0u);
// Remove all specific services
- SetSpecificServices("", "");
}
void AddTestSession() {
start_session_id_ = connection_handler_->OnSessionStartedCallback(
- uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+ uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
EXPECT_NE(0u, start_session_id_);
EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_);
connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_);
@@ -102,27 +123,12 @@ class ConnectionHandlerTest : public ::testing::Test {
EXPECT_EQ(session_id, start_session_id_);
}
- // Additional SetUp
- void SetSpecificServices(const std::string& protect, const std::string& not_protect) {
- const char* config_file = "config.ini";
- std::ofstream file_config(config_file);
- ASSERT_TRUE(file_config.is_open());
- const std::string non("NON");
- file_config << "[Security Manager]" << std::endl
- << "; Force protected services (could be id's from 0x01 to 0xFF)"
- << std::endl << "ForceProtectedService = "
- << (protect.empty() ? non : protect) << std::endl
- << "; Force unprotected services" << std::endl
- << "ForceUnprotectedService = "
- << (not_protect.empty() ? non : not_protect) << std::endl;
- file_config.close();
- profile::Profile::instance()->config_file_name(config_file);
- }
// Check Service Wrapper
// If session_id is NULL - check that there is no sessions in connection
void CheckSessionExists(const int connectionId, const int session_id) {
// Check all tree to find Session and check own protected value
- const ConnectionList& connection_list = connection_handler_->getConnectionList();
+ const ConnectionList& connection_list =
+ connection_handler_->getConnectionList();
ASSERT_FALSE(connection_list.empty());
ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
ASSERT_NE(conn_it, connection_list.end());
@@ -139,17 +145,21 @@ class ConnectionHandlerTest : public ::testing::Test {
const ServiceList& service_list = session.service_list;
ASSERT_FALSE(service_list.empty());
// Check RPC and bulk services in session
- ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kRpc));
- ASSERT_NE(service_list.end(), std::find(service_list.begin(), service_list.end(), kBulk));
+ ASSERT_NE(service_list.end(),
+ std::find(service_list.begin(), service_list.end(), kRpc));
+ ASSERT_NE(service_list.end(),
+ std::find(service_list.begin(), service_list.end(), kBulk));
}
}
// Check Service Wrapper
- void CheckServiceExists(const int connectionId, const int session_id,
+ void CheckServiceExists(const int connectionId,
+ const int session_id,
const ::protocol_handler::ServiceType serviceId,
const bool exists) {
// Check all trees to find Service and check own protected value
- const ConnectionList& connection_list = connection_handler_->getConnectionList();
+ const ConnectionList& connection_list =
+ connection_handler_->getConnectionList();
ASSERT_FALSE(connection_list.empty());
ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
ASSERT_NE(conn_it, connection_list.end());
@@ -162,7 +172,8 @@ class ConnectionHandlerTest : public ::testing::Test {
const Session& session = sess_it->second;
const ServiceList& service_list = session.service_list;
ASSERT_FALSE(service_list.empty());
- ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId);
+ ServiceList::const_iterator serv_it =
+ std::find(service_list.begin(), service_list.end(), serviceId);
if (exists) {
ASSERT_NE(serv_it, service_list.end());
} else {
@@ -170,12 +181,14 @@ class ConnectionHandlerTest : public ::testing::Test {
}
}
// Check Service Wrapper
- void CheckService(const int connectionId, const int session_id,
+ void CheckService(const int connectionId,
+ const int session_id,
const ::protocol_handler::ServiceType serviceId,
const ::security_manager::SSLContext* ssl_context,
const bool is_protected) {
// Check all tree to find Service and check own protected value
- const ConnectionList& connection_list = connection_handler_->getConnectionList();
+ const ConnectionList& connection_list =
+ connection_handler_->getConnectionList();
ASSERT_FALSE(connection_list.empty());
ConnectionList::const_iterator conn_it = connection_list.find(connectionId);
ASSERT_NE(conn_it, connection_list.end());
@@ -191,7 +204,8 @@ class ConnectionHandlerTest : public ::testing::Test {
#endif // ENABLE_SECURITY
const ServiceList& service_list = session.service_list;
ASSERT_FALSE(service_list.empty());
- ServiceList::const_iterator serv_it = std::find(service_list.begin(), service_list.end(), serviceId);
+ ServiceList::const_iterator serv_it =
+ std::find(service_list.begin(), service_list.end(), serviceId);
ASSERT_NE(serv_it, service_list.end());
const Service& service = *serv_it;
@@ -199,28 +213,36 @@ class ConnectionHandlerTest : public ::testing::Test {
#ifdef ENABLE_SECURITY
if (is_protected) {
// Emulate success protection - check enable service flag
- const uint32_t connection_key_ = connection_handler_->KeyFromPair(
- connectionId, session_id);
+ const uint32_t connection_key_ =
+ connection_handler_->KeyFromPair(connectionId, session_id);
connection_handler_->SetProtectionFlag(connection_key_, serviceId);
}
#endif // ENABLE_SECURITY
}
- void ChangeProtocol(const int connectionId, const int session_id, const uint8_t protocol_version) {
+ void ChangeProtocol(const int connectionId,
+ const int session_id,
+ const uint8_t protocol_version) {
ConnectionList connection_list = connection_handler_->getConnectionList();
- ConnectionList::const_iterator conn_it = (connection_handler_->getConnectionList()).find(connectionId);
+ ConnectionList::const_iterator conn_it =
+ (connection_handler_->getConnectionList()).find(connectionId);
ASSERT_NE(conn_it, connection_list.end());
- Connection * connection = conn_it->second;
+ Connection* connection = conn_it->second;
ASSERT_TRUE(connection != NULL);
connection->UpdateProtocolVersionSession(session_id, protocol_version);
uint8_t check_protocol_version;
- EXPECT_TRUE(connection->ProtocolVersion(session_id, check_protocol_version));
- EXPECT_EQ(check_protocol_version,protocol_version);
-
+ EXPECT_TRUE(
+ connection->ProtocolVersion(session_id, check_protocol_version));
+ EXPECT_EQ(check_protocol_version, protocol_version);
}
ConnectionHandlerImpl* connection_handler_;
+ testing::NiceMock<transport_manager_test::MockTransportManager>
+ mock_transport_manager;
+ testing::NiceMock<MockConnectionHandlerSettings>
+ mock_connection_handler_settings;
+ protocol_handler_test::MockProtocolHandler mock_protocol_handler_;
transport_manager::DeviceHandle device_handle_;
transport_manager::ConnectionUID uid_;
uint32_t connection_key_;
@@ -231,13 +253,17 @@ class ConnectionHandlerTest : public ::testing::Test {
std::string device_name_;
std::string mac_address_;
+ const uint32_t heartbeat_timeout = 100u;
+ std::vector<int> protected_services_;
+ std::vector<int> unprotected_services_;
};
TEST_F(ConnectionHandlerTest, StartSession_NoConnection) {
// Null sessionId for start new session
const uint8_t sessionID = 0;
// Start new session with RPC service
- const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_);
+ const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(
+ uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_);
// Unknown connection error is '0'
EXPECT_EQ(0u, result_fail);
EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -251,12 +277,23 @@ TEST_F(ConnectionHandlerTest, StartSession) {
AddTestSession();
}
+TEST_F(ConnectionHandlerTest, AddConnection_StopConnection) {
+ // Add virtual device and connection
+ AddTestDeviceConnection();
+ EXPECT_FALSE(connection_handler_->getConnectionList().empty());
+ // Stop connection
+ connection_handler_->Stop();
+ EXPECT_TRUE(connection_handler_->getConnectionList().empty());
+}
+
TEST_F(ConnectionHandlerTest, GetConnectionSessionsCount) {
AddTestDeviceConnection();
- EXPECT_EQ(0u, connection_handler_->GetConnectionSessionsCount(connection_key_));
+ EXPECT_EQ(0u,
+ connection_handler_->GetConnectionSessionsCount(connection_key_));
AddTestSession();
- EXPECT_EQ(1u, connection_handler_->GetConnectionSessionsCount(connection_key_));
+ EXPECT_EQ(1u,
+ connection_handler_->GetConnectionSessionsCount(connection_key_));
}
TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) {
@@ -266,51 +303,82 @@ TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) {
uint32_t app_id = 0;
const uint32_t testid = SessionHash(uid_, start_session_id_);
- EXPECT_EQ(0, connection_handler_->GetDataOnSessionKey(connection_key_, &app_id, NULL, NULL));
+ EXPECT_EQ(0,
+ connection_handler_->GetDataOnSessionKey(
+ connection_key_, &app_id, NULL, NULL));
EXPECT_EQ(testid, app_id);
}
-TEST_F(ConnectionHandlerTest,GetDeviceID) {
+TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey_SessionNotStarted) {
+ AddTestDeviceConnection();
+
+ uint32_t app_id = 0;
+ EXPECT_EQ(-1,
+ connection_handler_->GetDataOnSessionKey(
+ connection_key_, &app_id, NULL, NULL));
+}
+
+TEST_F(ConnectionHandlerTest, GetDeviceID) {
AddTestDeviceConnection();
AddTestSession();
DeviceHandle test_handle;
- const DeviceMap & devmap = connection_handler_->getDeviceList();
+ const DeviceMap& devmap = connection_handler_->getDeviceList();
DeviceMap::const_iterator pos = devmap.find(device_handle_);
ASSERT_NE(pos, devmap.end());
- const Device & devres = pos->second;
+ const Device& devres = pos->second;
std::string test_mac_address = devres.mac_address();
EXPECT_TRUE(connection_handler_->GetDeviceID(test_mac_address, &test_handle));
EXPECT_EQ(device_handle_, test_handle);
}
-TEST_F(ConnectionHandlerTest,GetDeviceName) {
+TEST_F(ConnectionHandlerTest, GetDeviceName) {
AddTestDeviceConnection();
AddTestSession();
std::string test_device_name;
DeviceHandle handle = 0;
- EXPECT_EQ(0, connection_handler_->GetDataOnDeviceID(handle, &test_device_name));
+ EXPECT_EQ(0,
+ connection_handler_->GetDataOnDeviceID(handle, &test_device_name));
EXPECT_EQ(device_name_, test_device_name);
}
-TEST_F(ConnectionHandlerTest,GetConnectionType) {
+TEST_F(ConnectionHandlerTest, GetConnectionType) {
AddTestDeviceConnection();
AddTestSession();
const DeviceHandle handle = 0;
std::string test_connection_type;
- EXPECT_EQ(0, connection_handler_->GetDataOnDeviceID(handle, NULL, NULL, NULL, &test_connection_type));
+ EXPECT_EQ(0,
+ connection_handler_->GetDataOnDeviceID(
+ handle, NULL, NULL, NULL, &test_connection_type));
EXPECT_EQ(connection_type_, test_connection_type);
}
+TEST_F(ConnectionHandlerTest, GetApplicationsOnDevice) {
+ AddTestDeviceConnection();
+ AddTestSession();
+
+ const DeviceHandle handle = 0;
+ std::list<uint32_t> applications_list;
+ EXPECT_EQ(
+ 0,
+ connection_handler_->GetDataOnDeviceID(handle, NULL, &applications_list));
+
+ uint32_t test_id = connection_handler_->KeyFromPair(uid_, start_session_id_);
+ EXPECT_EQ(1u, applications_list.size());
+
+ EXPECT_EQ(test_id, applications_list.front());
+}
+
TEST_F(ConnectionHandlerTest, GetDefaultProtocolVersion) {
AddTestDeviceConnection();
AddTestSession();
uint8_t protocol_version = 0;
- EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version));
+ EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(
+ uid_, start_session_id_, protocol_version));
EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version);
}
@@ -321,7 +389,8 @@ TEST_F(ConnectionHandlerTest, GetProtocolVersion) {
ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3);
uint8_t protocol_version = 0;
- EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version));
+ EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(
+ uid_, start_session_id_, protocol_version));
EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version);
}
@@ -330,12 +399,15 @@ TEST_F(ConnectionHandlerTest, GetProtocolVersionAfterBinding) {
AddTestDeviceConnection();
AddTestSession();
uint8_t protocol_version = 0;
- EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version));
+ EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(
+ uid_, start_session_id_, protocol_version));
EXPECT_EQ(PROTOCOL_VERSION_2, protocol_version);
- connection_handler_->BindProtocolVersionWithSession(connection_key_, PROTOCOL_VERSION_3);
+ connection_handler_->BindProtocolVersionWithSession(connection_key_,
+ PROTOCOL_VERSION_3);
- EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(uid_, start_session_id_, protocol_version));
+ EXPECT_TRUE(connection_handler_->ProtocolVersionUsed(
+ uid_, start_session_id_, protocol_version));
EXPECT_EQ(PROTOCOL_VERSION_3, protocol_version);
}
@@ -353,49 +425,51 @@ TEST_F(ConnectionHandlerTest, GetPairFromKey) {
TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) {
AddTestDeviceConnection();
AddTestSession();
-
ChangeProtocol(uid_, start_session_id_, PROTOCOL_VERSION_3);
- EXPECT_TRUE(connection_handler_->IsHeartBeatSupported(uid_, start_session_id_));
+ EXPECT_TRUE(
+ connection_handler_->IsHeartBeatSupported(uid_, start_session_id_));
}
-TEST_F(ConnectionHandlerTest,SendEndServiceWithoutSetProtocolHandler) {
+TEST_F(ConnectionHandlerTest, SendEndServiceWithoutSetProtocolHandler) {
AddTestDeviceConnection();
AddTestSession();
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
-
- EXPECT_CALL(mock_protocol_handler, SendEndService(_,_,kRpc)).Times(0);
+ EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc)).Times(0);
connection_handler_->SendEndService(connection_key_, kRpc);
}
-TEST_F(ConnectionHandlerTest,SendEndService) {
+TEST_F(ConnectionHandlerTest, SendEndService) {
AddTestDeviceConnection();
AddTestSession();
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
-
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
- EXPECT_CALL(mock_protocol_handler, SendEndService(_,_,kRpc));
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc));
connection_handler_->SendEndService(connection_key_, kRpc);
}
-TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequest) {
+TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequest) {
AddTestDeviceConnection();
AddTestSession();
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest());
connection_handler_->OnFindNewApplicationsRequest();
}
-TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutObserver) {
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest()).Times(0);
+TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequestWithoutObserver) {
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest())
+ .Times(0);
connection_handler_->OnFindNewApplicationsRequest();
}
-TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutSession) {
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+TEST_F(ConnectionHandlerTest, OnFindNewApplicationsRequestWithoutSession) {
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
EXPECT_CALL(mock_connection_handler_observer, OnFindNewApplicationsRequest());
connection_handler_->OnFindNewApplicationsRequest();
@@ -406,18 +480,24 @@ TEST_F(ConnectionHandlerTest, OnMalformedMessageCallback) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kMalformed))
+ .Times(1);
connection_handler_->OnMalformedMessageCallback(uid_);
}
@@ -426,53 +506,288 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
-
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(1);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kCommon));
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kCommon));
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kCommon));
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kCommon));
connection_handler_->OnApplicationFloodCallBack(uid_);
}
+TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack_SessionFound) {
+ // Precondition
+ AddTestDeviceConnection();
+ AddTestSession();
+ AddTestService(kAudio);
+ AddTestService(kMobileNav);
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_));
+ InSequence seq;
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kMobileNav, kFlood));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kAudio, kFlood));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kBulk, kFlood));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kRpc, kFlood));
+
+ connection_handler_->OnApplicationFloodCallBack(connection_key_);
+}
+
TEST_F(ConnectionHandlerTest, StartDevicesDiscovery) {
AddTestDeviceConnection();
AddTestSession();
- transport_manager_test::TransportManagerMock mock_transport_manager;
- connection_handler_->set_transport_manager(&mock_transport_manager);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
EXPECT_CALL(mock_transport_manager, SearchDevices());
EXPECT_CALL(mock_connection_handler_observer, OnDeviceListUpdated(_));
connection_handler_->StartDevicesDiscovery();
}
+MATCHER_P(CheckDevList, check_device_map, "") {
+ DeviceMap device_list = arg;
+ if (device_list.size() != check_device_map.size()) {
+ return false;
+ }
+ DeviceMap::const_iterator it = device_list.begin();
+ DeviceMap::const_iterator end = device_list.end();
+
+ DeviceMap::const_iterator check_it = check_device_map.begin();
+ for (; it != end; ++it, ++check_it) {
+ if (it->first != check_it->first) {
+ return false;
+ }
+ if ((*it).second.device_handle() != (*check_it).second.device_handle()) {
+ return false;
+ }
+ if ((*it).second.mac_address() != (*check_it).second.mac_address()) {
+ return false;
+ }
+ if ((*it).second.connection_type() !=
+ (*check_it).second.connection_type()) {
+ return false;
+ }
+ }
+ return true;
+}
+
+TEST_F(ConnectionHandlerTest, UpdateDeviceList) {
+ // Precondition
+ AddTestDeviceConnection();
+ AddTestSession();
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ connection_type_ = "BTMAC";
+ device_name_ = "test_name";
+ mac_address_ = "test_address";
+ const transport_manager::DeviceInfo added_info(
+ 0, "test_address", "test_name", "BTMAC");
+ connection_handler_->OnDeviceAdded(added_info);
+
+ // Prepare map with DeviceInfo that sets in OnDeviceListUpdated
+ const transport_manager::DeviceInfo unused_parameter(
+ 0, "mac_address_", "device_name_", "connection_type_");
+ std::vector<transport_manager::DeviceInfo> unused_info;
+ unused_info.push_back(unused_parameter);
+ DeviceMap map_with_unused_var;
+ map_with_unused_var.insert(
+ DeviceMap::value_type(unused_parameter.device_handle(),
+ Device(unused_parameter.device_handle(),
+ unused_parameter.name(),
+ unused_parameter.mac_address(),
+ unused_parameter.connection_type())));
+
+ // Only previously added devices is updated
+ EXPECT_CALL(
+ mock_connection_handler_observer,
+ OnDeviceListUpdated(CheckDevList(connection_handler_->getDeviceList())));
+
+ // New value that sets in OnDeviceListUpdated does not add
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnDeviceListUpdated(CheckDevList(map_with_unused_var))).Times(0);
+
+ connection_handler_->OnDeviceListUpdated(unused_info);
+}
+
+TEST_F(ConnectionHandlerTest, GetConnectedDevicesMAC) {
+ // Precondition
+ const std::string mac_address1 = "test_address1";
+ const std::string mac_address2 = "test_address2";
+
+ const transport_manager::DeviceInfo device1(
+ 0, mac_address1, device_name_, connection_type_);
+ const transport_manager::DeviceInfo device2(
+ 1, mac_address2, device_name_, connection_type_);
+ connection_handler_->OnDeviceAdded(device1);
+ connection_handler_->OnDeviceAdded(device2);
+
+ // Expect mac adress was hashed and saved
+ const std::string check_mac1 = encryption::MakeHash(mac_address1);
+ const std::string check_mac2 = encryption::MakeHash(mac_address2);
+ std::vector<std::string> device_macs;
+ connection_handler_->GetConnectedDevicesMAC(device_macs);
+ ASSERT_EQ(2u, device_macs.size());
+ EXPECT_EQ(check_mac1, device_macs.at(0));
+ EXPECT_EQ(check_mac2, device_macs.at(1));
+}
+
TEST_F(ConnectionHandlerTest, StartTransportManager) {
AddTestDeviceConnection();
AddTestSession();
- transport_manager_test::TransportManagerMock mock_transport_manager;
- connection_handler_->set_transport_manager(&mock_transport_manager);
+
EXPECT_CALL(mock_transport_manager, Visibility(true));
connection_handler_->StartTransportManager();
}
+TEST_F(ConnectionHandlerTest, OnDeviceRemoved_ServiceNotStarted) {
+ // Precondition
+ const uint32_t dev_handle1 = 1;
+ const uint32_t dev_handle2 = 2;
+
+ const transport_manager::DeviceInfo device1(
+ dev_handle1, mac_address_, device_name_, connection_type_);
+ const transport_manager::DeviceInfo device2(
+ dev_handle2, mac_address_, device_name_, connection_type_);
+ connection_handler_->OnDeviceAdded(device1);
+ connection_handler_->OnDeviceAdded(device2);
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ EXPECT_CALL(mock_connection_handler_observer, RemoveDevice(dev_handle1));
+ EXPECT_CALL(mock_connection_handler_observer, OnServiceEndedCallback(_, _, _))
+ .Times(0);
+ connection_handler_->OnDeviceRemoved(device1);
+}
+
+TEST_F(ConnectionHandlerTest, OnDeviceRemoved_ServiceStarted) {
+ // Precondition
+ AddTestDeviceConnection();
+ AddTestSession();
+
+ const transport_manager::DeviceInfo device1(
+ device_handle_, mac_address_, device_name_, connection_type_);
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ EXPECT_CALL(mock_connection_handler_observer, RemoveDevice(device_handle_));
+
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kBulk, kCommon));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kRpc, kCommon));
+ connection_handler_->OnDeviceRemoved(device1);
+}
+
+TEST_F(ConnectionHandlerTest, OnConnectionClosed) {
+ AddTestDeviceConnection();
+ AddTestSession();
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kBulk, kCommon));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(connection_key_, kRpc, kCommon));
+
+ connection_handler_->OnConnectionClosed(uid_);
+}
+
+TEST_F(ConnectionHandlerTest, OnUnexpectedDisconnect) {
+ AddTestDeviceConnection();
+ AddTestSession();
+
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+ transport_manager::CommunicationError err;
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(
+ connection_key_, kBulk, CloseSessionReason::kCommon));
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceEndedCallback(
+ connection_key_, kRpc, CloseSessionReason::kCommon));
+
+ connection_handler_->OnUnexpectedDisconnect(uid_, err);
+}
+
+TEST_F(ConnectionHandlerTest, ConnectToDevice) {
+ // Precondition
+ const uint32_t dev_handle1 = 1;
+ const uint32_t dev_handle2 = 2;
+
+ const transport_manager::DeviceInfo device1(
+ dev_handle1, mac_address_, device_name_, connection_type_);
+ const transport_manager::DeviceInfo device2(
+ dev_handle2, mac_address_, device_name_, connection_type_);
+ connection_handler_->OnDeviceAdded(device1);
+ connection_handler_->OnDeviceAdded(device2);
+
+ EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle1))
+ .WillOnce(Return(transport_manager::E_SUCCESS));
+ EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle2)).Times(0);
+ connection_handler_->ConnectToDevice(dev_handle1);
+}
+
+TEST_F(ConnectionHandlerTest, ConnectToAllDevices) {
+ // Precondition
+ const uint32_t dev_handle1 = 1;
+ const uint32_t dev_handle2 = 2;
+
+ const transport_manager::DeviceInfo device1(
+ dev_handle1, mac_address_, device_name_, connection_type_);
+ const transport_manager::DeviceInfo device2(
+ dev_handle2, mac_address_, device_name_, connection_type_);
+ connection_handler_->OnDeviceAdded(device1);
+ connection_handler_->OnDeviceAdded(device2);
+
+ EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle1))
+ .WillOnce(Return(transport_manager::E_SUCCESS));
+ EXPECT_CALL(mock_transport_manager, ConnectDevice(dev_handle2))
+ .WillOnce(Return(transport_manager::E_SUCCESS));
+ connection_handler_->ConnectToAllDevices();
+}
+
TEST_F(ConnectionHandlerTest, CloseConnection) {
AddTestDeviceConnection();
AddTestSession();
- transport_manager_test::TransportManagerMock mock_transport_manager;
- connection_handler_->set_transport_manager(&mock_transport_manager);
+
EXPECT_CALL(mock_transport_manager, DisconnectForce(uid_));
connection_handler_->CloseConnection(uid_);
}
@@ -480,8 +795,7 @@ TEST_F(ConnectionHandlerTest, CloseConnection) {
TEST_F(ConnectionHandlerTest, CloseRevokedConnection) {
AddTestDeviceConnection();
AddTestSession();
- transport_manager_test::TransportManagerMock mock_transport_manager;
- connection_handler_->set_transport_manager(&mock_transport_manager);
+
EXPECT_CALL(mock_transport_manager, DisconnectForce(uid_));
connection_handler_->CloseRevokedConnection(connection_key_);
}
@@ -491,24 +805,27 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
-
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
-
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
-
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(1);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kCommon))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kCommon))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kCommon)).Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kCommon)).Times(1);
connection_handler_->CloseSession(connection_key_, kCommon);
+ Mock::AsyncVerifyAndClearExpectations(10000);
}
TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) {
@@ -516,24 +833,27 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
-
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(1);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kFlood)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kFlood))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kFlood)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kFlood)).Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kFlood)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kFlood)).Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kFlood)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kFlood)).Times(1);
connection_handler_->CloseSession(connection_key_, kFlood);
+ Mock::AsyncVerifyAndClearExpectations(10000);
}
TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) {
@@ -541,24 +861,30 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
-
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0);
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(0);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kMalformed))
+ .Times(1);
connection_handler_->CloseSession(connection_key_, kMalformed);
+ Mock::AsyncVerifyAndClearExpectations(10000);
}
TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) {
@@ -566,24 +892,30 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
-
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0);
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(0);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kMalformed))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kMalformed))
+ .Times(1);
connection_handler_->CloseConnectionSessions(uid_, kMalformed);
+ Mock::AsyncVerifyAndClearExpectations(10000);
}
TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) {
@@ -591,24 +923,28 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) {
AddTestSession();
AddTestService(kAudio);
AddTestService(kMobileNav);
- connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer;
- connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer);
-
- protocol_handler_test::ProtocolHandlerMock mock_protocol_handler;
- connection_handler_->set_protocol_handler(&mock_protocol_handler);
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
- EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_));
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendEndSession(uid_, start_session_id_))
+ .Times(1);
InSequence seq;
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kMobileNav, kCommon))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kAudio, kCommon))
+ .Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kBulk, kCommon)).Times(1);
EXPECT_CALL(mock_connection_handler_observer,
- OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1);
+ OnServiceEndedCallback(connection_key_, kRpc, kCommon)).Times(1);
connection_handler_->CloseConnectionSessions(uid_, kCommon);
+ Mock::AsyncVerifyAndClearExpectations(10000);
}
TEST_F(ConnectionHandlerTest, StartService_withServices) {
@@ -618,7 +954,7 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
// Start Audio service
const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+ uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
EXPECT_EQ(start_session_id_, start_audio);
CheckServiceExists(uid_, start_session_id_, kAudio, true);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
@@ -634,8 +970,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) {
AddTestDeviceConnection();
- const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
- uid_, 0u, 0u, kAudio);
+ const uint32_t end_session_result =
+ connection_handler_->OnSessionEndedCallback(uid_, 0u, 0u, kAudio);
EXPECT_EQ(0u, end_session_result);
CheckSessionExists(uid_, 0);
}
@@ -643,8 +979,9 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) {
TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) {
AddTestDeviceConnection();
AddTestSession();
- const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, 0u, kAudio);
+ const uint32_t end_session_result =
+ connection_handler_->OnSessionEndedCallback(
+ uid_, start_session_id_, 0u, kAudio);
EXPECT_EQ(0u, end_session_result);
CheckServiceExists(uid_, start_session_id_, kAudio, false);
}
@@ -656,12 +993,13 @@ TEST_F(ConnectionHandlerTest, ServiceStop) {
for (uint32_t some_hash_id = 0; some_hash_id < 0xFF; ++some_hash_id) {
// Start audio service
const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+ uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
EXPECT_EQ(start_session_id_, start_audio);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
- const uint32_t end_session_result = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, some_hash_id, kAudio);
+ const uint32_t end_session_result =
+ connection_handler_->OnSessionEndedCallback(
+ uid_, start_session_id_, some_hash_id, kAudio);
EXPECT_EQ(connection_key_, end_session_result);
CheckServiceExists(uid_, start_session_id_, kAudio, false);
}
@@ -675,13 +1013,14 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckHash) {
const uint32_t hash = connection_key_;
const uint32_t wrong_hash = hash + 1;
- const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, wrong_hash, kRpc);
+ const uint32_t end_audio_wrong_hash =
+ connection_handler_->OnSessionEndedCallback(
+ uid_, start_session_id_, wrong_hash, kRpc);
EXPECT_EQ(0u, end_audio_wrong_hash);
CheckSessionExists(uid_, start_session_id_);
const uint32_t end_audio = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, hash, kRpc);
+ uid_, start_session_id_, hash, kRpc);
EXPECT_EQ(connection_key_, end_audio);
CheckSessionExists(uid_, 0);
}
@@ -695,26 +1034,53 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) {
const uint32_t wrong_hash = protocol_handler::HASH_ID_WRONG;
const uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED;
- const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, wrong_hash, kRpc);
+ const uint32_t end_audio_wrong_hash =
+ connection_handler_->OnSessionEndedCallback(
+ uid_, start_session_id_, wrong_hash, kRpc);
EXPECT_EQ(0u, end_audio_wrong_hash);
CheckSessionExists(uid_, start_session_id_);
const uint32_t end_audio = connection_handler_->OnSessionEndedCallback(
- uid_, start_session_id_, hash, kRpc);
+ uid_, start_session_id_, hash, kRpc);
EXPECT_EQ(connection_key_, end_audio);
CheckSessionExists(uid_, 0);
}
}
-TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprotect) {
+TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) {
+ // Add virtual device and connection
+ AddTestDeviceConnection();
+ // Expect that rpc service has started
+ connection_handler_test::ConnectionHandlerObserverMock
+ mock_connection_handler_observer;
+ connection_handler_->set_connection_handler_observer(
+ &mock_connection_handler_observer);
+ uint32_t session_key =
+ connection_handler_->KeyFromPair(uid_, start_session_id_);
+ EXPECT_CALL(mock_connection_handler_observer,
+ OnServiceStartedCallback(device_handle_, session_key, kRpc))
+ .WillOnce(Return(true));
+
+ // Start new session with RPC service
+ uint32_t new_session_id = connection_handler_->OnSessionStartedCallback(
+ uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+
+ EXPECT_NE(0u, new_session_id);
+}
+
+TEST_F(ConnectionHandlerTest,
+ SessionStarted_StartSession_SecureSpecific_Unprotect) {
+ EXPECT_CALL(mock_connection_handler_settings, heart_beat_timeout())
+ .WillOnce(Return(heartbeat_timeout));
// Add virtual device and connection
AddTestDeviceConnection();
// Forbid start kRPC without encryption
- SetSpecificServices("0x07", "");
+ protected_services_.push_back(kRpc);
+ SetSpecificServices();
// Start new session with RPC service
- const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback(
- uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+ const uint32_t session_id_fail =
+ connection_handler_->OnSessionStartedCallback(
+ uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
#ifdef ENABLE_SECURITY
EXPECT_EQ(0u, session_id_fail);
EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -724,23 +1090,31 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprote
#endif // ENABLE_SECURITY
// Allow start kRPC without encryption
- SetSpecificServices("0x00, Non", "");
+ protected_services_.clear();
+ protected_services_.push_back(kControl);
+ SetSpecificServices();
// Start new session with RPC service
const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
- uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+ uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
EXPECT_NE(0u, session_id);
CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF);
EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
}
-TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect) {
+TEST_F(ConnectionHandlerTest,
+ SessionStarted_StartSession_SecureSpecific_Protect) {
// Add virtual device and connection
AddTestDeviceConnection();
// Forbid start kRPC with encryption
- SetSpecificServices("", "0x06, 0x07, 0x08, Non");
+ unprotected_services_.push_back(UnnamedService::kServedService1);
+ unprotected_services_.push_back(kRpc);
+ unprotected_services_.push_back(UnnamedService::kServedService2);
+ unprotected_services_.push_back(kControl);
+ SetSpecificServices();
// Start new session with RPC service
- const uint32_t session_id_fail = connection_handler_->OnSessionStartedCallback(
- uid_, 0, kRpc, PROTECTION_ON, NULL);
+ const uint32_t session_id_fail =
+ connection_handler_->OnSessionStartedCallback(
+ uid_, 0, kRpc, PROTECTION_ON, NULL);
#ifdef ENABLE_SECURITY
EXPECT_EQ(0u, session_id_fail);
#else
@@ -748,10 +1122,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect
#endif // ENABLE_SECURITY
// Allow start kRPC with encryption
- SetSpecificServices("", "0x00, 0x05, Non");
+ unprotected_services_.clear();
+ unprotected_services_.push_back(kControl);
+ SetSpecificServices();
// Start new session with RPC service
const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
- uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_);
+ uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_);
EXPECT_NE(0u, session_id);
EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
@@ -759,67 +1135,75 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect
CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF);
}
-TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprotect) {
+TEST_F(ConnectionHandlerTest,
+ SessionStarted_StartService_SecureSpecific_Unprotect) {
AddTestDeviceConnection();
AddTestSession();
- // Audio is 0x0A
- ASSERT_EQ(0x0A, kAudio);
-
// Forbid start kAudio without encryption
- SetSpecificServices("0x06, 0x0A, 0x08, Non", "");
+ protected_services_.push_back(UnnamedService::kServedService1);
+ protected_services_.push_back(kAudio);
+ protected_services_.push_back(UnnamedService::kServedService2);
+ protected_services_.push_back(kControl);
+ SetSpecificServices();
// Start new session with Audio service
const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
+ uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
#ifdef ENABLE_SECURITY
EXPECT_EQ(0u, session_id2);
#else
EXPECT_EQ(1u, session_id2);
#endif // ENABLE_SECURITY
// Allow start kAudio without encryption
- SetSpecificServices("0x06, 0x0B, 0x08, Non", "");
+ protected_services_.clear();
+ protected_services_.push_back(UnnamedService::kServedService1);
+ protected_services_.push_back(kMobileNav);
+ protected_services_.push_back(UnnamedService::kServedService2);
+ protected_services_.push_back(kControl);
+ SetSpecificServices();
const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
- // Returned original session id
+ uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+// Returned original session id
#ifdef ENABLE_SECURITY
EXPECT_EQ(start_session_id_, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
- CheckService(uid_, session_id3, kRpc,
- NULL,
- PROTECTION_OFF);
+ CheckService(uid_, session_id3, kRpc, NULL, PROTECTION_OFF);
#else
EXPECT_EQ(0u, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
#endif // ENABLE_SECURITY
}
-TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect) {
+TEST_F(ConnectionHandlerTest,
+ SessionStarted_StartService_SecureSpecific_Protect) {
AddTestDeviceConnection();
AddTestSession();
- // Audio is 0x0A
- ASSERT_EQ(0x0A, kAudio);
// Forbid start kAudio with encryption
- SetSpecificServices("", "0x06, 0x0A, 0x08, Non");
+ unprotected_services_.push_back(UnnamedService::kServedService1);
+ unprotected_services_.push_back(kAudio);
+ unprotected_services_.push_back(UnnamedService::kServedService2);
+ unprotected_services_.push_back(kControl);
+ SetSpecificServices();
// Start new session with Audio service
- const uint32_t session_id_reject = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
+ const uint32_t session_id_reject =
+ connection_handler_->OnSessionStartedCallback(
+ uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
#ifdef ENABLE_SECURITY
EXPECT_EQ(0u, session_id_reject);
#else
EXPECT_EQ(1u, session_id_reject);
#endif // ENABLE_SECURITY
// Allow start kAudio with encryption
- SetSpecificServices("", "Non");
+ unprotected_services_.clear();
+ SetSpecificServices();
const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
- // Returned original session id
+ uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
+// Returned original session id
#ifdef ENABLE_SECURITY
EXPECT_EQ(start_session_id_, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
- CheckService(uid_, session_id3, kAudio,
- NULL,
- PROTECTION_ON);
+ CheckService(uid_, session_id3, kAudio, NULL, PROTECTION_ON);
#else
EXPECT_EQ(0u, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -833,14 +1217,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) {
// Start RPC protection
const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_);
+ uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_);
#ifdef ENABLE_SECURITY
EXPECT_EQ(start_session_id_, session_id_new);
// Post protection nedd no hash
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
- CheckService(uid_, start_session_id_, kRpc,
- NULL,
- PROTECTION_ON);
+ CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON);
#else
EXPECT_EQ(0u, session_id_new);
// Post protection nedd no hash
@@ -850,20 +1232,18 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) {
// Start Audio session without protection
const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+ uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
EXPECT_EQ(start_session_id_, session_id2);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF);
// Start Audio protection
const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
+ uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
#ifdef ENABLE_SECURITY
EXPECT_EQ(start_session_id_, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
- CheckService(uid_, start_session_id_, kAudio,
- NULL,
- PROTECTION_ON);
+ CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_ON);
#else
EXPECT_EQ(0u, session_id3);
EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -876,12 +1256,10 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) {
AddTestSession();
const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
- uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
+ uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
#ifdef ENABLE_SECURITY
EXPECT_EQ(start_session_id_, session_id_new);
- CheckService(uid_, start_session_id_, kRpc,
- NULL,
- PROTECTION_ON);
+ CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_ON);
#else
EXPECT_EQ(0u, session_id_new);
CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF);
@@ -892,40 +1270,41 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) {
TEST_F(ConnectionHandlerTest, SetSSLContext_Null) {
// No SSLContext on start up
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL,
- connection_handler_->SetSSLContext(connection_key_, NULL));
+ connection_handler_->SetSSLContext(connection_key_, NULL));
// No SSLContext after error
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
AddTestDeviceConnection();
EXPECT_EQ(::security_manager::SecurityManager::ERROR_INTERNAL,
- connection_handler_->SetSSLContext(connection_key_, NULL));
+ connection_handler_->SetSSLContext(connection_key_, NULL));
// No SSLContext after error
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
AddTestSession();
EXPECT_EQ(::security_manager::SecurityManager::ERROR_SUCCESS,
- connection_handler_->SetSSLContext(connection_key_, NULL));
+ connection_handler_->SetSSLContext(connection_key_, NULL));
// NULL SSLContext after success
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
}
+
TEST_F(ConnectionHandlerTest, SetSSLContext) {
// No SSLContext on start up
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
- testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
+ testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context;
// Error on no connection
EXPECT_EQ(
connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
::security_manager::SecurityManager::ERROR_INTERNAL);
// No SSLContext after error
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
AddTestDeviceConnection();
// Error on no session
@@ -934,7 +1313,7 @@ TEST_F(ConnectionHandlerTest, SetSSLContext) {
::security_manager::SecurityManager::ERROR_INTERNAL);
// No SSLContext after error
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
AddTestSession();
// Success
EXPECT_EQ(
@@ -942,24 +1321,24 @@ TEST_F(ConnectionHandlerTest, SetSSLContext) {
::security_manager::SecurityManager::ERROR_SUCCESS);
// SSLContext set on Success
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- &mock_ssl_context);
+ &mock_ssl_context);
// Null SSLContext for unprotected services
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kMobileNav),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
}
TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) {
// No SSLContext on start up
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
- testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
+ testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context;
AddTestDeviceConnection();
AddTestSession();
EXPECT_EQ(
@@ -967,11 +1346,11 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) {
::security_manager::SecurityManager::ERROR_SUCCESS);
// kControl service mean - return for all connection
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- &mock_ssl_context);
+ &mock_ssl_context);
// kAudio is not exists yet
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
// Open kAudio service
const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
@@ -980,21 +1359,22 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) {
// kAudio is not exists yet
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
- &mock_ssl_context);
+ &mock_ssl_context);
}
+
TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) {
- testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
+ testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context;
AddTestDeviceConnection();
AddTestSession();
EXPECT_EQ(
connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
::security_manager::SecurityManager::ERROR_SUCCESS);
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- &mock_ssl_context);
+ &mock_ssl_context);
// kRpc is not protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
// Protect kRpc (Bulk will be protect also)
const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
@@ -1004,24 +1384,25 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) {
// kRpc is protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
- &mock_ssl_context);
+ &mock_ssl_context);
// kBulk is protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
- &mock_ssl_context);
+ &mock_ssl_context);
}
+
TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) {
- testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context;
+ testing::StrictMock<security_manager_test::MockSSLContext> mock_ssl_context;
AddTestDeviceConnection();
AddTestSession();
EXPECT_EQ(
connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context),
::security_manager::SecurityManager::ERROR_SUCCESS);
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl),
- &mock_ssl_context);
+ &mock_ssl_context);
// kRpc is not protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
- reinterpret_cast<security_manager::SSLContext *>(NULL));
+ reinterpret_cast<security_manager::SSLContext*>(NULL));
// Protect Bulk (kRpc will be protected also)
const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
@@ -1031,13 +1412,22 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) {
// kRpc is protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
- &mock_ssl_context);
+ &mock_ssl_context);
// kBulk is protected
EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk),
- &mock_ssl_context);
+ &mock_ssl_context);
}
#endif // ENABLE_SECURITY
-} // namespace connection_handle_test
+TEST_F(ConnectionHandlerTest, SendHeartBeat) {
+ // Add virtual device and connection
+ AddTestDeviceConnection();
+ AddTestSession();
+ connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+ EXPECT_CALL(mock_protocol_handler_, SendHeartBeat(uid_, start_session_id_));
+ connection_handler_->SendHeartBeat(uid_, start_session_id_);
+}
+
+} // namespace connection_handler_test
} // namespace components
} // namespace test
diff --git a/src/components/connection_handler/test/connection_test.cc b/src/components/connection_handler/test/connection_test.cc
index a1e9307ce3..e36e9aa65c 100644
--- a/src/components/connection_handler/test/connection_test.cc
+++ b/src/components/connection_handler/test/connection_test.cc
@@ -30,14 +30,18 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include <gtest/gtest.h>
#include <algorithm>
+
+#include "gtest/gtest.h"
+
#include "protocol/common.h"
#include "connection_handler/connection.h"
#include "connection_handler/connection_handler_impl.h"
#include "protocol/service_type.h"
-#include "utils/shared_ptr.h"
-#include "security_manager_mock.h"
+#include "connection_handler/mock_connection_handler_settings.h"
+#include "transport_manager/mock_transport_manager.h"
+#include "security_manager/mock_security_manager.h"
+#include "security_manager/mock_ssl_context.h"
#define EXPECT_RETURN_TRUE true
#define EXPECT_RETURN_FALSE false
@@ -46,24 +50,25 @@
namespace test {
namespace components {
-namespace connection_handle {
+namespace connection_handler_test {
using namespace ::connection_handler;
using namespace ::protocol_handler;
class ConnectionTest : public ::testing::Test {
protected:
void SetUp() OVERRIDE {
- connection_handler_ = ConnectionHandlerImpl::instance();
+ connection_handler_ = new ConnectionHandlerImpl(
+ mock_connection_handler_settings, transport_manager_mock);
const ConnectionHandle connectionHandle = 0;
- const DeviceHandle device_handle = 0;
- connection_.reset(
- new Connection(connectionHandle, device_handle, connection_handler_,
- 10000));
+ const DeviceHandle device_handle = 0u;
+ const uint32_t heart_beat = 10000u;
+ connection_ = new Connection(
+ connectionHandle, device_handle, connection_handler_, heart_beat);
}
void TearDown() OVERRIDE {
- connection_.reset();
- ConnectionHandlerImpl::destroy();
+ delete connection_;
+ delete connection_handler_;
}
void StartSession() {
session_id = connection_->AddNewSession();
@@ -72,17 +77,17 @@ class ConnectionTest : public ::testing::Test {
EXPECT_FALSE(sessionMap.empty());
const ServiceList serviceList = sessionMap.begin()->second.service_list;
EXPECT_FALSE(serviceList.empty());
- const ServiceList::const_iterator it = std::find(serviceList.begin(),
- serviceList.end(),
- protocol_handler::kRpc);
- EXPECT_NE(it, serviceList.end());
+ const ServiceList::const_iterator it =
+ std::find(serviceList.begin(), serviceList.end(), kRpc);
+ const bool found_result = (it != serviceList.end());
+ EXPECT_TRUE(found_result);
}
- void AddNewService(const protocol_handler::ServiceType service_type,
+ void AddNewService(const ServiceType service_type,
const bool protection,
const bool expect_add_new_service_call_result,
const bool expect_exist_service) {
- const bool result = connection_->AddNewService(session_id, service_type,
- protection);
+ const bool result =
+ connection_->AddNewService(session_id, service_type, protection);
EXPECT_EQ(result, expect_add_new_service_call_result);
#ifdef ENABLE_SECURITY
@@ -94,9 +99,8 @@ class ConnectionTest : public ::testing::Test {
EXPECT_FALSE(session_map.empty());
const ServiceList newServiceList = session_map.begin()->second.service_list;
EXPECT_FALSE(newServiceList.empty());
- const ServiceList::const_iterator it = std::find(newServiceList.begin(),
- newServiceList.end(),
- service_type);
+ const ServiceList::const_iterator it =
+ std::find(newServiceList.begin(), newServiceList.end(), service_type);
const bool found_result = it != newServiceList.end();
EXPECT_EQ(expect_exist_service, found_result);
#ifdef ENABLE_SECURITY
@@ -107,7 +111,7 @@ class ConnectionTest : public ::testing::Test {
#endif // ENABLE_SECURITY
}
- void RemoveService(const protocol_handler::ServiceType service_type,
+ void RemoveService(const ServiceType service_type,
const bool expect_remove_service_result,
const bool expect_exist_service) {
const bool result = connection_->RemoveService(session_id, service_type);
@@ -115,22 +119,23 @@ class ConnectionTest : public ::testing::Test {
const SessionMap newSessionMap = connection_->session_map();
EXPECT_FALSE(newSessionMap.empty());
- const ServiceList newServiceList = newSessionMap.begin()->second
- .service_list;
+ const ServiceList newServiceList =
+ newSessionMap.begin()->second.service_list;
EXPECT_FALSE(newServiceList.empty());
- const ServiceList::const_iterator it = std::find(newServiceList.begin(),
- newServiceList.end(),
- service_type);
- const bool found_result = it != newServiceList.end();
+ const ServiceList::const_iterator it =
+ std::find(newServiceList.begin(), newServiceList.end(), service_type);
+ const bool found_result = (it != newServiceList.end());
EXPECT_EQ(expect_exist_service, found_result);
}
- ::utils::SharedPtr<Connection> connection_;
+ Connection* connection_;
+ MockConnectionHandlerSettings mock_connection_handler_settings;
+ testing::StrictMock<transport_manager_test::MockTransportManager>
+ transport_manager_mock;
ConnectionHandlerImpl* connection_handler_;
uint32_t session_id;
};
-
TEST_F(ConnectionTest, Session_TryGetProtocolVersionWithoutSession) {
uint8_t protocol_version;
EXPECT_FALSE(connection_->ProtocolVersion(session_id, protocol_version));
@@ -140,14 +145,14 @@ TEST_F(ConnectionTest, Session_GetDefaultProtocolVersion) {
StartSession();
uint8_t protocol_version;
EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
- EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2);
+ EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_2), protocol_version);
}
TEST_F(ConnectionTest, Session_UpdateProtocolVersion) {
StartSession();
- uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3;
+ uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_3);
connection_->UpdateProtocolVersionSession(session_id, protocol_version);
EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
- EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3);
+ EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_3), protocol_version);
}
TEST_F(ConnectionTest, HeartBeat_NotSupported) {
@@ -155,44 +160,64 @@ TEST_F(ConnectionTest, HeartBeat_NotSupported) {
StartSession();
uint8_t protocol_version;
EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version));
- EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2);
+ EXPECT_EQ(static_cast<uint8_t>(PROTOCOL_VERSION_2), protocol_version);
// Assert
EXPECT_FALSE(connection_->SupportHeartBeat(session_id));
}
-TEST_F(ConnectionTest, DISABLED_HeartBeat_Supported) {
+TEST_F(ConnectionTest, HeartBeat_Protocol3_Supported) {
// Arrange
StartSession();
-
- // Check if protocol version is 3
- uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3;
+ // Check execution if protocol version is 3
+ const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_3);
connection_->UpdateProtocolVersionSession(session_id, protocol_version);
- EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3);
+ EXPECT_TRUE(connection_->SupportHeartBeat(session_id));
+}
- // Assert
+TEST_F(ConnectionTest, HeartBeat_Protocol4_PositiveHeartBeat_Supported) {
+ // Arrange
+ StartSession();
+ // Check execution if protocol version is 4
+ const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_4);
+ connection_->UpdateProtocolVersionSession(session_id, protocol_version);
EXPECT_TRUE(connection_->SupportHeartBeat(session_id));
}
+TEST_F(ConnectionTest, HeartBeat_Protocol4_ZeroHeartBeat_NotSupported) {
+ // Correctc of connection (need connection with heartbeat=0)
+ delete connection_;
+ connection_ = 0;
+
+ const ConnectionHandle connectionHandle = 0;
+ const DeviceHandle device_handle = 0u;
+ const uint32_t heart_beat = 0u;
+ connection_ = new Connection(
+ connectionHandle, device_handle, connection_handler_, heart_beat);
+ StartSession();
+ // Check execution if protocol version is 4
+ const uint8_t protocol_version = static_cast<uint8_t>(PROTOCOL_VERSION_4);
+ connection_->UpdateProtocolVersionSession(session_id, protocol_version);
+ EXPECT_FALSE(connection_->SupportHeartBeat(session_id));
+}
+
// Try to add service without session
TEST_F(ConnectionTest, Session_AddNewServiceWithoutSession) {
- EXPECT_EQ(
- connection_->AddNewService(session_id, protocol_handler::kAudio, true),
- EXPECT_RETURN_FALSE);
- EXPECT_EQ(
- connection_->AddNewService(session_id, protocol_handler::kAudio, false),
- EXPECT_RETURN_FALSE);
- EXPECT_EQ(
- connection_->AddNewService(session_id, protocol_handler::kMobileNav, true),
- EXPECT_RETURN_FALSE);
- EXPECT_EQ(
- connection_->AddNewService(session_id, protocol_handler::kMobileNav, false),
- EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->AddNewService(session_id, kAudio, true),
+ EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->AddNewService(session_id, kAudio, false),
+ EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->AddNewService(session_id, kMobileNav, true),
+ EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->AddNewService(session_id, kMobileNav, false),
+ EXPECT_RETURN_FALSE);
}
// Try to remove service without session
TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) {
- EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
+ EXPECT_EQ(connection_->RemoveService(session_id, kAudio),
+ EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->RemoveService(session_id, kMobileNav),
EXPECT_RETURN_FALSE);
EXPECT_EQ(
connection_->RemoveService(session_id, protocol_handler::kMobileNav),
@@ -201,70 +226,67 @@ TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) {
// Try to remove RPC
TEST_F(ConnectionTest, Session_RemoveRPCBulk) {
StartSession();
- EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kRpc),
- EXPECT_RETURN_FALSE);
- EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kBulk),
- EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->RemoveService(session_id, kRpc), EXPECT_RETURN_FALSE);
+ EXPECT_EQ(connection_->RemoveService(session_id, kBulk), EXPECT_RETURN_FALSE);
}
// Control Service could not be started anyway
TEST_F(ConnectionTest, Session_AddControlService) {
StartSession();
-
- AddNewService(protocol_handler::kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE,
- EXPECT_SERVICE_NOT_EXISTS);
- AddNewService(protocol_handler::kControl, PROTECTION_ON, EXPECT_RETURN_FALSE,
- EXPECT_SERVICE_NOT_EXISTS);
+ AddNewService(
+ kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
+ AddNewService(
+ kControl, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
}
// Invalid Services couldnot be started anyway
TEST_F(ConnectionTest, Session_AddInvalidService) {
StartSession();
- AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_OFF,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
- AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS);
+ AddNewService(kInvalidServiceType,
+ PROTECTION_OFF,
+ EXPECT_RETURN_FALSE,
+ EXPECT_SERVICE_NOT_EXISTS);
+ AddNewService(kInvalidServiceType,
+ PROTECTION_ON,
+ EXPECT_RETURN_FALSE,
+ EXPECT_SERVICE_NOT_EXISTS);
}
// RPC and Bulk Services could be only delay protected
TEST_F(ConnectionTest, Session_AddRPCBulkServices) {
StartSession();
- AddNewService(protocol_handler::kRpc, PROTECTION_OFF,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kRpc, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
// Bulk shall not be added and shall be PROTECTION_OFF
- AddNewService(protocol_handler::kBulk, PROTECTION_OFF,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kBulk, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
#ifdef ENABLE_SECURITY
- AddNewService(protocol_handler::kRpc, PROTECTION_ON,
- EXPECT_RETURN_TRUE,
- EXPECT_SERVICE_EXISTS);
+ AddNewService(kRpc, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#else
- AddNewService(protocol_handler::kRpc, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kRpc, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
#endif // ENABLE_SECURITY
// Bulk shall not be added and shall be PROTECTION_ON
- AddNewService(protocol_handler::kBulk, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kBulk, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
}
TEST_F(ConnectionTest, Session_AddAllOtherService_Unprotected) {
StartSession();
-
- AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
}
TEST_F(ConnectionTest, Session_AddAllOtherService_Protected) {
StartSession();
-
- AddNewService(protocol_handler::kAudio, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
}
TEST_F(ConnectionTest, FindAddedService) {
@@ -272,82 +294,79 @@ TEST_F(ConnectionTest, FindAddedService) {
// Arrange
SessionMap currentSessionMap = connection_->session_map();
- Service * sessionWithService = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kAudio);
+ Service* sessionWithService =
+ currentSessionMap.find(session_id)->second.FindService(kAudio);
EXPECT_EQ(NULL, sessionWithService);
// Act
- AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
currentSessionMap = connection_->session_map();
// Expect that service is existing
- sessionWithService = currentSessionMap.find(session_id)->second.FindService(
- protocol_handler::kAudio);
+ sessionWithService =
+ currentSessionMap.find(session_id)->second.FindService(kAudio);
EXPECT_TRUE(sessionWithService != NULL);
}
TEST_F(ConnectionTest, Session_RemoveAddedService) {
StartSession();
- AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
- EXPECT_RETURN_TRUE);
+ EXPECT_EQ(connection_->RemoveService(session_id, kAudio), EXPECT_RETURN_TRUE);
// Try delete nonexisting service
- EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio),
+ EXPECT_EQ(connection_->RemoveService(session_id, kAudio),
EXPECT_RETURN_FALSE);
}
TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected1) {
StartSession();
- AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#ifdef ENABLE_SECURITY
- AddNewService(protocol_handler::kAudio, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#else
- AddNewService(protocol_handler::kAudio, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
#endif // ENABLE_SECURITY
}
// Use other order
TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected2) {
StartSession();
-
- AddNewService(protocol_handler::kAudio, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#ifdef ENABLE_SECURITY
- AddNewService(protocol_handler::kAudio, PROTECTION_ON,
- EXPECT_RETURN_TRUE,
- EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#else
- AddNewService(protocol_handler::kAudio, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kAudio, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
#endif // ENABLE_SECURITY
- AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_OFF, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#ifdef ENABLE_SECURITY
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
#else
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS);
#endif // ENABLE_SECURITY
}
@@ -360,86 +379,84 @@ TEST_F(ConnectionTest, RemoveSession) {
#ifdef ENABLE_SECURITY
TEST_F(ConnectionTest, SetSSLContextWithoutSession) {
- //random value. Session was not started
+ // random value. Session was not started
uint8_t session_id = 10;
- security_manager_test::SSLContextMock mock_ssl_context;
+ security_manager_test::MockSSLContext mock_ssl_context;
int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context);
- EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL,setResult);
+ EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL, setResult);
}
TEST_F(ConnectionTest, GetSSLContextWithoutSession) {
- //random value. Session was not started
+ // random value. Session was not started
uint8_t session_id = 10;
- EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
+ EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav));
}
TEST_F(ConnectionTest, SetGetSSLContext) {
StartSession();
- EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
- AddNewService(protocol_handler::kMobileNav, PROTECTION_ON,
- EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
+ EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav));
+ AddNewService(
+ kMobileNav, PROTECTION_ON, EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS);
- EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::kMobileNav));
+ EXPECT_EQ(NULL, connection_->GetSSLContext(session_id, kMobileNav));
- security_manager_test::SSLContextMock mock_ssl_context;
- //Set SSLContext
+ security_manager_test::MockSSLContext mock_ssl_context;
+ // Set SSLContext
int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context);
- EXPECT_EQ(security_manager::SecurityManager::ERROR_SUCCESS,setResult);
+ EXPECT_EQ(security_manager::SecurityManager::ERROR_SUCCESS, setResult);
- security_manager::SSLContext *result = connection_->GetSSLContext(session_id,protocol_handler::kMobileNav);
- EXPECT_EQ(result,&mock_ssl_context);
+ security_manager::SSLContext* result =
+ connection_->GetSSLContext(session_id, kMobileNav);
+ EXPECT_EQ(result, &mock_ssl_context);
}
TEST_F(ConnectionTest, SetProtectionFlagForRPC) {
StartSession();
// Arrange
SessionMap currentSessionMap = connection_->session_map();
- Service * service_rpc = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kRpc);
+ Service* service_rpc =
+ currentSessionMap.find(session_id)->second.FindService(kRpc);
EXPECT_FALSE(service_rpc->is_protected_);
- Service * service_bulk = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kBulk);
+ Service* service_bulk =
+ currentSessionMap.find(session_id)->second.FindService(kBulk);
EXPECT_FALSE(service_bulk->is_protected_);
// Expect that service protection is enabled
- connection_->SetProtectionFlag(session_id, protocol_handler::kRpc);
+ connection_->SetProtectionFlag(session_id, kRpc);
currentSessionMap = connection_->session_map();
- service_bulk = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kBulk);
+ service_bulk = currentSessionMap.find(session_id)->second.FindService(kBulk);
EXPECT_TRUE(service_bulk->is_protected_);
- service_rpc = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kRpc);
+ service_rpc = currentSessionMap.find(session_id)->second.FindService(kRpc);
EXPECT_TRUE(service_rpc->is_protected_);
}
-
TEST_F(ConnectionTest, SetProtectionFlagForBulk) {
StartSession();
// Arrange
SessionMap currentSessionMap = connection_->session_map();
- Service * service_rpc = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kRpc);
+ Service* service_rpc =
+ currentSessionMap.find(session_id)->second.FindService(kRpc);
EXPECT_FALSE(service_rpc->is_protected_);
- Service * service_bulk = currentSessionMap.find(session_id)->second
- .FindService(protocol_handler::kBulk);
+ Service* service_bulk =
+ currentSessionMap.find(session_id)->second.FindService(kBulk);
EXPECT_FALSE(service_bulk->is_protected_);
// Expect that service protection is enabled
- connection_->SetProtectionFlag(session_id, protocol_handler::kBulk);
+ connection_->SetProtectionFlag(session_id, kBulk);
currentSessionMap = connection_->session_map();
- service_bulk = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kBulk);
+ service_bulk = currentSessionMap.find(session_id)->second.FindService(kBulk);
EXPECT_TRUE(service_bulk->is_protected_);
- service_rpc = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kRpc);
+ service_rpc = currentSessionMap.find(session_id)->second.FindService(kRpc);
EXPECT_TRUE(service_rpc->is_protected_);
}
@@ -448,4 +465,3 @@ TEST_F(ConnectionTest, SetProtectionFlagForBulk) {
} // namespace connection_handle
} // namespace components
} // namespace test
-
diff --git a/src/components/connection_handler/test/device_test.cc b/src/components/connection_handler/test/device_test.cc
index dc1a51faf1..ea9aa746b5 100644
--- a/src/components/connection_handler/test/device_test.cc
+++ b/src/components/connection_handler/test/device_test.cc
@@ -55,7 +55,8 @@ TEST(ConnectionDevice, CompareDevicesWithDifferentMacAddresses) {
std::string hash_mac_address = test_device.mac_address();
std::string test_next_mac_address = "test_address_";
- Device next_test_device(device_handle, device_name, test_next_mac_address, connection_type);
+ Device next_test_device(
+ device_handle, device_name, test_next_mac_address, connection_type);
EXPECT_NE(test_next_mac_address, next_test_device.mac_address());
std::string hash_next_mac_address = next_test_device.mac_address();
@@ -77,4 +78,3 @@ TEST(ConnectionDevice, MacAddressHash) {
} // namespace connection_handle
} // namespace components
} // namespace test
-
diff --git a/src/components/connection_handler/test/heart_beat_monitor_test.cc b/src/components/connection_handler/test/heart_beat_monitor_test.cc
index 710977c643..2c928fe458 100644
--- a/src/components/connection_handler/test/heart_beat_monitor_test.cc
+++ b/src/components/connection_handler/test/heart_beat_monitor_test.cc
@@ -32,12 +32,11 @@
#include <string>
#include <iostream>
-//#include <stdio.h>
-#include "gmock/gmock.h"
+#include "gtest/gtest.h"
#include "connection_handler/heartbeat_monitor.h"
#include "connection_handler/connection.h"
#include "connection_handler/connection_handler.h"
-#include "config_profile/profile.h"
+#include "connection_handler/mock_connection_handler.h"
namespace {
const int32_t MILLISECONDS_IN_SECOND = 1000;
@@ -50,91 +49,42 @@ namespace components {
namespace connection_handler_test {
using ::testing::_;
-class ConnectionHandlerMock : public connection_handler::ConnectionHandler {
+class HeartBeatMonitorTest : public testing::Test {
public:
- MOCK_METHOD1(set_connection_handler_observer,
- void(connection_handler::ConnectionHandlerObserver*));
- MOCK_METHOD1(set_transport_manager,
- void(transport_manager::TransportManager*));
- MOCK_METHOD0(StartTransportManager,
- void());
- MOCK_METHOD1(ConnectToDevice,
- void(connection_handler::DeviceHandle device_handle));
- MOCK_METHOD0(ConnectToAllDevices,
- void());
- MOCK_METHOD1(CloseRevokedConnection, void(uint32_t connection_key));
- MOCK_METHOD1(CloseConnection,
- void(connection_handler::ConnectionHandle connection_handle));
- MOCK_METHOD1(GetConnectionSessionsCount, uint32_t(uint32_t connection_key));
- MOCK_METHOD2(GetDeviceID,
- bool(const std::string& mac_address,
- connection_handler::DeviceHandle* device_handle));
- MOCK_CONST_METHOD1(GetConnectedDevicesMAC, void(std::vector<std::string> &device_macs));
- MOCK_METHOD2(CloseSession,
- void(uint32_t key,
- connection_handler::CloseSessionReason close_reason));
- MOCK_METHOD3(CloseSession,
- void(connection_handler::ConnectionHandle connection_handle,
- uint8_t session_id,
- connection_handler::CloseSessionReason close_reason));
- MOCK_METHOD2(SendEndService,
- void(uint32_t key, uint8_t service_type));
-
- MOCK_METHOD1(StartSessionHeartBeat,
- void(uint32_t key));
- MOCK_METHOD2(SendHeartBeat,
- void(connection_handler::ConnectionHandle connection_handle,
- uint8_t session_id));
- MOCK_METHOD2(SetHeartBeatTimeout, void(uint32_t connection_key,
- uint32_t timeout));
- MOCK_METHOD2(BindProtocolVersionWithSession,
- void(uint32_t connection_key,
- uint8_t protocol_version));
- MOCK_METHOD4(GetDataOnSessionKey,
- int32_t(uint32_t key, uint32_t* app_id,
- std::list<int32_t>* sessions_list,
- uint32_t* device_id));
-};
+ HeartBeatMonitorTest() : conn(NULL) {
+ kTimeout = 5000u;
+ }
-class HeartBeatMonitorTest : public testing::Test {
-public:
- HeartBeatMonitorTest():
- conn(NULL) {
- profile::Profile::instance()->config_file_name("smartDeviceLink.ini");
- kTimeout = profile::Profile::instance()->heart_beat_timeout();
- }
-
-protected:
- testing::NiceMock<ConnectionHandlerMock> connection_handler_mock;
+ protected:
+ testing::NiceMock<MockConnectionHandler> connection_handler_mock;
connection_handler::Connection* conn;
uint32_t kTimeout;
- static const connection_handler::ConnectionHandle kConnectionHandle = 0xABCDEF;
+ static const connection_handler::ConnectionHandle kConnectionHandle =
+ 0xABCDEF;
virtual void SetUp() {
- conn = new connection_handler::Connection(kConnectionHandle, 0,
- &connection_handler_mock,
- kTimeout);
+ conn = new connection_handler::Connection(
+ kConnectionHandle, 0, &connection_handler_mock, kTimeout);
}
- virtual void TearDown() {
+ void TearDown() OVERRIDE {
delete conn;
}
-
};
-ACTION_P2(RemoveSession, conn, session_id){
+ACTION_P2(RemoveSession, conn, session_id) {
conn->RemoveSession(session_id);
}
TEST_F(HeartBeatMonitorTest, TimerNotStarted) {
-
- // Whithout StartHeartBeat nothing to be call
+ // Whithout StartHeartBeat nothing to be call
EXPECT_CALL(connection_handler_mock, CloseSession(_, _)).Times(0);
EXPECT_CALL(connection_handler_mock, CloseConnection(_)).Times(0);
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0);
conn->AddNewSession();
- usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
+ testing::Mock::AsyncVerifyAndClearExpectations(
+ kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
}
TEST_F(HeartBeatMonitorTest, TimerNotElapsed) {
@@ -144,19 +94,21 @@ TEST_F(HeartBeatMonitorTest, TimerNotElapsed) {
const uint32_t session = conn->AddNewSession();
conn->StartHeartBeat(session);
- usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
+ testing::Mock::AsyncVerifyAndClearExpectations(
+ kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND);
}
TEST_F(HeartBeatMonitorTest, TimerElapsed) {
const uint32_t session = conn->AddNewSession();
- EXPECT_CALL(connection_handler_mock, CloseSession(_, session,_))
- .WillOnce(RemoveSession(conn, session));
+ EXPECT_CALL(connection_handler_mock, CloseSession(_, session, _))
+ .WillOnce(RemoveSession(conn, session));
EXPECT_CALL(connection_handler_mock, CloseConnection(_));
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session));
conn->StartHeartBeat(session);
- usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
+ testing::Mock::AsyncVerifyAndClearExpectations(
+ 2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
}
TEST_F(HeartBeatMonitorTest, KeptAlive) {
@@ -179,8 +131,8 @@ TEST_F(HeartBeatMonitorTest, NotKeptAlive) {
const uint32_t session = conn->AddNewSession();
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session));
- EXPECT_CALL(connection_handler_mock, CloseSession(_, session,_))
- .WillOnce(RemoveSession(conn, session));
+ EXPECT_CALL(connection_handler_mock, CloseSession(_, session, _))
+ .WillOnce(RemoveSession(conn, session));
EXPECT_CALL(connection_handler_mock, CloseConnection(_));
conn->StartHeartBeat(session);
@@ -197,17 +149,18 @@ TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) {
const uint32_t kSession1 = conn->AddNewSession();
const uint32_t kSession2 = conn->AddNewSession();
- EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession1,_))
- .WillOnce(RemoveSession(conn, kSession1));
- EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession2,_))
- .WillOnce(RemoveSession(conn, kSession2));
+ EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession1, _))
+ .WillOnce(RemoveSession(conn, kSession1));
+ EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession2, _))
+ .WillOnce(RemoveSession(conn, kSession2));
EXPECT_CALL(connection_handler_mock, CloseConnection(_));
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession1));
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession2));
conn->StartHeartBeat(kSession1);
conn->StartHeartBeat(kSession2);
- usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
+ testing::Mock::AsyncVerifyAndClearExpectations(
+ 2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND);
}
TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) {
@@ -217,19 +170,19 @@ TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) {
EXPECT_CALL(connection_handler_mock, CloseConnection(_)).Times(0);
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0);
-
const uint32_t kNewTimeout = kTimeout + MICROSECONDS_IN_MILLISECONDS;
conn->StartHeartBeat(kSession);
conn->SetHeartBeatTimeout(kNewTimeout, kSession);
// new timeout greater by old timeout so mock object shouldn't be invoked
- usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS);
+ testing::Mock::AsyncVerifyAndClearExpectations(kTimeout *
+ MICROSECONDS_IN_MILLISECONDS);
}
TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) {
const uint32_t kSession = conn->AddNewSession();
- EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession,_))
- .WillOnce(RemoveSession(conn, kSession));
+ EXPECT_CALL(connection_handler_mock, CloseSession(_, kSession, _))
+ .WillOnce(RemoveSession(conn, kSession));
EXPECT_CALL(connection_handler_mock, CloseConnection(_));
EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, kSession));
@@ -237,9 +190,10 @@ TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) {
conn->StartHeartBeat(kSession);
conn->SetHeartBeatTimeout(kNewTimeout, kSession);
// new timeout less than old timeout so mock object should be invoked
- usleep(kTimeout * 2 * MICROSECONDS_IN_MILLISECONDS);
+ testing::Mock::AsyncVerifyAndClearExpectations(kTimeout * 2 *
+ MICROSECONDS_IN_MILLISECONDS);
}
-} // namespace connection_handler_test
-} // namespace components
-} // namespace test
+} // namespace connection_handler_test
+} // namespace components
+} // namespace test
diff --git a/src/components/connection_handler/test/include/connection_handler_observer_mock.h b/src/components/connection_handler/test/include/connection_handler/connection_handler_observer_mock.h
index 9a74375262..aa22f1aa1c 100644
--- a/src/components/connection_handler/test/include/connection_handler_observer_mock.h
+++ b/src/components/connection_handler/test/include/connection_handler/connection_handler_observer_mock.h
@@ -33,7 +33,7 @@
#ifndef SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
#define SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
-#include <gmock/gmock.h>
+#include "gmock/gmock.h"
#include <string>
#include "connection_handler/connection_handler_observer.h"
@@ -42,29 +42,31 @@ namespace components {
namespace connection_handler_test {
/*
- * MOCK implementation of ::connection_handler::ConnectionHandlerObserver interface
+ * MOCK implementation of ::connection_handler::ConnectionHandlerObserver
+ * interface
*/
-class ConnectionHandlerObserverMock : public ::connection_handler::ConnectionHandlerObserver {
+class ConnectionHandlerObserverMock
+ : public ::connection_handler::ConnectionHandlerObserver {
public:
MOCK_METHOD1(OnDeviceListUpdated,
- void(const connection_handler::DeviceMap &device_list));
- MOCK_METHOD0(OnFindNewApplicationsRequest,void());
+ void(const connection_handler::DeviceMap& device_list));
+ MOCK_METHOD0(OnFindNewApplicationsRequest, void());
MOCK_METHOD1(RemoveDevice,
- void(const connection_handler::DeviceHandle &device_handle));
+ void(const connection_handler::DeviceHandle& device_handle));
MOCK_METHOD3(OnServiceStartedCallback,
- bool(const connection_handler::DeviceHandle &device_handle,
- const int32_t &session_key,
- const protocol_handler::ServiceType &type));
- MOCK_METHOD3(OnServiceEndedCallback,
- void(const int32_t &session_key,
- const protocol_handler::ServiceType &type,
+ bool(const connection_handler::DeviceHandle& device_handle,
+ const int32_t& session_key,
+ const protocol_handler::ServiceType& type));
+ MOCK_METHOD3(
+ OnServiceEndedCallback,
+ void(const int32_t& session_key,
+ const protocol_handler::ServiceType& type,
const connection_handler::CloseSessionReason& close_reason));
- MOCK_CONST_METHOD1(GetHandshakeContext,
- security_manager::SSLContext::HandshakeContext(
- uint32_t key));
-
+ MOCK_CONST_METHOD1(
+ GetHandshakeContext,
+ security_manager::SSLContext::HandshakeContext(uint32_t key));
};
-} // namespace connection_handler_test
-} // namespace components
-} // namespace test
-#endif //SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
+} // namespace connection_handler_test
+} // namespace components
+} // namespace test
+#endif // SRC_COMPONENTS_CONNECTION_HANDLER_TEST_INCLUDE_CONNECTION_HANDLER_OBSERVER_MOCK_H_
View Lorry Controller Status