From 1c32db10769c284450346b5e2de829bb437bff7e Mon Sep 17 00:00:00 2001 From: JackLivio Date: Wed, 13 Mar 2019 13:07:49 -0400 Subject: Cloud app disconnect tests + fix --- .../application_manager/application_manager_impl.h | 9 ++ .../src/application_manager_impl.cc | 10 +- .../test/application_manager_impl_test.cc | 136 ++++++++++++++++++++- .../test/transport_adapter_test.cc | 131 ++++++++++++++++++++ .../test/transport_manager_impl_test.cc | 44 +++++++ 5 files changed, 321 insertions(+), 9 deletions(-) diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h index 27be913cd5..90af5afebf 100644 --- a/src/components/application_manager/include/application_manager/application_manager_impl.h +++ b/src/components/application_manager/include/application_manager/application_manager_impl.h @@ -1580,6 +1580,15 @@ class ApplicationManagerImpl rpc_service_.reset(rpc_service); } + /** + * @brief set a mock rpc service directly. Only for unit + * testing. + * @param mock_app the mock rpc service to be assigned + */ + void SetMockPolicyHandler(policy::PolicyHandlerInterface* policy_handler) { + policy_handler_.reset(policy_handler); + } + virtual void SetPluginManager( std::unique_ptr& plugin_manager) OVERRIDE { diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc index 9d16c366d5..1eeaa8f739 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -1195,14 +1195,15 @@ void ApplicationManagerImpl::SetPendingApplicationState( } LOG4CXX_DEBUG(logger_, "Unregister application and move into apps_to_register"); - { - sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_); - apps_to_register_.insert(app); - } UnregisterApplication( app->app_id(), mobile_apis::Result::INVALID_ENUM, true, true); app->MarkUnregistered(); + + { + sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_); + apps_to_register_.insert(app); + } } void ApplicationManagerImpl::OnConnectionStatusUpdated() { @@ -2923,6 +2924,7 @@ void ApplicationManagerImpl::UnregisterApplication( auto it_app = applications_.begin(); while (applications_.end() != it_app) { if (app_id == (*it_app)->app_id()) { + connection_handler().GetDeviceID((*it_app)->mac_address(), &handle); app_to_remove = *it_app; applications_.erase(it_app++); } else { 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 f27e252142..c606a37ff2 100644 --- a/src/components/application_manager/test/application_manager_impl_test.cc +++ b/src/components/application_manager/test/application_manager_impl_test.cc @@ -29,12 +29,12 @@ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ +#include #include #include #include #include #include -#include #include "application_manager/application.h" #include "application_manager/application_impl.h" @@ -44,6 +44,7 @@ #include "application_manager/mock_resumption_data.h" #include "application_manager/mock_rpc_plugin_manager.h" #include "application_manager/mock_rpc_service.h" +#include "application_manager/policies/mock_policy_handler_interface.h" #include "application_manager/resumption/resume_ctrl_impl.h" #include "application_manager/test/include/application_manager/mock_message_helper.h" #include "connection_handler/mock_connection_handler.h" @@ -60,8 +61,8 @@ #include "utils/file_system.h" #include "utils/lock.h" -#include "utils/push_log.h" #include "encryption/hashing.h" +#include "utils/push_log.h" namespace test { namespace components { @@ -73,15 +74,16 @@ namespace con_test = connection_handler_test; using testing::_; using ::testing::An; -using ::testing::Matcher; using ::testing::ByRef; using ::testing::DoAll; +using ::testing::Matcher; using ::testing::Mock; +using ::testing::NiceMock; using ::testing::Return; using ::testing::ReturnRef; -using ::testing::NiceMock; using ::testing::SaveArg; using ::testing::SetArgPointee; +using ::testing::SetArgReferee; using namespace application_manager; @@ -115,6 +117,8 @@ class ApplicationManagerImplTest : public ::testing::Test { std::make_shared >( mock_app_mngr_)) , mock_rpc_service_(new MockRPCService) + , mock_policy_handler_( + new test::components::policy_test::MockPolicyHandlerInterface) , mock_message_helper_( application_manager::MockMessageHelper::message_helper_mock()) @@ -141,6 +145,7 @@ class ApplicationManagerImplTest : public ::testing::Test { app_manager_impl_->set_connection_handler(&mock_connection_handler_); Json::Value empty; ON_CALL(mock_last_state_, get_dictionary()).WillByDefault(ReturnRef(empty)); + // app_manager_impl_->SetMockPolicyHandler(mock_policy_handler_); std::unique_ptr app_service_manager_ptr( new AppServiceManager(*app_manager_impl_, mock_last_state_)); app_manager_impl_->SetAppServiceManager(app_service_manager_ptr); @@ -210,6 +215,8 @@ class ApplicationManagerImplTest : public ::testing::Test { connection_handler::DeviceHandle secondary_device_handle, std::string secondary_transport_device_string); + void AddCloudAppToPendingDeviceMap(); + uint32_t app_id_; NiceMock mock_policy_settings_; std::shared_ptr > mock_storage_; @@ -219,6 +226,8 @@ class ApplicationManagerImplTest : public ::testing::Test { NiceMock mock_connection_handler_; NiceMock mock_session_observer_; NiceMock mock_application_manager_settings_; + test::components::policy_test::MockPolicyHandlerInterface* + mock_policy_handler_; application_manager_test::MockApplicationManager mock_app_mngr_; std::unique_ptr app_manager_impl_; application_manager::MockMessageHelper* mock_message_helper_; @@ -1428,6 +1437,123 @@ TEST_F(ApplicationManagerImplTest, EXPECT_TRUE(file_system::RemoveDirectory(kDirectoryName, true)); } +void ApplicationManagerImplTest::AddCloudAppToPendingDeviceMap() { + app_manager_impl_->SetMockPolicyHandler(mock_policy_handler_); + std::vector enabled_apps{"1234"}; + std::string endpoint = "https://fakesdlcloudapptesting.com:8080"; + std::string certificate = "cert"; + std::string auth_token = "auth_token"; + std::string cloud_transport_type = "WS"; + std::string hybrid_app_preference_str = "CLOUD"; + bool enabled = true; + EXPECT_CALL(*mock_policy_handler_, GetEnabledCloudApps(_)) + .WillOnce(SetArgReferee<0>(enabled_apps)); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(enabled), + SetArgReferee<2>(endpoint), + SetArgReferee<3>(certificate), + SetArgReferee<4>(auth_token), + SetArgReferee<5>(cloud_transport_type), + SetArgReferee<6>(hybrid_app_preference_str), + Return(true))); + + std::vector nicknames{"CloudApp"}; + EXPECT_CALL(*mock_policy_handler_, GetInitialAppData(_, _, _)) + .WillOnce(DoAll(SetArgPointee<1>(nicknames), Return(true))); + + EXPECT_CALL(*mock_policy_handler_, GetIconUrl(_)).WillOnce(Return("")); + + app_manager_impl_->RefreshCloudAppInformation(); +} + +TEST_F(ApplicationManagerImplTest, CreatePendingApplication) { + // Add to pending device map. Calls refresh cloud app + AddCloudAppToPendingDeviceMap(); + + // CreatePendingApplication + transport_manager::DeviceInfo device_info( + 1, "mac", "https://fakesdlcloudapptesting.com:8080", "CLOUD_WEBSOCKET"); + std::vector nicknames{"CloudApp"}; + EXPECT_CALL(*mock_policy_handler_, GetInitialAppData(_, _, _)) + .WillOnce(DoAll(SetArgPointee<1>(nicknames), Return(true))); + std::vector enabled_apps{"1234"}; + std::string endpoint = "https://fakesdlcloudapptesting.com:8080"; + std::string certificate = "cert"; + std::string auth_token = "auth_token"; + std::string cloud_transport_type = "WS"; + std::string hybrid_app_preference_str = "CLOUD"; + bool enabled = true; + + EXPECT_CALL(*mock_policy_handler_, GetStatisticManager()) + .WillOnce(Return(std::shared_ptr( + new usage_statistics_test::MockStatisticsManager()))); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(enabled), + SetArgReferee<2>(endpoint), + SetArgReferee<3>(certificate), + SetArgReferee<4>(auth_token), + SetArgReferee<5>(cloud_transport_type), + SetArgReferee<6>(hybrid_app_preference_str), + Return(true))); + // Expect Update app list + EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(_, _)).Times(1); + app_manager_impl_->CreatePendingApplication(1, device_info, 1); + AppsWaitRegistrationSet app_list = + app_manager_impl_->AppsWaitingForRegistration().GetData(); + EXPECT_EQ(1u, app_list.size()); +} + +TEST_F(ApplicationManagerImplTest, SetPendingState) { + AddCloudAppToPendingDeviceMap(); + AddMockApplication(); + AppsWaitRegistrationSet app_list = + app_manager_impl_->AppsWaitingForRegistration().GetData(); + EXPECT_EQ(0u, app_list.size()); + EXPECT_CALL(*mock_app_ptr_, policy_app_id()).WillRepeatedly(Return("1234")); + EXPECT_CALL(*mock_app_ptr_, app_id()).WillRepeatedly(Return(123)); + std::string mac = "MAC_ADDRESS"; + EXPECT_CALL(*mock_app_ptr_, mac_address()).WillRepeatedly(ReturnRef(mac)); + transport_manager::DeviceInfo device_info( + 1, "mac", "https://fakesdlcloudapptesting.com:8080", "CLOUD_WEBSOCKET"); + + std::vector enabled_apps{"1234"}; + std::string endpoint = "https://fakesdlcloudapptesting.com:8080"; + std::string certificate = "cert"; + std::string auth_token = "auth_token"; + std::string cloud_transport_type = "WS"; + std::string hybrid_app_preference_str = "CLOUD"; + bool enabled = true; + + EXPECT_CALL(*mock_policy_handler_, GetEnabledCloudApps(_)) + .WillOnce(SetArgReferee<0>(enabled_apps)); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(enabled), + SetArgReferee<2>(endpoint), + SetArgReferee<3>(certificate), + SetArgReferee<4>(auth_token), + SetArgReferee<5>(cloud_transport_type), + SetArgReferee<6>(hybrid_app_preference_str), + Return(true))); + + std::vector nicknames{"CloudApp"}; + EXPECT_CALL(*mock_policy_handler_, GetInitialAppData(_, _, _)) + .WillOnce(DoAll(SetArgPointee<1>(nicknames), Return(true))); + + EXPECT_CALL(*mock_policy_handler_, GetIconUrl(_)).WillOnce(Return("")); + + plugin_manager::MockRPCPluginManager* mock_rpc_plugin_manager = + new plugin_manager::MockRPCPluginManager; + std::unique_ptr mock_rpc_plugin_manager_ptr( + mock_rpc_plugin_manager); + app_manager_impl_->SetPluginManager(mock_rpc_plugin_manager_ptr); + + EXPECT_CALL(mock_connection_handler_, GetDeviceID(_, _)) + .WillOnce(DoAll(SetArgPointee<1>(0), Return(true))); + app_manager_impl_->SetPendingApplicationState(1, device_info); + app_list = app_manager_impl_->AppsWaitingForRegistration().GetData(); + EXPECT_EQ(1u, app_list.size()); +} + TEST_F(ApplicationManagerImplTest, RegisterApplication_CloudAppRegisterSuccess) { std::shared_ptr waiting_app = @@ -1542,6 +1668,6 @@ TEST_F(ApplicationManagerImplTest, EXPECT_EQ(0, application.use_count()); } -} // application_manager_test +} // namespace application_manager_test } // namespace components } // namespace test diff --git a/src/components/transport_manager/test/transport_adapter_test.cc b/src/components/transport_manager/test/transport_adapter_test.cc index dafabf4504..5abfa4dfdd 100644 --- a/src/components/transport_manager/test/transport_adapter_test.cc +++ b/src/components/transport_manager/test/transport_adapter_test.cc @@ -478,6 +478,137 @@ TEST_F(TransportAdapterTest, Disconnect_ConnectDoneSuccess) { EXPECT_CALL(*serverMock, Terminate()); } +TEST_F(TransportAdapterTest, FindPending) { + MockServerConnectionFactory* serverMock = new MockServerConnectionFactory(); + MockTransportAdapterImpl transport_adapter( + NULL, serverMock, NULL, last_state_, transport_manager_settings); + SetDefaultExpectations(transport_adapter); + + EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK)); + EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true)); + transport_adapter.Init(); + + MockTransportAdapterListener mock_listener; + transport_adapter.AddListener(&mock_listener); + + std::shared_ptr mockdev = + std::make_shared(dev_id, uniq_id); + DeviceVector devices{mockdev}; + transport_adapter.SearchDeviceDone(devices); + + // Create cloud app device with connection in pending state + std::shared_ptr connection = + std::make_shared(); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + transport_adapter.ConnectionCreated(connection, uniq_id, 0); + transport_adapter.ConnectPending(uniq_id, 0); + + std::vector dev_list = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, dev_list.size()); + EXPECT_EQ(uniq_id, dev_list[0]); + EXPECT_EQ(ConnectionStatus::PENDING, mockdev->connection_status()); + + ConnectionSPtr mock_connection = + transport_adapter.FindPendingConnection(uniq_id, 0); + ASSERT_TRUE(mock_connection.use_count() != 0); + + ConnectionSPtr mock_connection_fake = + transport_adapter.FindPendingConnection(uniq_id, 1); + ASSERT_TRUE(mock_connection_fake.use_count() == 0); +} + +TEST_F(TransportAdapterTest, + Pending_Connect_Disconnect_ConnectDoneSuccess_PendingDeviceAdded) { + MockServerConnectionFactory* serverMock = new MockServerConnectionFactory(); + MockTransportAdapterImpl transport_adapter( + NULL, serverMock, NULL, last_state_, transport_manager_settings); + SetDefaultExpectations(transport_adapter); + + EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK)); + EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true)); + transport_adapter.Init(); + + MockTransportAdapterListener mock_listener; + transport_adapter.AddListener(&mock_listener); + + std::shared_ptr mockdev = + std::make_shared(dev_id, uniq_id); + DeviceVector devices{mockdev}; + transport_adapter.SearchDeviceDone(devices); + + // Create cloud app device with connection in pending state + std::shared_ptr connection = + std::make_shared(); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + transport_adapter.ConnectionCreated(connection, uniq_id, 0); + transport_adapter.ConnectPending(uniq_id, 0); + + std::vector dev_list = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, dev_list.size()); + EXPECT_EQ(uniq_id, dev_list[0]); + EXPECT_EQ(ConnectionStatus::PENDING, mockdev->connection_status()); + + // Connect cloud app + int app_handle = 0; + std::vector int_list = {app_handle}; + EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(int_list)); + + EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true)); + EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle)) + .WillOnce(Return(TransportAdapter::OK)); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + + TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id); + + EXPECT_EQ(TransportAdapter::OK, res); + EXPECT_EQ(ConnectionStatus::CONNECTED, mockdev->connection_status()); + + auto mock_connection = std::make_shared(); + transport_adapter.ConnectionCreated(mock_connection, dev_id, app_handle); + + EXPECT_CALL(transport_adapter, Store()); + transport_adapter.ConnectDone(dev_id, app_handle); + + // Disconnect cloud app + EXPECT_CALL(*mock_connection, Disconnect()) + .WillOnce(Return(TransportAdapter::OK)); + TransportAdapter::Error new_res = + transport_adapter.Disconnect(dev_id, app_handle); + EXPECT_EQ(TransportAdapter::OK, new_res); + + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev)); + EXPECT_CALL(transport_adapter, GetDeviceType()) + .WillOnce(Return(DeviceType::CLOUD_WEBSOCKET)); + EXPECT_CALL(mock_listener, + OnDisconnectDeviceDone(&transport_adapter, uniq_id)); + EXPECT_CALL(mock_listener, OnDeviceListUpdated(&transport_adapter)).Times(2); + EXPECT_CALL(transport_adapter, Store()); + transport_adapter.DisconnectDone(uniq_id, 0); + + dev_list = transport_adapter.GetDeviceList(); + ASSERT_EQ(0u, dev_list.size()); + + // Recreate device and put cloud app back into pending state + std::shared_ptr mockdev2 = + std::make_shared(dev_id, uniq_id); + DeviceVector devices2{mockdev2}; + transport_adapter.SearchDeviceDone(devices2); + + std::shared_ptr connection2 = + std::make_shared(); + EXPECT_CALL(transport_adapter, FindDevice(uniq_id)) + .WillOnce(Return(mockdev2)); + transport_adapter.ConnectionCreated(connection2, uniq_id, 0); + transport_adapter.ConnectPending(uniq_id, 0); + + dev_list = transport_adapter.GetDeviceList(); + ASSERT_EQ(1u, dev_list.size()); + EXPECT_EQ(uniq_id, dev_list[0]); + EXPECT_EQ(ConnectionStatus::PENDING, mockdev2->connection_status()); + + EXPECT_CALL(*serverMock, Terminate()); +} + TEST_F(TransportAdapterTest, DisconnectDevice_DeviceAddedConnectionCreated) { MockServerConnectionFactory* serverMock = new MockServerConnectionFactory(); MockTransportAdapterImpl transport_adapter( 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 5f13adcd44..dbf0899a1b 100644 --- a/src/components/transport_manager/test/transport_manager_impl_test.cc +++ b/src/components/transport_manager/test/transport_manager_impl_test.cc @@ -190,6 +190,24 @@ class TransportManagerImplTest : public ::testing::Test { tm_.TestHandle(test_event); } + void HandlePending() { + TransportAdapterEvent test_event(EventTypeEnum::ON_CONNECT_PENDING, + mock_adapter_, + dev_info_.mac_address(), + application_id_, + test_message_, + error_); + + EXPECT_CALL(*mock_adapter_, DeviceName(dev_info_.mac_address())) + .WillOnce(Return(dev_info_.name())); + EXPECT_CALL(*mock_adapter_, GetConnectionType()) + .WillRepeatedly(Return(dev_info_.connection_type())); + + EXPECT_CALL(*tm_listener_, OnConnectionPending(dev_info_, connection_key_)); + + tm_.TestHandle(test_event); + } + void HandleConnectionFailed() { TransportAdapterEvent test_event(EventTypeEnum::ON_CONNECT_FAIL, mock_adapter_, @@ -405,6 +423,32 @@ TEST_F(TransportManagerImplTest, DisconnectDevice_DeviceNotConnected) { EXPECT_EQ(E_INVALID_HANDLE, tm_.DisconnectDevice(device_handle_)); } +TEST_F(TransportManagerImplTest, Pending) { + // Calling HandlePending twice verifies the connection_id stays the same if + // the connection exists. + HandlePending(); + HandlePending(); + + // Now create pending event for new app id and verify connection_id is + // incremented + TransportAdapterEvent test_event(EventTypeEnum::ON_CONNECT_PENDING, + mock_adapter_, + dev_info_.mac_address(), + application_id_ + 1, + test_message_, + error_); + + EXPECT_CALL(*mock_adapter_, DeviceName(dev_info_.mac_address())) + .WillOnce(Return(dev_info_.name())); + EXPECT_CALL(*mock_adapter_, GetConnectionType()) + .WillRepeatedly(Return(dev_info_.connection_type())); + + EXPECT_CALL(*tm_listener_, + OnConnectionPending(dev_info_, connection_key_ + 1)); + + tm_.TestHandle(test_event); +} + TEST_F(TransportManagerImplTest, Disconnect) { // Arrange HandleConnection(); -- cgit v1.2.1