diff options
Diffstat (limited to 'src/components/connection_handler/test/connection_handler_impl_test.cc')
| -rw-r--r-- | src/components/connection_handler/test/connection_handler_impl_test.cc | 299 |
1 files changed, 257 insertions, 42 deletions
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 d0b9ce4ae4..64de24b103 100644 --- a/src/components/connection_handler/test/connection_handler_impl_test.cc +++ b/src/components/connection_handler/test/connection_handler_impl_test.cc @@ -88,7 +88,7 @@ class ConnectionHandlerTest : public ::testing::Test { mac_address_ = "test_address"; connection_handler_ = new ConnectionHandlerImpl( - mock_connection_handler_settings, mock_transport_manager_); + mock_connection_handler_settings_, mock_transport_manager_); uid_ = 1u; connection_key_ = connection_handler_->KeyFromPair(0, 0u); protected_services_.clear(); @@ -101,23 +101,29 @@ class ConnectionHandlerTest : public ::testing::Test { void SetSpecificServices() { #ifdef ENABLE_SECURITY - ON_CALL(mock_connection_handler_settings, force_protected_service()) + ON_CALL(mock_connection_handler_settings_, force_protected_service()) .WillByDefault(ReturnRefOfCopy(protected_services_)); - ON_CALL(mock_connection_handler_settings, force_unprotected_service()) + ON_CALL(mock_connection_handler_settings_, force_unprotected_service()) .WillByDefault(ReturnRefOfCopy(unprotected_services_)); #endif // ENABLE_SECURITY } + // Additional SetUp void AddTestDeviceConnection() { 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()) + 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 } + + /** + * @brief Adds test session + * @return session_id + */ void AddTestSession() { protocol_handler_test::MockProtocolHandler temp_protocol_handler; connection_handler_->set_protocol_handler(&temp_protocol_handler); @@ -134,9 +140,11 @@ class ConnectionHandlerTest : public ::testing::Test { connection_handler_->KeyFromPair(uid_, out_context_.new_session_id_); CheckSessionExists(uid_, out_context_.new_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, out_context_.new_session_id_); EXPECT_EQ(SessionHash(uid_, out_context_.new_session_id_), @@ -198,10 +206,12 @@ class ConnectionHandlerTest : public ::testing::Test { } // Check Service Wrapper - void CheckServiceExists(const int connectionId, - const int session_id, - const ::protocol_handler::ServiceType serviceId, - const bool exists) { + void CheckServiceExists( + const int connectionId, + const int session_id, + const ::protocol_handler::ServiceType serviceId, + const ::transport_manager::ConnectionUID serviceConnectionId, + const bool exists) { // Check all trees to find Service and check own protected value const ConnectionList& connection_list = connection_handler_->getConnectionList(); @@ -221,6 +231,7 @@ class ConnectionHandlerTest : public ::testing::Test { std::find(service_list.begin(), service_list.end(), serviceId); if (exists) { ASSERT_NE(serv_it, service_list.end()); + ASSERT_EQ(serv_it->connection_id, serviceConnectionId); } else { ASSERT_EQ(serv_it, service_list.end()); } @@ -306,12 +317,37 @@ class ConnectionHandlerTest : public ::testing::Test { connection->ProtocolVersion(session_id, check_protocol_version)); EXPECT_EQ(check_protocol_version, protocol_version); } + void AddSecondaryTestService(ServiceType service_type) { + EXPECT_NE(0u, out_context_.new_session_id_); + EXPECT_EQ(SessionHash(uid_, out_context_.new_session_id_), + out_context_.hash_id_); + CheckSessionExists(uid_, out_context_.new_session_id_); + + // Set protocol version to 5 + ChangeProtocol(uid_, + out_context_.new_session_id_, + protocol_handler::PROTOCOL_VERSION_5); + + connection_handler_test::MockConnectionHandlerObserver + temp_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &temp_connection_handler_observer); + EXPECT_CALL(temp_connection_handler_observer, + OnServiceStartedCallback(_, _, service_type, _)).Times(1); + + connection_handler_->OnSessionStartedCallback(2u, + out_context_.new_session_id_, + service_type, + PROTECTION_OFF, + static_cast<BsonObject*>(0)); + connection_handler_->set_connection_handler_observer(NULL); + } ConnectionHandlerImpl* connection_handler_; testing::NiceMock<transport_manager_test::MockTransportManager> mock_transport_manager_; testing::NiceMock<MockConnectionHandlerSettings> - mock_connection_handler_settings; + mock_connection_handler_settings_; protocol_handler_test::MockProtocolHandler mock_protocol_handler_; transport_manager::DeviceHandle device_handle_; transport_manager::ConnectionUID uid_; @@ -376,23 +412,23 @@ TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey) { AddTestSession(); uint32_t app_id = 0; - const uint32_t testid = SessionHash(uid_, out_context_.new_session_id_); + const uint32_t test_id = SessionHash(uid_, out_context_.new_session_id_); - connection_handler::DeviceHandle null_handle = 0; + connection_handler::DeviceHandle* device_id = NULL; EXPECT_EQ(0, connection_handler_->GetDataOnSessionKey( - connection_key_, &app_id, NULL, &null_handle)); - EXPECT_EQ(testid, app_id); + connection_key_, &app_id, NULL, device_id)); + EXPECT_EQ(test_id, app_id); } TEST_F(ConnectionHandlerTest, GetAppIdOnSessionKey_SessionNotStarted) { AddTestDeviceConnection(); uint32_t app_id = 0; - connection_handler::DeviceHandle null_handle = 0; + connection_handler::DeviceHandle* device_id = NULL; EXPECT_EQ(-1, connection_handler_->GetDataOnSessionKey( - connection_key_, &app_id, NULL, &null_handle)); + connection_key_, &app_id, NULL, device_id)); } TEST_F(ConnectionHandlerTest, GetDeviceID) { @@ -500,6 +536,13 @@ TEST_F(ConnectionHandlerTest, GetPairFromKey) { EXPECT_EQ(out_context_.new_session_id_, session_id); } +MATCHER_P(SameDevice, device, "") { + return arg.device_handle() == device.device_handle() && + arg.user_friendly_name() == device.user_friendly_name() && + arg.mac_address() == device.mac_address() && + arg.connection_type() == device.connection_type(); +} + TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) { AddTestDeviceConnection(); AddTestSession(); @@ -508,17 +551,10 @@ TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) { uid_, out_context_.new_session_id_)); } -MATCHER_P(SameDevice, device, "") { - return arg.device_handle() == device.device_handle() && - arg.user_friendly_name() == device.user_friendly_name() && - arg.mac_address() == device.mac_address() && - arg.connection_type() == device.connection_type(); -} - TEST_F(ConnectionHandlerTest, SendEndServiceWithoutSetProtocolHandler) { AddTestDeviceConnection(); AddTestSession(); - EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc)).Times(0); + EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, _, kRpc)).Times(0); connection_handler_->SendEndService(connection_key_, kRpc); } @@ -526,7 +562,7 @@ TEST_F(ConnectionHandlerTest, SendEndService) { AddTestDeviceConnection(); AddTestSession(); connection_handler_->set_protocol_handler(&mock_protocol_handler_); - EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, kRpc)); + EXPECT_CALL(mock_protocol_handler_, SendEndService(_, _, _, kRpc)); connection_handler_->SendEndService(connection_key_, kRpc); } @@ -1112,7 +1148,7 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { PROTECTION_OFF, static_cast<BsonObject*>(NULL)); EXPECT_NE(0u, audio_context.new_session_id_); - CheckServiceExists(uid_, audio_context.new_session_id_, kAudio, true); + CheckServiceExists(uid_, audio_context.new_session_id_, kAudio, uid_, true); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, audio_context.hash_id_); // Start Audio service @@ -1122,7 +1158,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) { PROTECTION_OFF, static_cast<BsonObject*>(NULL)); EXPECT_NE(0u, video_context.new_session_id_); - CheckServiceExists(uid_, video_context.new_session_id_, kMobileNav, true); + CheckServiceExists( + uid_, video_context.new_session_id_, kMobileNav, uid_, true); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_); connection_handler_->set_protocol_handler(NULL); @@ -1150,7 +1187,8 @@ TEST_F(ConnectionHandlerTest, StartService_withServices_withParams) { PROTECTION_OFF, dummy_param); EXPECT_EQ(out_context_.new_session_id_, video_context.new_session_id_); - CheckServiceExists(uid_, out_context_.new_session_id_, kMobileNav, true); + CheckServiceExists( + uid_, out_context_.new_session_id_, kMobileNav, uid_, true); EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, video_context.hash_id_); connection_handler_->set_protocol_handler(NULL); @@ -1174,7 +1212,7 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) { connection_handler_->OnSessionEndedCallback( uid_, out_context_.new_session_id_, &dummy_hash, kAudio); EXPECT_EQ(0u, end_session_result); - CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false); + CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, uid_, false); } TEST_F(ConnectionHandlerTest, ServiceStop) { @@ -1204,7 +1242,7 @@ TEST_F(ConnectionHandlerTest, ServiceStop) { connection_handler_->OnSessionEndedCallback( uid_, out_context_.new_session_id_, &some_hash_id, kAudio); EXPECT_EQ(connection_key_, end_session_result); - CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, false); + CheckServiceExists(uid_, out_context_.new_session_id_, kAudio, uid_, false); } } @@ -1235,8 +1273,8 @@ TEST_F(ConnectionHandlerTest, SessionStop_CheckSpecificHash) { for (uint32_t session = 0; session < 0xFF; ++session) { AddTestSession(); - uint32_t wrong_hash = protocol_handler::HASH_ID_WRONG; - uint32_t hash = protocol_handler::HASH_ID_NOT_SUPPORTED; + uint32_t hash = connection_key_; + uint32_t wrong_hash = hash + 1; const uint32_t end_audio_wrong_hash = connection_handler_->OnSessionEndedCallback( @@ -1273,9 +1311,6 @@ TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) { true, ByRef(empty))); - EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) - .WillOnce(Return(true)); - connection_handler_->set_protocol_handler(&mock_protocol_handler_); EXPECT_CALL(mock_protocol_handler_, NotifySessionStarted(_, _)) .WillOnce(SaveArg<0>(&out_context_)); @@ -1312,8 +1347,6 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_SUCCESS) { session_key, true, ByRef(empty))); - EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) - .WillOnce(Return(true)); // confirm that NotifySessionStarted() is called connection_handler_->set_protocol_handler(&mock_protocol_handler_); @@ -1354,8 +1387,6 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_FAILURE) { session_key, false, ByRef(empty))); - EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) - .WillOnce(Return(true)); // confirm that NotifySessionStarted() is called connection_handler_->set_protocol_handler(&mock_protocol_handler_); @@ -1446,9 +1477,6 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { session_key1, true, ByRef(empty)))); - EXPECT_CALL(mock_connection_handler_observer, CheckAppIsNavi(_)) - .Times(2) - .WillRepeatedly(Return(true)); // verify that connection handler will not mix up the two results SessionContext new_context_first, new_context_second; @@ -1474,7 +1502,7 @@ TEST_F(ConnectionHandlerTest, ServiceStarted_Video_Multiple) { TEST_F(ConnectionHandlerTest, SessionStarted_StartSession_SecureSpecific_Unprotect) { - EXPECT_CALL(mock_connection_handler_settings, heart_beat_timeout()) + EXPECT_CALL(mock_connection_handler_settings_, heart_beat_timeout()) .WillOnce(Return(heartbeat_timeout)); // Add virtual device and connection AddTestDeviceConnection(); @@ -2013,6 +2041,193 @@ TEST_F(ConnectionHandlerTest, OnDeviceConnectionSwitching) { connection_handler_->OnDeviceSwitchingStart(mac_address_, second_mac_address); } +TEST_F(ConnectionHandlerTest, StartStopSecondarySession) { + // Add virtual device and connection + AddTestDeviceConnection(); + // Start new session with RPC service + AddTestSession(); + + connection_handler_test::MockConnectionHandlerObserver + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + // Start a session on a secondary transport + const transport_manager::DeviceInfo secondary_device_info( + device_handle_, mac_address_, device_name_, std::string("WIFI")); + const transport_manager::ConnectionUID secondary_uid = 2u; + // Add Device and connection + ON_CALL(mock_connection_handler_settings_, heart_beat_timeout()) + .WillByDefault(Return(1000u)); + connection_handler_->addDeviceConnection(secondary_device_info, + secondary_uid); + + EXPECT_CALL(mock_connection_handler_observer, + OnSecondaryTransportStartedCallback(device_handle_, _)).Times(1); + + connection_handler_->OnSecondaryTransportStarted( + uid_, secondary_uid, out_context_.new_session_id_); + + SessionTransports st = + connection_handler_->GetSessionTransports(out_context_.new_session_id_); + EXPECT_EQ(st.primary_transport, uid_); + EXPECT_EQ(st.secondary_transport, secondary_uid); + + AddSecondaryTestService(kAudio); + AddSecondaryTestService(kMobileNav); + + CheckServiceExists( + uid_, out_context_.new_session_id_, kAudio, secondary_uid, true); + CheckServiceExists( + uid_, out_context_.new_session_id_, kMobileNav, secondary_uid, true); + + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + EXPECT_CALL(mock_connection_handler_observer, + OnSecondaryTransportEndedCallback(_)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(_, kAudio, _)).Times(1); + EXPECT_CALL(mock_connection_handler_observer, + OnServiceEndedCallback(_, kMobileNav, _)).Times(1); + + connection_handler_->OnSecondaryTransportEnded(uid_, secondary_uid); + + st = connection_handler_->GetSessionTransports(out_context_.new_session_id_); + EXPECT_EQ(st.primary_transport, uid_); + EXPECT_EQ(st.secondary_transport, 0u); + + CheckServiceExists( + uid_, out_context_.new_session_id_, kAudio, secondary_uid, false); + CheckServiceExists( + uid_, out_context_.new_session_id_, kMobileNav, secondary_uid, false); +} + +TEST_F(ConnectionHandlerTest, StopSecondarySession_NoService) { + AddTestDeviceConnection(); + AddTestSession(); + + connection_handler_test::MockConnectionHandlerObserver + mock_connection_handler_observer; + connection_handler_->set_connection_handler_observer( + &mock_connection_handler_observer); + + const transport_manager::DeviceInfo secondary_device_info( + device_handle_, mac_address_, device_name_, std::string("WIFI")); + const transport_manager::ConnectionUID secondary_uid = 123u; + ON_CALL(mock_connection_handler_settings_, heart_beat_timeout()) + .WillByDefault(Return(1000u)); + connection_handler_->addDeviceConnection(secondary_device_info, + secondary_uid); + + EXPECT_CALL(mock_connection_handler_observer, + OnSecondaryTransportStartedCallback(device_handle_, _)).Times(1); + connection_handler_->OnSecondaryTransportStarted( + uid_, secondary_uid, out_context_.new_session_id_); + + // check if OnSecondaryTransportEndedCallback is triggered with correct + // session ID even if we don't have any services + EXPECT_CALL(mock_connection_handler_observer, + OnSecondaryTransportEndedCallback(_)); + EXPECT_CALL(mock_connection_handler_observer, OnServiceEndedCallback(_, _, _)) + .Times(0); + + connection_handler_->OnSecondaryTransportEnded(uid_, secondary_uid); + + SessionTransports st = + connection_handler_->GetSessionTransports(out_context_.new_session_id_); + EXPECT_EQ(st.primary_transport, uid_); + EXPECT_EQ(st.secondary_transport, 0u); +} + +TEST_F(ConnectionHandlerTest, ConnectionType_valid) { + AddTestDeviceConnection(); + AddTestSession(); + + std::string ret = + connection_handler_->TransportTypeProfileStringFromConnHandle(uid_); + EXPECT_EQ(connection_type_, ret); +} + +TEST_F(ConnectionHandlerTest, ConnectionType_invalid) { + AddTestDeviceConnection(); + + transport_manager::ConnectionUID invalid_uid = 12345; + ASSERT_TRUE(invalid_uid != uid_); + std::string ret = + connection_handler_->TransportTypeProfileStringFromConnHandle( + invalid_uid); + EXPECT_EQ(std::string(), ret); +} + +TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_UpdateSuccess) { + uint8_t session_id = 123; + transport_manager::ConnectionUID primary_uid = 100; + transport_manager::ConnectionUID secondary_uid = 0; + + SessionConnectionMap& session_connection_map = + connection_handler_->getSessionConnectionMap(); + // secondary transport's ID is 0 + SessionTransports st = {primary_uid, secondary_uid}; + session_connection_map[session_id] = st; + + secondary_uid = 200; + st = connection_handler_->SetSecondaryTransportID(session_id, secondary_uid); + EXPECT_EQ(primary_uid, st.primary_transport); + EXPECT_EQ(secondary_uid, st.secondary_transport); +} + +TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_UpdateFailure) { + uint8_t session_id = 123; + transport_manager::ConnectionUID primary_uid = 100; + transport_manager::ConnectionUID secondary_uid = 300; + + SessionConnectionMap& session_connection_map = + connection_handler_->getSessionConnectionMap(); + // secondary transport's ID is already assigned + SessionTransports st = {primary_uid, secondary_uid}; + session_connection_map[session_id] = st; + + st = connection_handler_->SetSecondaryTransportID(session_id, 500); + EXPECT_EQ(primary_uid, st.primary_transport); + // secondary transport's ID is NOT updated + EXPECT_EQ(secondary_uid, st.secondary_transport); +} + +TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_OverwirteSecondaryUID) { + uint8_t session_id = 123; + transport_manager::ConnectionUID primary_uid = 200; + transport_manager::ConnectionUID secondary_uid = 500; + + SessionConnectionMap& session_connection_map = + connection_handler_->getSessionConnectionMap(); + SessionTransports st = {primary_uid, secondary_uid}; + session_connection_map[session_id] = st; + + secondary_uid = kDisabledSecondary; + st = connection_handler_->SetSecondaryTransportID(session_id, secondary_uid); + EXPECT_EQ(primary_uid, st.primary_transport); + // secondary transport's ID is updated + EXPECT_EQ(secondary_uid, st.secondary_transport); +} + +TEST_F(ConnectionHandlerTest, SetSecondaryTransportID_Failure) { + uint8_t session_id = 123; + transport_manager::ConnectionUID primary_uid = 100; + transport_manager::ConnectionUID secondary_uid = 0; + + SessionConnectionMap& session_connection_map = + connection_handler_->getSessionConnectionMap(); + SessionTransports st = {primary_uid, secondary_uid}; + session_connection_map[session_id] = st; + + uint8_t invalid_session_id = 10; + secondary_uid = 300; + st = connection_handler_->SetSecondaryTransportID(invalid_session_id, + secondary_uid); + EXPECT_EQ(0u, st.primary_transport); + EXPECT_EQ(0u, st.secondary_transport); +} + } // namespace connection_handler_test } // namespace components } // namespace test |