From 2c207377259ad01c7f231533ba7189008d03a898 Mon Sep 17 00:00:00 2001 From: "Andrey Oleynik (GitHub)" Date: Thu, 30 Nov 2017 09:43:44 +0200 Subject: Updates mocks and unit tests after prior commit Fixes mock classes interfaces, unit tests and build after changes related to making iAP2 switching triggered externally and using of Bluetooth MAC/USB serial instead of UUID for internal device management. --- .../src/application_manager_impl.cc | 27 +-- .../test/application_manager_impl_mock_hmi_test.cc | 19 +- .../test/application_manager_impl_test.cc | 107 ++++++---- .../mobile/register_app_interface_request_test.cc | 18 +- .../test/connection_handler_impl_test.cc | 46 +++-- .../policies/mock_policy_handler_interface.h | 2 + .../mock_connection_handler_observer.h | 4 +- .../policy_external/policy/mock_cache_manager.h | 2 + .../policy_external/policy/mock_policy_manager.h | 2 + .../policy_regular/policy/mock_cache_manager.h | 2 + .../policy_regular/policy/mock_policy_manager.h | 3 + .../mock_transport_manager_listener.h | 3 +- .../transport_adapter/mock_transport_adapter.h | 5 +- .../mock_transport_adapter_listener.h | 2 + .../test/transport_manager_impl_test.cc | 221 ++++++++++++++++----- 15 files changed, 322 insertions(+), 141 deletions(-) diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index b4cb692740..b6ffc80ed4 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -1076,29 +1076,28 @@ void ApplicationManagerImpl::OnDeviceSwitchingStart( const connection_handler::Device& device_from, const connection_handler::Device& device_to) { LOG4CXX_AUTO_TRACE(logger_); - sync_primitives::AutoLock lock(reregister_wait_list_lock_); { auto apps_data_accessor = applications(); std::copy_if( - apps_data_accessor.GetData().begin(), - apps_data_accessor.GetData().end(), - std::back_inserter(reregister_wait_list_), - std::bind1st(std::ptr_fun(&device_id_comparator), - device_from.mac_address())); + apps_data_accessor.GetData().begin(), + apps_data_accessor.GetData().end(), + std::back_inserter(reregister_wait_list_), + std::bind1st(std::ptr_fun(&device_id_comparator), + device_from.mac_address())); } { // During sending of UpdateDeviceList this lock is acquired also so making // it scoped sync_primitives::AutoLock lock(reregister_wait_list_lock_); - for (auto i = reregister_wait_list_.begin(); reregister_wait_list_.end() != i; - ++i) { - auto app = *i; - request_ctrl_.terminateAppRequests(app->app_id()); - resume_ctrl_->SaveApplication(app); + for (auto i = reregister_wait_list_.begin(); reregister_wait_list_.end() != i; + ++i) { + auto app = *i; + request_ctrl_.terminateAppRequests(app->app_id()); + resume_ctrl_->SaveApplication(app); + } } -} policy_handler_->OnDeviceSwitching(device_from.mac_address(), device_to.mac_address()); @@ -1108,6 +1107,10 @@ void ApplicationManagerImpl::OnDeviceSwitchingStart( smart_objects::SmartObjectSPtr msg_params = MessageHelper::CreateDeviceListSO(device_list, GetPolicyHandler(), *this); + if (!msg_params) { + LOG4CXX_ERROR(logger_, "Can't create UpdateDeviceList notification"); + return; + } auto update_list = utils::MakeShared(); smart_objects::SmartObject& so_to_send = *update_list; diff --git a/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc b/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc index 4de7be7c4c..471270f9b8 100644 --- a/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc +++ b/src/components/application_manager/test/application_manager_impl_mock_hmi_test.cc @@ -39,6 +39,7 @@ #include "application_manager/application_manager_impl.h" #include "utils/custom_string.h" #include "utils/make_shared.h" +#include "encryption/hashing.h" #include "application_manager/mock_application_manager_settings.h" #include "application_manager/mock_resumption_data.h" @@ -162,7 +163,7 @@ TEST_F(ApplicationManagerImplMockHmiTest, utils::SharedPtr app_impl = new ApplicationImpl( application_id, policy_app_id, - mac_address, + encryption::MakeHash(mac_address), device_id, app_name, utils::SharedPtr( @@ -171,11 +172,25 @@ TEST_F(ApplicationManagerImplMockHmiTest, app_manager_impl_->AddMockApplication(app_impl); - app_manager_impl_->OnDeviceSwitchingStart(mac_address); + const connection_handler::Device bt(device_id, + "BT_device", + mac_address, + "BLUETOOTH"); + + const connection_handler::Device usb(device_id + 1, + "USB_device", + "USB_serial", + "USB_IOS"); MockHMICommandFactory* mock_hmi_factory = MockHMICommandFactory::mock_hmi_command_factory(); + // Skip sending notification on device switching as it is not the goal here + EXPECT_CALL(*mock_hmi_factory, CreateCommand(_, _)) + .WillOnce(Return(utils::SharedPtr())); + + app_manager_impl_->OnDeviceSwitchingStart(bt, usb); + const uint32_t connection_key = 1u; const uint32_t correlation_id_1 = 1u; const uint32_t correlation_id_2 = 2u; diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc index f2af615025..4398952237 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -56,6 +56,7 @@ #include "utils/lock.h" #include "utils/make_shared.h" #include "utils/push_log.h" +#include "encryption/hashing.h" namespace test { namespace components { @@ -131,7 +132,7 @@ class ApplicationManagerImplTest : public ::testing::Test { ON_CALL(mock_application_manager_settings_, app_storage_folder()) .WillByDefault(ReturnRef(kDirectoryName)); ON_CALL(mock_application_manager_settings_, launch_hmi()) - .WillByDefault(Return(true)); + .WillByDefault(Return(false)); ON_CALL(mock_application_manager_settings_, stop_streaming_timeout()) .WillByDefault(Return(stop_streaming_timeout)); ON_CALL(mock_application_manager_settings_, default_timeout()) @@ -679,29 +680,56 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr switching_app_ptr = utils::MakeShared(); - const std::string switching_mac_address = "switching"; + const std::string switching_device_id = "switching"; + const std::string switching_device_id_hash = + encryption::MakeHash(switching_device_id); app_manager_impl_->AddMockApplication(switching_app_ptr); EXPECT_CALL(*switching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(switching_mac_address)); + .WillRepeatedly(ReturnRef(switching_device_id_hash)); const std::string policy_app_id_switch = "abc"; EXPECT_CALL(*switching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_switch)); + const auto hmi_level_switching_app = mobile_apis::HMILevel::HMI_FULL; + EXPECT_CALL(*switching_app_ptr, hmi_level()) + .WillRepeatedly(Return(hmi_level_switching_app)); + utils::SharedPtr nonswitching_app_ptr = utils::MakeShared(); - const std::string nonswitching_mac_address = "nonswitching"; + const std::string nonswitching_device_id = "nonswitching"; + const std::string nonswitching_device_id_hash = + encryption::MakeHash(nonswitching_device_id); app_manager_impl_->AddMockApplication(nonswitching_app_ptr); EXPECT_CALL(*nonswitching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(nonswitching_mac_address)); + .WillRepeatedly(ReturnRef(nonswitching_device_id_hash)); const std::string policy_app_id_nonswitch = "efg"; EXPECT_CALL(*nonswitching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_nonswitch)); + const auto hmi_level_nonswitching_app = mobile_apis::HMILevel::HMI_LIMITED; + EXPECT_CALL(*nonswitching_app_ptr, hmi_level()) + .WillRepeatedly(Return(hmi_level_nonswitching_app)); + // Act - app_manager_impl_->OnDeviceSwitchingStart(switching_mac_address); + const connection_handler::DeviceHandle switching_handle = 1; + const connection_handler::Device switching_device(switching_handle, + "switching_device", + switching_device_id, + "BLUETOOTH"); + + const connection_handler::DeviceHandle non_switching_handle = 2; + const connection_handler::Device non_switching_device(non_switching_handle, + "non_switching_device", + nonswitching_device_id, + "USB"); + + EXPECT_CALL(*mock_message_helper_, CreateDeviceListSO(_, _, _)) + .WillOnce(Return(smart_objects::SmartObjectSPtr())); + app_manager_impl_->OnDeviceSwitchingStart(switching_device, + non_switching_device); EXPECT_TRUE(app_manager_impl_->IsAppInReconnectMode(policy_app_id_switch)); EXPECT_FALSE( app_manager_impl_->IsAppInReconnectMode(policy_app_id_nonswitch)); @@ -712,62 +740,63 @@ TEST_F(ApplicationManagerImplTest, utils::SharedPtr switching_app_ptr = utils::MakeShared(); - const uint32_t switching_app_id = 1u; - EXPECT_CALL(*switching_app_ptr, app_id()) - .WillRepeatedly(Return(switching_app_id)); - - const uint32_t switching_device_id = 1u; - EXPECT_CALL(*switching_app_ptr, device()) - .WillRepeatedly(Return(switching_device_id)); - - const std::string switching_mac_address = "switching"; + const std::string switching_device_id = "switching"; + const std::string switching_device_id_hash = + encryption::MakeHash(switching_device_id); app_manager_impl_->AddMockApplication(switching_app_ptr); EXPECT_CALL(*switching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(switching_mac_address)); + .WillRepeatedly(ReturnRef(switching_device_id_hash)); const std::string policy_app_id_switch = "abc"; EXPECT_CALL(*switching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_switch)); + const auto hmi_level_switching_app = mobile_apis::HMILevel::HMI_FULL; + EXPECT_CALL(*switching_app_ptr, hmi_level()) + .WillRepeatedly(Return(hmi_level_switching_app)); + utils::SharedPtr nonswitching_app_ptr = utils::MakeShared(); - const uint32_t nonswitching_app_id = 2u; - EXPECT_CALL(*nonswitching_app_ptr, app_id()) - .WillRepeatedly(Return(nonswitching_app_id)); - - const uint32_t nonswitching_device_id = 2u; - EXPECT_CALL(*nonswitching_app_ptr, device()) - .WillRepeatedly(Return(nonswitching_device_id)); - - const std::string nonswitching_mac_address = "nonswitching"; + const std::string nonswitching_device_id = "nonswitching"; + const std::string nonswitching_device_id_hash = + encryption::MakeHash(nonswitching_device_id); app_manager_impl_->AddMockApplication(nonswitching_app_ptr); EXPECT_CALL(*nonswitching_app_ptr, mac_address()) - .WillRepeatedly(ReturnRef(nonswitching_mac_address)); + .WillRepeatedly(ReturnRef(nonswitching_device_id_hash)); const std::string policy_app_id_nonswitch = "efg"; EXPECT_CALL(*nonswitching_app_ptr, policy_app_id()) .WillRepeatedly(Return(policy_app_id_nonswitch)); + const auto hmi_level_nonswitching_app = mobile_apis::HMILevel::HMI_LIMITED; + EXPECT_CALL(*nonswitching_app_ptr, hmi_level()) + .WillRepeatedly(Return(hmi_level_nonswitching_app)); + // Act - app_manager_impl_->OnDeviceSwitchingStart(switching_mac_address); - EXPECT_TRUE(app_manager_impl_->IsAppInReconnectMode(policy_app_id_switch)); - EXPECT_FALSE( - app_manager_impl_->IsAppInReconnectMode(policy_app_id_nonswitch)); + const connection_handler::DeviceHandle switching_handle = 1; + const connection_handler::Device switching_device(switching_handle, + "switching_device", + switching_device_id, + "BLUETOOTH"); - smart_objects::SmartObjectSPtr sptr = - MakeShared(); + const connection_handler::DeviceHandle non_switching_handle = 2; + const connection_handler::Device non_switching_device(non_switching_handle, + "non_switching_device", + nonswitching_device_id, + "USB"); - ON_CALL(*mock_message_helper_, CreateModuleInfoSO(_, _)) - .WillByDefault(Return(sptr)); - ON_CALL(*mock_message_helper_, CreateNegativeResponse(_, _, _, _)) - .WillByDefault(Return(sptr)); + EXPECT_CALL(*mock_message_helper_, CreateDeviceListSO(_, _, _)) + .WillOnce(Return(smart_objects::SmartObjectSPtr())); + + app_manager_impl_->OnDeviceSwitchingStart(switching_device, + non_switching_device); + + EXPECT_TRUE(app_manager_impl_->IsAppInReconnectMode(policy_app_id_switch)); - app_manager_impl_->OnDeviceSwitchingFinish(switching_mac_address); + app_manager_impl_->OnDeviceSwitchingFinish(switching_device_id); EXPECT_FALSE( app_manager_impl_->application_by_policy_id(policy_app_id_switch)); - EXPECT_TRUE( - app_manager_impl_->application_by_policy_id(policy_app_id_nonswitch)); } TEST_F(ApplicationManagerImplTest, diff --git a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc index b0928044fc..bf619e5229 100644 --- a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc @@ -432,13 +432,7 @@ TEST_F(RegisterAppInterfaceRequestTest, mock_app), request_hash_id)).WillOnce(Return(true)); - EXPECT_CALL( - mock_resume_crt_, - CheckPersistenceFilesForResumption( - MockAppPtr::static_pointer_cast( - mock_app))).WillOnce(Return(true)); - - EXPECT_CALL(mock_resume_crt_, RemoveApplicationFromSaved(_)).Times(0); + EXPECT_CALL(mock_resume_crt_, RemoveApplicationFromSaved(_)).Times(0); EXPECT_CALL(mock_application_helper_, RecallApplicationData(_, _)).Times(0); @@ -473,11 +467,7 @@ TEST_F(RegisterAppInterfaceRequestTest, mock_app), request_hash_id)).WillOnce(Return(false)); - EXPECT_CALL(mock_resume_crt_, - RemoveApplicationFromSaved(MockAppPtr::static_pointer_cast< - const application_manager::Application>(mock_app))); - - EXPECT_CALL( + EXPECT_CALL( mock_application_helper_, RecallApplicationData( MockAppPtr::static_pointer_cast( @@ -507,10 +497,6 @@ TEST_F(RegisterAppInterfaceRequestTest, EXPECT_CALL(app_mngr_, ProcessReconnection(_, kConnectionKey)); - EXPECT_CALL(mock_resume_crt_, - RemoveApplicationFromSaved(MockAppPtr::static_pointer_cast< - const application_manager::Application>(mock_app))); - EXPECT_CALL( mock_application_helper_, RecallApplicationData( 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 15d1e645ab..3967fb247f 100644 --- a/src/components/connection_handler/test/connection_handler_impl_test.cc +++ b/src/components/connection_handler/test/connection_handler_impl_test.cc @@ -471,6 +471,14 @@ TEST_F(ConnectionHandlerTest, IsHeartBeatSupported) { connection_handler_->IsHeartBeatSupported(uid_, start_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(); @@ -1900,23 +1908,35 @@ TEST_F(ConnectionHandlerTest, OnDeviceConnectionSwitching) { connection_handler_->set_connection_handler_observer( &mock_connection_handler_observer); - const std::string fake_device_id = "fake_device_id"; - EXPECT_CALL(mock_connection_handler_observer, - OnDeviceSwitchingStart(encryption::MakeHash(fake_device_id))); - connection_handler_->OnDeviceSwitchingStart(fake_device_id); -} + const transport_manager::DeviceInfo device_info_1(device_handle_, + mac_address_, + device_name_, + connection_type_); -TEST_F(ConnectionHandlerTest, OnDeviceSwitchingFinish) { - connection_handler_test::MockConnectionHandlerObserver - mock_connection_handler_observer; - connection_handler_->set_connection_handler_observer( - &mock_connection_handler_observer); + connection_handler_->OnDeviceAdded(device_info_1); + + const auto second_mac_address = "second_mac_address"; + const transport_manager::DeviceInfo device_info_2(device_handle_ + 1, + second_mac_address, + "second_device_name", + "second_connection_type"); + + connection_handler_->OnDeviceAdded(device_info_2); + + connection_handler::Device d1(device_info_1.device_handle(), + device_info_1.name(), + device_info_1.mac_address(), + device_info_1.connection_type()); + + connection_handler::Device d2(device_info_2.device_handle(), + device_info_2.name(), + device_info_2.mac_address(), + device_info_2.connection_type()); - const std::string fake_device_id = "fake_device_id"; EXPECT_CALL(mock_connection_handler_observer, - OnDeviceSwitchingFinish(encryption::MakeHash(fake_device_id))); + OnDeviceSwitchingStart(SameDevice(d1), SameDevice(d2))); - connection_handler_->OnDeviceSwitchingFinish(fake_device_id); + connection_handler_->OnDeviceSwitchingStart(mac_address_, second_mac_address); } } // namespace connection_handler_test diff --git a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h index 812df19ccd..bb4e5d3e21 100644 --- a/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h +++ b/src/components/include/test/application_manager/policies/mock_policy_handler_interface.h @@ -255,6 +255,8 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface { MOCK_METHOD2(SetDefaultHmiTypes, void(const std::string& application_id, const smart_objects::SmartObject* app_types)); + MOCK_METHOD2(OnDeviceSwitching, void(const std::string& device_id_from, + const std::string& device_id_to)); #endif // SDL_REMOTE_CONTROL private: diff --git a/src/components/include/test/connection_handler/mock_connection_handler_observer.h b/src/components/include/test/connection_handler/mock_connection_handler_observer.h index 3bcd8d5214..0d0d362adb 100644 --- a/src/components/include/test/connection_handler/mock_connection_handler_observer.h +++ b/src/components/include/test/connection_handler/mock_connection_handler_observer.h @@ -67,7 +67,9 @@ class MockConnectionHandlerObserver GetHandshakeContext, security_manager::SSLContext::HandshakeContext(uint32_t key)); - MOCK_METHOD1(OnDeviceSwitchingStart, void(const std::string& device_uid)); + MOCK_METHOD2(OnDeviceSwitchingStart, void( + const connection_handler::Device& device_from, + const connection_handler::Device& device_to)); MOCK_METHOD1(OnDeviceSwitchingFinish, void(const std::string& device_uid)); }; diff --git a/src/components/include/test/policy/policy_external/policy/mock_cache_manager.h b/src/components/include/test/policy/policy_external/policy/mock_cache_manager.h index e90fa63075..2f3c785865 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_cache_manager.h +++ b/src/components/include/test/policy/policy_external/policy/mock_cache_manager.h @@ -247,6 +247,8 @@ class MockCacheManagerInterface : public ::policy::CacheManagerInterface { GroupsByExternalConsentStatus(const ExternalConsentStatus&)); MOCK_METHOD0(GetKnownLinksFromPT, std::map()); MOCK_METHOD1(SetExternalConsentForApp, void(const PermissionConsent&)); + MOCK_METHOD2(OnDeviceSwitching, void(const std::string& device_id_from, + const std::string& device_id_to)); }; } // namespace policy_test diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h index 6227e7e85c..3b835be422 100644 --- a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h +++ b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h @@ -215,6 +215,8 @@ class MockPolicyManager : public PolicyManager { MOCK_METHOD0(GetExternalConsentStatus, ExternalConsentStatus()); MOCK_CONST_METHOD1(IsNeedToUpdateExternalConsentStatus, bool(const ExternalConsentStatus&)); + MOCK_METHOD2(OnDeviceSwitching, void(const std::string& device_id_from, + const std::string& device_id_to)); }; } // namespace policy_manager_test } // namespace components diff --git a/src/components/include/test/policy/policy_regular/policy/mock_cache_manager.h b/src/components/include/test/policy/policy_regular/policy/mock_cache_manager.h index 39876cf713..9a254417ec 100644 --- a/src/components/include/test/policy/policy_regular/policy/mock_cache_manager.h +++ b/src/components/include/test/policy/policy_regular/policy/mock_cache_manager.h @@ -211,6 +211,8 @@ class MockCacheManagerInterface : public CacheManagerInterface { MOCK_CONST_METHOD2(AppHasHMIType, bool(const std::string& application_id, policy_table::AppHMIType hmi_type)); + MOCK_METHOD2(OnDeviceSwitching, void(const std::string& device_id_from, + const std::string& device_id_to)); }; } // namespace policy_test diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h index cfe41ee64c..66fc9bcf8d 100644 --- a/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h @@ -222,6 +222,9 @@ class MockPolicyManager : public PolicyManager { CheckPendingPermissionsChanges, void(const std::string& policy_app_id, const std::vector& current_permissions)); + + MOCK_METHOD2(OnDeviceSwitching, void(const std::string& device_id_from, + const std::string& device_id_to)); }; } // namespace policy_manager_test diff --git a/src/components/include/test/transport_manager/mock_transport_manager_listener.h b/src/components/include/test/transport_manager/mock_transport_manager_listener.h index a57ae69bbb..2099c2c56b 100644 --- a/src/components/include/test/transport_manager/mock_transport_manager_listener.h +++ b/src/components/include/test/transport_manager/mock_transport_manager_listener.h @@ -81,7 +81,8 @@ class MockTransportManagerListener : public TransportManagerListener { MOCK_METHOD2(OnTMMessageSendFailed, void(const DataSendError& error, const ::protocol_handler::RawMessagePtr message)); - MOCK_METHOD1(OnDeviceSwitchingStart, void(const DeviceUID& device_uid)); + MOCK_METHOD2(OnDeviceSwitchingStart, void(const DeviceUID& device_uid_from, + const DeviceUID& device_uid_to)); MOCK_METHOD1(OnDeviceSwitchingFinish, void(const DeviceUID& device_uid)); }; diff --git a/src/components/include/test/transport_manager/transport_adapter/mock_transport_adapter.h b/src/components/include/test/transport_manager/transport_adapter/mock_transport_adapter.h index 3f915a75f4..c37c41d4f8 100644 --- a/src/components/include/test/transport_manager/transport_adapter/mock_transport_adapter.h +++ b/src/components/include/test/transport_manager/transport_adapter/mock_transport_adapter.h @@ -98,10 +98,11 @@ class MockTransportAdapter MOCK_CONST_METHOD1(StopDevice, void(const ::transport_manager::DeviceUID& device_id)); - + MOCK_CONST_METHOD0(DoTransportSwitch, void()); MOCK_METHOD1(DeviceSwitched, void(const ::transport_manager::DeviceUID& device_handle)); - + MOCK_CONST_METHOD0(GetSwitchableDevices, + transport_manager::SwitchableDevices()); #ifdef TELEMETRY_MONITOR MOCK_METHOD0(GetTelemetryObserver, ::transport_manager::TMTelemetryObserver*()); diff --git a/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_listener.h b/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_listener.h index 8302a63beb..29bf7c8e83 100644 --- a/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_listener.h +++ b/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_listener.h @@ -120,6 +120,8 @@ class MockTransportAdapterListener : public TransportAdapterListener { void(const TransportAdapter*, const DeviceUID&, const ApplicationHandle&)); + MOCK_METHOD1(OnTransportSwitchRequested, + void(const TransportAdapter* transport_adapter)); }; } // namespace transport_manager_test diff --git a/src/components/transport_manager/test/transport_manager_impl_test.cc b/src/components/transport_manager/test/transport_manager_impl_test.cc index 65884d8e94..7380d68bbc 100644 --- a/src/components/transport_manager/test/transport_manager_impl_test.cc +++ b/src/components/transport_manager/test/transport_manager_impl_test.cc @@ -106,6 +106,34 @@ class TransportManagerImplTest : public ::testing::Test { MakeShared(connection_key_, version_protocol_, data, kSize); } + DeviceInfo ConstructDeviceInfo(const std::string& mac_address, + const std::string& connection_type, + const std::string& device_name) { + const auto device_handle( + tm_.get_converter().UidToHandle(mac_address, connection_type)); + + return DeviceInfo(device_handle, mac_address, device_name, connection_type); + } + + void SetAddDeviceExpectations(MockTransportAdapter* mock_adapter, + transport_adapter::DeviceType type, + const DeviceList& device_list, + const DeviceInfo& device_info) { + EXPECT_CALL(*mock_adapter, GetDeviceList()) + .WillRepeatedly(Return(device_list)); + + EXPECT_CALL(*mock_adapter, DeviceName(device_info.mac_address())) + .WillRepeatedly(Return(device_info.name())); + + EXPECT_CALL(*mock_adapter, GetConnectionType()) + .WillRepeatedly(Return(device_info.connection_type())); + + EXPECT_CALL(*mock_adapter, GetDeviceType()).WillRepeatedly(Return(type)); + + EXPECT_CALL(*tm_listener_, OnDeviceAdded(device_info)); + EXPECT_CALL(*tm_listener_, OnDeviceListUpdated(_)); + } + void HandleDeviceListUpdated() { TransportAdapterEvent test_event(EventTypeEnum::ON_DEVICE_LIST_UPDATED, mock_adapter_, @@ -127,8 +155,8 @@ class TransportManagerImplTest : public ::testing::Test { .Times(AtLeast(1)) .WillRepeatedly(Return(dev_info_.connection_type())); - EXPECT_CALL(*tm_listener_, OnDeviceFound(dev_info_)); EXPECT_CALL(*tm_listener_, OnDeviceAdded(dev_info_)); + EXPECT_CALL(*tm_listener_, OnDeviceListUpdated(_)); tm_.TestHandle(test_event); device_list_.pop_back(); @@ -287,24 +315,6 @@ class TransportManagerImplTest : public ::testing::Test { ASSERT_EQ(E_SUCCESS, tm_.Stop()); } - void SetAddDeviceExpectations(MockTransportAdapter* mock_adapter, - transport_adapter::DeviceType type) { - EXPECT_CALL(*mock_adapter, GetDeviceList()) - .WillRepeatedly(Return(device_list_)); - - EXPECT_CALL(*mock_adapter, DeviceName(dev_info_.mac_address())) - .WillRepeatedly(Return(dev_info_.name())); - - EXPECT_CALL(*mock_adapter, GetConnectionType()) - .WillRepeatedly(Return(dev_info_.connection_type())); - - EXPECT_CALL(*mock_adapter, GetDeviceType()).WillRepeatedly(Return(type)); - - EXPECT_CALL(*tm_listener_, OnDeviceAdded(dev_info_)); - EXPECT_CALL(*tm_listener_, OnDeviceListUpdated(_)); - EXPECT_CALL(*tm_listener_, OnDeviceFound(_)); - } - MockTransportManagerSettings mock_transport_manager_settings_; #ifdef TELEMETRY_MONITOR MockTMTelemetryObserver mock_metric_observer_; @@ -1073,44 +1083,44 @@ TEST_F(TransportManagerImplTest, TEST_F( TransportManagerImplTest, - UpdateDeviceList_AddSameUUIDNonSwitchableDevices_TwoTransportAdapters_ExpectSecondFailed) { - // Arrange - MockTransportAdapter* second_mock_adapter = new MockTransportAdapter(); + UpdateDeviceList_AddSameUUIDNonSwitchableDevices_TwoTransportAdapters_ExpectNoSwitch) { device_list_.push_back(dev_info_.mac_address()); - // Check before Act + SetAddDeviceExpectations( + mock_adapter_, transport_adapter::DeviceType::TCP, device_list_, dev_info_); + + tm_.OnDeviceListUpdated(mock_adapter_); + + // Adapter will be removed by TM on destruction + MockTransportAdapter* second_mock_adapter = new MockTransportAdapter(); EXPECT_CALL(*second_mock_adapter, AddListener(_)); EXPECT_CALL(*second_mock_adapter, IsInitialised()).WillOnce(Return(true)); EXPECT_EQ(E_SUCCESS, tm_.AddTransportAdapter(second_mock_adapter)); - EXPECT_CALL(*mock_adapter_, GetDeviceType()) - .WillRepeatedly(Return(transport_adapter::DeviceType::TCP)); - EXPECT_CALL(*mock_adapter_, GetDeviceList()) - .WillRepeatedly(Return(device_list_)); - EXPECT_CALL(*mock_adapter_, DeviceName(dev_info_.mac_address())) - .WillRepeatedly(Return(dev_info_.name())); - EXPECT_CALL(*mock_adapter_, GetConnectionType()) - .WillRepeatedly(Return(dev_info_.connection_type())); - EXPECT_CALL(*tm_listener_, OnDeviceFound(dev_info_)); - EXPECT_CALL(*tm_listener_, OnDeviceAdded(dev_info_)); - EXPECT_CALL(*tm_listener_, OnDeviceListUpdated(_)); + const auto usb_serial = "USB_serial"; + DeviceInfo second_device = + ConstructDeviceInfo(usb_serial, "USB_IOS", "SecondDeviceName"); - // Act - tm_.OnDeviceListUpdated(mock_adapter_); + DeviceList second_adapter_device_list; + second_adapter_device_list.push_back(usb_serial); - EXPECT_CALL(*second_mock_adapter, GetDeviceList()) - .WillRepeatedly(Return(device_list_)); - EXPECT_CALL(*second_mock_adapter, DeviceName(dev_info_.mac_address())) - .WillRepeatedly(Return(dev_info_.name())); - EXPECT_CALL(*second_mock_adapter, GetConnectionType()) - .WillRepeatedly(Return(dev_info_.connection_type())); - EXPECT_CALL(*second_mock_adapter, GetDeviceType()) - .WillRepeatedly(Return(transport_adapter::DeviceType::IOS_USB)); + SetAddDeviceExpectations(second_mock_adapter, + transport_adapter::DeviceType::IOS_USB, + second_adapter_device_list, + second_device); + + tm_.OnDeviceListUpdated(second_mock_adapter); + + // Act EXPECT_CALL(*second_mock_adapter, StopDevice(_)).Times(0); EXPECT_CALL(*second_mock_adapter, DeviceSwitched(_)).Times(0); - EXPECT_CALL(*tm_listener_, OnDeviceListUpdated(_)).Times(0); - // Act - tm_.OnDeviceListUpdated(second_mock_adapter); + tm_.TestHandle( + TransportAdapterEvent(EventTypeEnum::ON_TRANSPORT_SWITCH_REQUESTED, + second_mock_adapter, + mac_address_, + application_id_, + test_message_, + error_)); device_list_.pop_back(); } @@ -1129,7 +1139,7 @@ TEST_F(TransportManagerImplTest, OnlyOneDeviceShouldNotTriggerSwitch) { EXPECT_CALL(*mock_adapter_, StopDevice(_)).Times(0); EXPECT_CALL(*mock_adapter_, DeviceSwitched(_)).Times(0); - EXPECT_CALL(*tm_listener_, OnDeviceSwitchingStart(_)).Times(0); + EXPECT_CALL(*tm_listener_, OnDeviceSwitchingStart(_, _)).Times(0); tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, mock_adapter_, @@ -1146,8 +1156,10 @@ TEST_F(TransportManagerImplTest, device_list_.push_back(dev_info_.mac_address()); const uint32_t timeout = 0; - SetAddDeviceExpectations(mock_adapter_, - transport_adapter::DeviceType::IOS_BT); + SetAddDeviceExpectations( + mock_adapter_, transport_adapter::DeviceType::IOS_BT, device_list_, dev_info_); + + EXPECT_CALL(*tm_listener_, OnDeviceFound(dev_info_)); tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, mock_adapter_, @@ -1158,19 +1170,89 @@ TEST_F(TransportManagerImplTest, auto second_mock_adapter = utils::MakeShared(); + const auto usb_serial = "USB_serial"; + DeviceInfo second_device = + ConstructDeviceInfo(usb_serial, "USB_IOS", "SecondDeviceName"); + + DeviceList second_adapter_devices; + second_adapter_devices.push_back(second_device.mac_address()); + SetAddDeviceExpectations(second_mock_adapter.get(), - transport_adapter::DeviceType::IOS_USB); + transport_adapter::DeviceType::IOS_USB, + second_adapter_devices, + second_device); - EXPECT_CALL(*mock_adapter_, StopDevice(mac_address_)); - EXPECT_CALL(*second_mock_adapter, DeviceSwitched(mac_address_)); + EXPECT_CALL(*tm_listener_, OnDeviceFound(second_device)); + EXPECT_CALL(*second_mock_adapter, DeviceSwitched(_)).Times(0); + + tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, + second_mock_adapter.get(), + mac_address_, + application_id_, + test_message_, + error_)); + + // Act + const auto uuid = "ABC-DEF-GHJ-KLM"; + SwitchableDevices bt_switchables; + bt_switchables.insert(std::make_pair(dev_info_.mac_address(), uuid)); + EXPECT_CALL(*mock_adapter_, GetSwitchableDevices()) + .WillOnce(Return(bt_switchables)); + + SwitchableDevices usb_switchables; + usb_switchables.insert(std::make_pair(second_device.mac_address(), uuid)); + EXPECT_CALL(*second_mock_adapter, GetSwitchableDevices()) + .WillOnce(Return(usb_switchables)); + EXPECT_CALL(*mock_adapter_, StopDevice(mac_address_)); + EXPECT_CALL(*second_mock_adapter, DeviceSwitched(usb_serial)); EXPECT_CALL(mock_transport_manager_settings_, app_transport_change_timer()) .WillOnce(Return(timeout)); EXPECT_CALL(mock_transport_manager_settings_, app_transport_change_timer_addition()).WillOnce(Return(0)); - EXPECT_CALL(*tm_listener_, OnDeviceSwitchingStart(mac_address_)); - EXPECT_CALL(*tm_listener_, OnDeviceSwitchingFinish(mac_address_)); + EXPECT_CALL(*tm_listener_, OnDeviceSwitchingStart(mac_address_, usb_serial)); + + tm_.TestHandle( + TransportAdapterEvent(EventTypeEnum::ON_TRANSPORT_SWITCH_REQUESTED, + second_mock_adapter.get(), + mac_address_, + application_id_, + test_message_, + error_)); + + // There is internal timer started on switching. Need to wait for timeout. + sleep(1); + device_list_.pop_back(); +} + +TEST_F(TransportManagerImplTest, + TwoTransportAdapterAddSameDeviceSecondSkipped) { + device_list_.push_back(dev_info_.mac_address()); + + SetAddDeviceExpectations( + mock_adapter_, transport_adapter::DeviceType::IOS_BT, device_list_, dev_info_); + + EXPECT_CALL(*tm_listener_, OnDeviceFound(_)); + + tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, + mock_adapter_, + mac_address_, + application_id_, + test_message_, + error_)); + + auto second_mock_adapter = utils::MakeShared(); + + DeviceInfo second_device = + ConstructDeviceInfo("MA:CA:DR:ES:S", "USB_IOS", "SecondDeviceName"); + + SetAddDeviceExpectations(second_mock_adapter.get(), + transport_adapter::DeviceType::IOS_USB, + device_list_, + second_device); + + EXPECT_CALL(*tm_listener_, OnDeviceFound(_)).Times(0); tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, second_mock_adapter.get(), @@ -1182,6 +1264,35 @@ TEST_F(TransportManagerImplTest, device_list_.pop_back(); } +TEST_F(TransportManagerImplTest, NoDeviceTransportSwitchRequest_Fail) { + device_list_.push_back(dev_info_.mac_address()); + SetAddDeviceExpectations( + mock_adapter_, transport_adapter::DeviceType::IOS_USB, device_list_, dev_info_); + + EXPECT_CALL(*tm_listener_, OnDeviceFound(_)); + + tm_.TestHandle(TransportAdapterEvent(EventTypeEnum::ON_DEVICE_LIST_UPDATED, + mock_adapter_, + mac_address_, + application_id_, + test_message_, + error_)); + + EXPECT_CALL(*mock_adapter_, StopDevice(mac_address_)).Times(0); + + EXPECT_CALL(*tm_listener_, OnDeviceSwitchingStart(mac_address_, mac_address_)).Times(0); + + tm_.TestHandle( + TransportAdapterEvent(EventTypeEnum::ON_TRANSPORT_SWITCH_REQUESTED, + mock_adapter_, + mac_address_, + application_id_, + test_message_, + error_)); + + device_list_.pop_back(); +} + TEST_F(TransportManagerImplTest, UpdateDeviceList_RemoveDevices_TwoTransportAdapters_ExpectSuccess) { // Arrange -- cgit v1.2.1