diff options
author | iAndrew5 <abyzhynar@luxoft.com> | 2015-10-20 18:18:38 +0300 |
---|---|---|
committer | iAndrew5 <abyzhynar@luxoft.com> | 2015-10-20 18:18:38 +0300 |
commit | 790208669af77d4da040922283c2644dfab4f457 (patch) | |
tree | c671d2100f4c4d3358da76e79df5b2780dd7c5cd /src/components/connection_handler/test | |
parent | 13fd07953c463a8d035df130bf1713ee6508d7d8 (diff) | |
download | sdl_core-790208669af77d4da040922283c2644dfab4f457.tar.gz |
Moved, Enabled and partially refactored Unit tests
Diffstat (limited to 'src/components/connection_handler/test')
7 files changed, 740 insertions, 350 deletions
diff --git a/src/components/connection_handler/test/CMakeLists.txt b/src/components/connection_handler/test/CMakeLists.txt index f98c03391d..7c0e1b2a98 100644 --- a/src/components/connection_handler/test/CMakeLists.txt +++ b/src/components/connection_handler/test/CMakeLists.txt @@ -36,18 +36,24 @@ 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 ) set(LIBRARIES gmock connectionHandler ConfigProfile + ProtocolHandler + TransportManager ) set(SOURCES #connection_handler_impl_test.cc connection_test.cc + device_test.cc #heart_beat_monitor_test.cc ) 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 8d2e9b6a07..94e4c816fa 100644 --- a/src/components/connection_handler/test/connection_handler_impl_test.cc +++ b/src/components/connection_handler/test/connection_handler_impl_test.cc @@ -38,6 +38,9 @@ #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" namespace test { namespace components { @@ -46,52 +49,66 @@ namespace connection_handle_test { using namespace ::connection_handler; using ::protocol_handler::ServiceType; using namespace ::protocol_handler; +using ::testing::_; +using ::testing::InSequence; // For service types and PROTECTION_ON/OFF class ConnectionHandlerTest : public ::testing::Test { protected: void SetUp() OVERRIDE { connection_handler_ = ConnectionHandlerImpl::instance(); - uid = 1u; - connection_key = connection_handler_->KeyFromPair(0, 0u); + uid_ = 1u; + connection_key_ = connection_handler_->KeyFromPair(0, 0u); } void TearDown() OVERRIDE { ConnectionHandlerImpl::destroy(); } // Additional SetUp void AddTestDeviceConnection() { - const transport_manager::DeviceHandle device_handle = 0; - const transport_manager::DeviceInfo device_info(device_handle, - std::string("test_address"), - std::string("test_name"), - std::string("BTMAC")); + device_handle_ = 0; + + connection_type_ = "BTMAC"; + device_name_ = "test_name"; + mac_address_ = "test_address"; + + const transport_manager::DeviceInfo device_info(device_handle_, + mac_address_, + device_name_, + connection_type_); // Add Device and connection - connection_handler_->addDeviceConnection(device_info, uid); - connection_key = connection_handler_->KeyFromPair(uid, 0u); + 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); - 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); - CheckSessionExists(uid, start_session_id); + start_session_id_ = connection_handler_->OnSessionStartedCallback( + 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_); + CheckSessionExists(uid_, start_session_id_); } uint32_t SessionHash(const uint32_t connection, const uint32_t session) { return connection_handler_->KeyFromPair(connection, session); } + void AddTestService(ServiceType service_type) { + 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_); + CheckSessionExists(uid_, start_session_id_); + uint32_t session_id = connection_handler_->OnSessionStartedCallback( + uid_, start_session_id_, service_type, PROTECTION_OFF, 0); + EXPECT_EQ(session_id, start_session_id_); + } // Additional SetUp - void SetSpecificServices(const std::string& protect, - const std::string& not_protect) { + 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 + 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 @@ -105,8 +122,7 @@ class ConnectionHandlerTest : public ::testing::Test { // 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()); @@ -123,10 +139,8 @@ 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)); } } @@ -135,8 +149,7 @@ class ConnectionHandlerTest : public ::testing::Test { 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()); @@ -149,9 +162,7 @@ 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 { @@ -164,8 +175,7 @@ class ConnectionHandlerTest : public ::testing::Test { 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()); @@ -181,9 +191,7 @@ 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; @@ -191,31 +199,51 @@ 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( + const uint32_t connection_key_ = connection_handler_->KeyFromPair( connectionId, session_id); - connection_handler_->SetProtectionFlag(connection_key, serviceId); + connection_handler_->SetProtectionFlag(connection_key_, serviceId); } #endif // ENABLE_SECURITY } + 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); + ASSERT_NE(conn_it, connection_list.end()); + 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); + + } + ConnectionHandlerImpl* connection_handler_; - transport_manager::ConnectionUID uid; - uint32_t connection_key; - uint32_t start_session_id; - uint32_t out_hash_id; + transport_manager::DeviceHandle device_handle_; + transport_manager::ConnectionUID uid_; + uint32_t connection_key_; + uint32_t start_session_id_; + uint32_t out_hash_id_; + + std::string connection_type_; + std::string device_name_; + std::string mac_address_; + }; 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); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); ASSERT_TRUE(connection_handler_->getConnectionList().empty()); } + TEST_F(ConnectionHandlerTest, StartSession) { // Add virtual device and connection AddTestDeviceConnection(); @@ -238,7 +266,7 @@ 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)); + EXPECT_EQ(0, connection_handler_->GetDataOnSessionKey(connection_key_, &app_id, NULL, NULL)); EXPECT_EQ(testid, app_id); } @@ -376,17 +404,28 @@ TEST_F(ConnectionHandlerTest,OnFindNewApplicationsRequestWithoutSession) { TEST_F(ConnectionHandlerTest, OnMalformedMessageCallback) { AddTestDeviceConnection(); AddTestSession(); + AddTestService(kAudio); + AddTestService(kMobileNav); 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); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2); + OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); connection_handler_->OnMalformedMessageCallback(uid_); } TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) { AddTestDeviceConnection(); AddTestSession(); + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -394,8 +433,16 @@ TEST_F(ConnectionHandlerTest, OnApplicationFloodCallBack) { 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, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2); + OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); connection_handler_->OnApplicationFloodCallBack(uid_); } @@ -442,7 +489,8 @@ TEST_F(ConnectionHandlerTest, CloseRevokedConnection) { TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) { AddTestDeviceConnection(); AddTestSession(); - + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -450,16 +498,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithCommonReason) { connection_handler_->set_protocol_handler(&mock_protocol_handler); EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); - EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); connection_handler_->CloseSession(connection_key_, kCommon); } TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) { AddTestDeviceConnection(); AddTestSession(); - + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -467,16 +523,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithFloodReason) { connection_handler_->set_protocol_handler(&mock_protocol_handler); EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); - EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kFlood)).Times(2); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kMobileNav, kFlood)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kFlood)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kBulk, kFlood)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kFlood)).Times(1); connection_handler_->CloseSession(connection_key_, kFlood); } TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) { AddTestDeviceConnection(); AddTestSession(); - + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -484,16 +548,24 @@ TEST_F(ConnectionHandlerTest, CloseSessionWithMalformedMessage) { connection_handler_->set_protocol_handler(&mock_protocol_handler); EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0); - EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); connection_handler_->CloseSession(connection_key_, kMalformed); } TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) { AddTestDeviceConnection(); AddTestSession(); - + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -501,16 +573,24 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithMalformedMessage) { connection_handler_->set_protocol_handler(&mock_protocol_handler); EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)).Times(0); - EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kMalformed)).Times(2); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kMobileNav, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kBulk, kMalformed)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kMalformed)).Times(1); connection_handler_->CloseConnectionSessions(uid_, kMalformed); } TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) { AddTestDeviceConnection(); AddTestSession(); - + AddTestService(kAudio); + AddTestService(kMobileNav); connection_handler_test::ConnectionHandlerObserverMock mock_connection_handler_observer; connection_handler_->set_connection_handler_observer(&mock_connection_handler_observer); @@ -518,9 +598,16 @@ TEST_F(ConnectionHandlerTest, CloseConnectionSessionsWithCommonReason) { connection_handler_->set_protocol_handler(&mock_protocol_handler); EXPECT_CALL(mock_protocol_handler, SendEndSession(uid_,start_session_id_)); - EXPECT_CALL(mock_connection_handler_observer, - OnServiceEndedCallback(connection_key_,_, kCommon)).Times(2); + InSequence seq; + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kMobileNav, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kAudio, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kBulk, kCommon)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(connection_key_,kRpc, kCommon)).Times(1); connection_handler_->CloseConnectionSessions(uid_, kCommon); } @@ -531,35 +618,35 @@ 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); - 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); + 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_); // Start Audio service const uint32_t start_video = connection_handler_->OnSessionStartedCallback( - uid, start_session_id, kMobileNav, PROTECTION_OFF, &out_hash_id); - EXPECT_EQ(start_session_id, start_video); - CheckServiceExists(uid, start_session_id, kMobileNav, true); - EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id); + uid_, start_session_id_, kMobileNav, PROTECTION_OFF, &out_hash_id_); + EXPECT_EQ(start_session_id_, start_video); + CheckServiceExists(uid_, start_session_id_, kMobileNav, true); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); } 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); + CheckSessionExists(uid_, 0); } 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); + CheckServiceExists(uid_, start_session_id_, kAudio, false); } TEST_F(ConnectionHandlerTest, ServiceStop) { @@ -569,14 +656,14 @@ 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); - 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); - EXPECT_EQ(connection_key, end_session_result); - CheckServiceExists(uid, start_session_id, kAudio, false); + 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); + EXPECT_EQ(connection_key_, end_session_result); + CheckServiceExists(uid_, start_session_id_, kAudio, false); } } @@ -585,18 +672,18 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckHash) { for (uint32_t session = 0; session < 0xFF; ++session) { AddTestSession(); - const uint32_t hash = connection_key; + 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); + CheckSessionExists(uid_, start_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid, start_session_id, hash, kRpc); - EXPECT_EQ(connection_key, end_audio); - CheckSessionExists(uid, 0); + uid_, start_session_id_, hash, kRpc); + EXPECT_EQ(connection_key_, end_audio); + CheckSessionExists(uid_, 0); } } @@ -608,15 +695,15 @@ 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); + CheckSessionExists(uid_, start_session_id_); const uint32_t end_audio = connection_handler_->OnSessionEndedCallback( - uid, start_session_id, hash, kRpc); - EXPECT_EQ(connection_key, end_audio); - CheckSessionExists(uid, 0); + uid_, start_session_id_, hash, kRpc); + EXPECT_EQ(connection_key_, end_audio); + CheckSessionExists(uid_, 0); } } @@ -626,28 +713,24 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprote // Forbid start kRPC without encryption SetSpecificServices("0x07", ""); // 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); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); #else EXPECT_EQ(1u, session_id_fail); - EXPECT_EQ(SessionHash(uid, session_id_fail), out_hash_id); + EXPECT_EQ(SessionHash(uid_, session_id_fail), out_hash_id_); #endif // ENABLE_SECURITY // Allow start kRPC without encryption SetSpecificServices("0x00, Non", ""); // 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); + CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); + EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); } TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect) { @@ -656,9 +739,8 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect // Forbid start kRPC with encryption SetSpecificServices("", "0x06, 0x07, 0x08, Non"); // 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 @@ -669,14 +751,12 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Protect SetSpecificServices("", "0x00, 0x05, Non"); // 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); + EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_); // Protection steal FALSE because of APPlink Protocol implementation - CheckService(uid, session_id, kRpc, - NULL, - PROTECTION_OFF); + CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF); } TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprotect) { @@ -690,7 +770,7 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprote SetSpecificServices("0x06, 0x0A, 0x08, Non", ""); // 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 @@ -699,17 +779,17 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Unprote // Allow start kAudio without encryption SetSpecificServices("0x06, 0x0B, 0x08, Non", ""); const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback( - uid, start_session_id, kAudio, PROTECTION_OFF, &out_hash_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); + 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); #else EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); #endif // ENABLE_SECURITY } @@ -722,9 +802,8 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect // Forbid start kAudio with encryption SetSpecificServices("", "0x06, 0x0A, 0x08, Non"); // 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 @@ -733,20 +812,18 @@ TEST_F(ConnectionHandlerTest, SessionStarted_StartService_SecureSpecific_Protect // Allow start kAudio with encryption SetSpecificServices("", "Non"); 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_); // 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); + 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); #else EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id); - CheckService(uid, start_session_id, kAudio, - NULL, - PROTECTION_OFF); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); #endif // ENABLE_SECURITY } @@ -756,47 +833,41 @@ 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); + 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); + EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_); + CheckService(uid_, start_session_id_, kRpc, + NULL, + PROTECTION_ON); #else EXPECT_EQ(0u, session_id_new); - // Post protection nedd no hash - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id); - CheckService(uid, start_session_id, kRpc, - NULL, - PROTECTION_OFF); + // Post protection nedd no hash + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF); #endif // ENABLE_SECURITY // Start Audio session without protection const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback( - 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); + 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); + 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); #else EXPECT_EQ(0u, session_id3); - EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id); - CheckService(uid, start_session_id, kAudio, - NULL, - PROTECTION_OFF); + EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_); + CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF); #endif // ENABLE_SECURITY } @@ -805,169 +876,168 @@ 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); + EXPECT_EQ(start_session_id_, session_id_new); + 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); + CheckService(uid_, start_session_id_, kRpc, NULL, PROTECTION_OFF); #endif // ENABLE_SECURITY } #ifdef ENABLE_SECURITY TEST_F(ConnectionHandlerTest, SetSSLContext_Null) { // No SSLContext on start up - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + reinterpret_cast<security_manager::SSLContext *>(NULL)); testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; // Error on no connection EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + reinterpret_cast<security_manager::SSLContext *>(NULL)); AddTestDeviceConnection(); // Error on no session EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + reinterpret_cast<security_manager::SSLContext *>(NULL)); AddTestSession(); // Success EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); // SSLContext set on Success - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + &mock_ssl_context); // Null SSLContext for unprotected services - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk), - reinterpret_cast<security_manager::SSLContext *>(NULL)); - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio), - reinterpret_cast<security_manager::SSLContext *>(NULL)); - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kMobileNav), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), + reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), + reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), + reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kMobileNav), + 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)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + reinterpret_cast<security_manager::SSLContext *>(NULL)); testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); // kControl service mean - return for all connection - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + &mock_ssl_context); // kAudio is not exists yet - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), + 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); - EXPECT_EQ(session_id, start_session_id); - CheckService(uid, session_id, kAudio, &mock_ssl_context, PROTECTION_ON); + uid_, start_session_id_, kAudio, PROTECTION_ON, NULL); + EXPECT_EQ(session_id, start_session_id_); + CheckService(uid_, session_id, kAudio, &mock_ssl_context, PROTECTION_ON); // kAudio is not exists yet - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kAudio), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio), + &mock_ssl_context); } -TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtecteRPC) { +TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) { testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + &mock_ssl_context); // kRpc is not protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), + reinterpret_cast<security_manager::SSLContext *>(NULL)); // Protect kRpc (Bulk will be protect also) const uint32_t session_id = connection_handler_->OnSessionStartedCallback( - uid, start_session_id, kRpc, PROTECTION_ON, NULL); - EXPECT_EQ(start_session_id, session_id); - CheckService(uid, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); + uid_, start_session_id_, kRpc, PROTECTION_ON, NULL); + EXPECT_EQ(start_session_id_, session_id); + CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); // kRpc is protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), + &mock_ssl_context); // kBulk is protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), + &mock_ssl_context); } -TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtecteBulk) { +TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) { testing::StrictMock<security_manager_test::SSLContextMock> mock_ssl_context; AddTestDeviceConnection(); AddTestSession(); EXPECT_EQ( - connection_handler_->SetSSLContext(connection_key, &mock_ssl_context), + connection_handler_->SetSSLContext(connection_key_, &mock_ssl_context), ::security_manager::SecurityManager::ERROR_SUCCESS); - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kControl), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kControl), + &mock_ssl_context); // kRpc is not protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc), - reinterpret_cast<security_manager::SSLContext *>(NULL)); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), + reinterpret_cast<security_manager::SSLContext *>(NULL)); // Protect Bulk (kRpc will be protected also) const uint32_t session_id = connection_handler_->OnSessionStartedCallback( - uid, start_session_id, kBulk, PROTECTION_ON, NULL); - EXPECT_EQ(start_session_id, session_id); - CheckService(uid, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); + uid_, start_session_id_, kBulk, PROTECTION_ON, NULL); + EXPECT_EQ(start_session_id_, session_id); + CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON); // kRpc is protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kRpc), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc), + &mock_ssl_context); // kBulk is protected - EXPECT_EQ(connection_handler_->GetSSLContext(connection_key, kBulk), - &mock_ssl_context); + EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kBulk), + &mock_ssl_context); } #endif // ENABLE_SECURITY + } // namespace connection_handle_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 9462f039c9..a1e9307ce3 100644 --- a/src/components/connection_handler/test/connection_test.cc +++ b/src/components/connection_handler/test/connection_test.cc @@ -37,6 +37,7 @@ #include "connection_handler/connection_handler_impl.h" #include "protocol/service_type.h" #include "utils/shared_ptr.h" +#include "security_manager_mock.h" #define EXPECT_RETURN_TRUE true #define EXPECT_RETURN_FALSE false @@ -46,17 +47,18 @@ namespace test { namespace components { namespace connection_handle { - using namespace ::connection_handler; - using namespace ::protocol_handler; +using namespace ::connection_handler; +using namespace ::protocol_handler; -class ConnectionTest: public ::testing::Test { +class ConnectionTest : public ::testing::Test { protected: void SetUp() OVERRIDE { connection_handler_ = ConnectionHandlerImpl::instance(); const ConnectionHandle connectionHandle = 0; const DeviceHandle device_handle = 0; - connection_.reset(new Connection(connectionHandle, device_handle, - connection_handler_, 10000)); + connection_.reset( + new Connection(connectionHandle, device_handle, connection_handler_, + 10000)); } void TearDown() OVERRIDE { @@ -70,16 +72,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); + const ServiceList::const_iterator it = std::find(serviceList.begin(), + serviceList.end(), + protocol_handler::kRpc); EXPECT_NE(it, serviceList.end()); } void AddNewService(const protocol_handler::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 protection, + const bool expect_add_new_service_call_result, + const bool expect_exist_service) { + const bool result = connection_->AddNewService(session_id, service_type, + protection); EXPECT_EQ(result, expect_add_new_service_call_result); #ifdef ENABLE_SECURITY @@ -91,8 +94,9 @@ 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 @@ -106,16 +110,17 @@ class ConnectionTest: public ::testing::Test { void RemoveService(const protocol_handler::ServiceType service_type, const bool expect_remove_service_result, const bool expect_exist_service) { - const bool result = connection_-> - RemoveService(session_id, service_type); + const bool result = connection_->RemoveService(session_id, service_type); EXPECT_EQ(result, expect_remove_service_result); 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 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); } @@ -125,50 +130,89 @@ class ConnectionTest: public ::testing::Test { uint32_t session_id; }; + +TEST_F(ConnectionTest, Session_TryGetProtocolVersionWithoutSession) { + uint8_t protocol_version; + EXPECT_FALSE(connection_->ProtocolVersion(session_id, protocol_version)); +} + +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); +} +TEST_F(ConnectionTest, Session_UpdateProtocolVersion) { + StartSession(); + uint8_t protocol_version = ::protocol_handler::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); +} + +TEST_F(ConnectionTest, HeartBeat_NotSupported) { + // Arrange + StartSession(); + uint8_t protocol_version; + EXPECT_TRUE(connection_->ProtocolVersion(session_id, protocol_version)); + EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_2); + + // Assert + EXPECT_FALSE(connection_->SupportHeartBeat(session_id)); +} + +TEST_F(ConnectionTest, DISABLED_HeartBeat_Supported) { + // Arrange + StartSession(); + + // Check if protocol version is 3 + uint8_t protocol_version = ::protocol_handler::PROTOCOL_VERSION_3; + connection_->UpdateProtocolVersionSession(session_id, protocol_version); + EXPECT_EQ(protocol_version, ::protocol_handler::PROTOCOL_VERSION_3); + + // Assert + EXPECT_TRUE(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, 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); } // Try to remove service without session TEST_F(ConnectionTest, Session_RemoveServiceWithoutSession) { - EXPECT_EQ(connection_-> - RemoveService(session_id, protocol_handler::kAudio), - EXPECT_RETURN_FALSE); - EXPECT_EQ(connection_-> - RemoveService(session_id, protocol_handler::kMobileNav), + EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), EXPECT_RETURN_FALSE); + EXPECT_EQ( + connection_->RemoveService(session_id, protocol_handler::kMobileNav), + EXPECT_RETURN_FALSE); } // Try to remove RPC TEST_F(ConnectionTest, Session_RemoveRPCBulk) { StartSession(); - EXPECT_EQ(connection_-> - RemoveService(session_id, protocol_handler::kRpc), + EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kRpc), EXPECT_RETURN_FALSE); - EXPECT_EQ(connection_-> - RemoveService(session_id, protocol_handler::kBulk), + EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::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, + AddNewService(protocol_handler::kControl, PROTECTION_OFF, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); - AddNewService(protocol_handler::kControl, PROTECTION_ON, - EXPECT_RETURN_FALSE, + AddNewService(protocol_handler::kControl, PROTECTION_ON, EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); } @@ -177,89 +221,107 @@ TEST_F(ConnectionTest, Session_AddInvalidService) { StartSession(); AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_OFF, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_NOT_EXISTS); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_NOT_EXISTS); AddNewService(protocol_handler::kInvalidServiceType, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_NOT_EXISTS); + 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); + 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); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY AddNewService(protocol_handler::kRpc, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, + EXPECT_SERVICE_EXISTS); #else AddNewService(protocol_handler::kRpc, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_EXISTS); + 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); + 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); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + 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); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); +} + +TEST_F(ConnectionTest, FindAddedService) { + StartSession(); + + // Arrange + SessionMap currentSessionMap = connection_->session_map(); + Service * sessionWithService = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::kAudio); + EXPECT_EQ(NULL, sessionWithService); + + // Act + AddNewService(protocol_handler::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); + EXPECT_TRUE(sessionWithService != NULL); +} + +TEST_F(ConnectionTest, Session_RemoveAddedService) { + StartSession(); + AddNewService(protocol_handler::kAudio, PROTECTION_OFF, + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); + + EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), + EXPECT_RETURN_TRUE); + + // Try delete nonexisting service + EXPECT_EQ(connection_->RemoveService(session_id, protocol_handler::kAudio), + EXPECT_RETURN_FALSE); } TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected1) { StartSession(); AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY } @@ -268,32 +330,121 @@ TEST_F(ConnectionTest, Session_AddAllOtherService_DelayProtected2) { StartSession(); AddNewService(protocol_handler::kAudio, PROTECTION_OFF, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, + EXPECT_SERVICE_EXISTS); #else AddNewService(protocol_handler::kAudio, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY AddNewService(protocol_handler::kMobileNav, PROTECTION_OFF, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #ifdef ENABLE_SECURITY AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_TRUE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_TRUE, EXPECT_SERVICE_EXISTS); #else AddNewService(protocol_handler::kMobileNav, PROTECTION_ON, - EXPECT_RETURN_FALSE, - EXPECT_SERVICE_EXISTS); + EXPECT_RETURN_FALSE, EXPECT_SERVICE_EXISTS); #endif // ENABLE_SECURITY } +TEST_F(ConnectionTest, RemoveSession) { + StartSession(); + EXPECT_EQ(session_id, connection_->RemoveSession(session_id)); + EXPECT_EQ(0u, connection_->RemoveSession(session_id)); +} + +#ifdef ENABLE_SECURITY + +TEST_F(ConnectionTest, SetSSLContextWithoutSession) { + //random value. Session was not started + uint8_t session_id = 10; + security_manager_test::SSLContextMock mock_ssl_context; + int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context); + EXPECT_EQ(security_manager::SecurityManager::ERROR_INTERNAL,setResult); +} + +TEST_F(ConnectionTest, GetSSLContextWithoutSession) { + //random value. Session was not started + uint8_t session_id = 10; + + EXPECT_EQ(NULL,connection_->GetSSLContext(session_id,protocol_handler::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,protocol_handler::kMobileNav)); + + security_manager_test::SSLContextMock mock_ssl_context; + //Set SSLContext + int setResult = connection_->SetSSLContext(session_id, &mock_ssl_context); + 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); +} + +TEST_F(ConnectionTest, SetProtectionFlagForRPC) { + StartSession(); + // Arrange + SessionMap currentSessionMap = connection_->session_map(); + Service * service_rpc = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::kRpc); + + EXPECT_FALSE(service_rpc->is_protected_); + + Service * service_bulk = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::kBulk); + EXPECT_FALSE(service_bulk->is_protected_); + + // Expect that service protection is enabled + connection_->SetProtectionFlag(session_id, protocol_handler::kRpc); + + currentSessionMap = connection_->session_map(); + service_bulk = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::kBulk); + EXPECT_TRUE(service_bulk->is_protected_); + + service_rpc = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::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); + + EXPECT_FALSE(service_rpc->is_protected_); + + Service * service_bulk = currentSessionMap.find(session_id)->second + .FindService(protocol_handler::kBulk); + EXPECT_FALSE(service_bulk->is_protected_); + + // Expect that service protection is enabled + connection_->SetProtectionFlag(session_id, protocol_handler::kBulk); + + currentSessionMap = connection_->session_map(); + service_bulk = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kBulk); + EXPECT_TRUE(service_bulk->is_protected_); + + service_rpc = currentSessionMap.find(session_id)->second.FindService(protocol_handler::kRpc); + EXPECT_TRUE(service_rpc->is_protected_); +} + +#endif // ENABLE_SECURITY + } // 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 new file mode 100644 index 0000000000..dc1a51faf1 --- /dev/null +++ b/src/components/connection_handler/test/device_test.cc @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2015, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include <gtest/gtest.h> +#include "encryption/hashing.h" +#include "connection_handler/device.h" + +namespace test { +namespace components { +namespace connection_handle { + +using namespace connection_handler; +TEST(ConnectionDevice, CompareDevicesWithDifferentMacAddresses) { + DeviceHandle device_handle = 0; + + std::string connection_type = "BTMAC"; + std::string device_name = "test_name"; + std::string mac_address = "test_address"; + + Device test_device(device_handle, device_name, mac_address, connection_type); + + EXPECT_EQ(device_handle, test_device.device_handle()); + EXPECT_EQ(device_name, test_device.user_friendly_name()); + EXPECT_NE(mac_address, test_device.mac_address()); + EXPECT_EQ(connection_type, test_device.connection_type()); + 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); + EXPECT_NE(test_next_mac_address, next_test_device.mac_address()); + std::string hash_next_mac_address = next_test_device.mac_address(); + + EXPECT_NE(hash_mac_address, hash_next_mac_address); +} + +TEST(ConnectionDevice, MacAddressHash) { + DeviceHandle device_handle = 0; + std::string connection_type = "BTMAC"; + std::string device_name = "test_name"; + std::string mac_address = "test_address"; + + Device test_device(device_handle, device_name, mac_address, connection_type); + + std::string hashed_mac_address = encryption::MakeHash(mac_address); + EXPECT_EQ(hashed_mac_address, test_device.mac_address()); +} + +} // 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 f4a1708de5..710977c643 100644 --- a/src/components/connection_handler/test/heart_beat_monitor_test.cc +++ b/src/components/connection_handler/test/heart_beat_monitor_test.cc @@ -31,6 +31,7 @@ */ #include <string> +#include <iostream> //#include <stdio.h> #include "gmock/gmock.h" #include "connection_handler/heartbeat_monitor.h" @@ -38,6 +39,12 @@ #include "connection_handler/connection_handler.h" #include "config_profile/profile.h" +namespace { +const int32_t MILLISECONDS_IN_SECOND = 1000; +const int32_t MICROSECONDS_IN_MILLISECONDS = 1000; +const int32_t MICROSECONDS_IN_SECOND = 1000 * 1000; +} + namespace test { namespace components { namespace connection_handler_test { @@ -62,6 +69,7 @@ class ConnectionHandlerMock : public connection_handler::ConnectionHandler { 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)); @@ -78,10 +86,14 @@ class ConnectionHandlerMock : public connection_handler::ConnectionHandler { void(connection_handler::ConnectionHandle connection_handle, uint8_t session_id)); MOCK_METHOD2(SetHeartBeatTimeout, void(uint32_t connection_key, - int32_t timeout)); + 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)); }; class HeartBeatMonitorTest : public testing::Test { @@ -95,7 +107,7 @@ public: protected: testing::NiceMock<ConnectionHandlerMock> connection_handler_mock; connection_handler::Connection* conn; - int32_t kTimeout; + uint32_t kTimeout; static const connection_handler::ConnectionHandle kConnectionHandle = 0xABCDEF; virtual void SetUp() { @@ -122,7 +134,7 @@ TEST_F(HeartBeatMonitorTest, TimerNotStarted) { EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0); conn->AddNewSession(); - sleep(kTimeout + 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, TimerNotElapsed) { @@ -132,7 +144,7 @@ TEST_F(HeartBeatMonitorTest, TimerNotElapsed) { const uint32_t session = conn->AddNewSession(); conn->StartHeartBeat(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, TimerElapsed) { @@ -144,7 +156,7 @@ TEST_F(HeartBeatMonitorTest, TimerElapsed) { EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, session)); conn->StartHeartBeat(session); - sleep(2 * kTimeout + 1); + usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, KeptAlive) { @@ -154,13 +166,13 @@ TEST_F(HeartBeatMonitorTest, KeptAlive) { const uint32_t session = conn->AddNewSession(); conn->StartHeartBeat(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, NotKeptAlive) { @@ -172,13 +184,13 @@ TEST_F(HeartBeatMonitorTest, NotKeptAlive) { EXPECT_CALL(connection_handler_mock, CloseConnection(_)); conn->StartHeartBeat(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(kTimeout - 1); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS - MICROSECONDS_IN_SECOND); conn->KeepAlive(session); - sleep(2 * kTimeout + 1); + usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) { @@ -195,7 +207,7 @@ TEST_F(HeartBeatMonitorTest, TwoSessionsElapsed) { conn->StartHeartBeat(kSession1); conn->StartHeartBeat(kSession2); - sleep(2 * kTimeout + 1); + usleep(2 * kTimeout * MICROSECONDS_IN_MILLISECONDS + MICROSECONDS_IN_SECOND); } TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) { @@ -206,25 +218,26 @@ TEST_F(HeartBeatMonitorTest, IncreaseHeartBeatTimeout) { EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, _)).Times(0); - const int32_t kNewTimeout = kTimeout + 1; + 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 - sleep(kTimeout); + usleep(kTimeout * MICROSECONDS_IN_MILLISECONDS); } TEST_F(HeartBeatMonitorTest, DecreaseHeartBeatTimeout) { const uint32_t kSession = conn->AddNewSession(); - EXPECT_CALL(connection_handler_mock, SendHeartBeat(_, 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)); - const int32_t kNewTimeout = kTimeout - 1; + const uint32_t kNewTimeout = kTimeout - MICROSECONDS_IN_MILLISECONDS; conn->StartHeartBeat(kSession); conn->SetHeartBeatTimeout(kNewTimeout, kSession); // new timeout less than old timeout so mock object should be invoked - sleep(kTimeout*2); + usleep(kTimeout * 2 * MICROSECONDS_IN_MILLISECONDS); } } // namespace connection_handler_test diff --git a/src/components/connection_handler/test/include/connection_handler_observer_mock.h b/src/components/connection_handler/test/include/connection_handler_observer_mock.h new file mode 100644 index 0000000000..9a74375262 --- /dev/null +++ b/src/components/connection_handler/test/include/connection_handler_observer_mock.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2015, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#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 <string> +#include "connection_handler/connection_handler_observer.h" + +namespace test { +namespace components { +namespace connection_handler_test { + +/* + * MOCK implementation of ::connection_handler::ConnectionHandlerObserver interface + */ +class ConnectionHandlerObserverMock : public ::connection_handler::ConnectionHandlerObserver { + public: + MOCK_METHOD1(OnDeviceListUpdated, + void(const connection_handler::DeviceMap &device_list)); + MOCK_METHOD0(OnFindNewApplicationsRequest,void()); + MOCK_METHOD1(RemoveDevice, + 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, + const connection_handler::CloseSessionReason& close_reason)); + 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_ diff --git a/src/components/connection_handler/test/smartDeviceLink.ini b/src/components/connection_handler/test/smartDeviceLink.ini index 0e79edf3ac..109003eb5f 100644 --- a/src/components/connection_handler/test/smartDeviceLink.ini +++ b/src/components/connection_handler/test/smartDeviceLink.ini @@ -58,7 +58,7 @@ AppTimeScaleMaxRequests = 1000 AppRequestsTimeScale = 10 ; Allowed pending requests amount. If value is 0 check will be skipped PendingRequestsAmount = 5000 -HeartBeatTimeout = 7 +HeartBeatTimeout = 7000 SupportedDiagModes = 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x09, 0x0A, 0x18, 0x19, 0x22, 0x3E SystemFilesPath = /tmp/fs/mp/images/ivsu_cache UseLastState = true |