diff options
author | JackLivio <jack@livio.io> | 2019-03-17 15:40:55 -0400 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-03-17 15:40:55 -0400 |
commit | 12c02a9406277a43c43b0b069a12595534f6f7b5 (patch) | |
tree | f26bb8b6530fd786946fcf4df00774792342a2c6 | |
parent | 79ce3c927bf6b1c661bfb8174031370694ea9ff6 (diff) | |
parent | c6020f483bcd9739779ce4fa87c0065f0ae7cac8 (diff) | |
download | sdl_core-12c02a9406277a43c43b0b069a12595534f6f7b5.tar.gz |
Merge pull request #2842 from smartdevicelink/tests/cloud_app_disconnect+fix
Cloud App Disconnect Unit tests and fix
5 files changed, 305 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 cba9cdfd79..738458ef26 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 @@ -1581,6 +1581,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::RPCPluginManager>& 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 b4a0d442f0..8a8671c167 100644 --- a/src/components/application_manager/src/application_manager_impl.cc +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -1198,14 +1198,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() { @@ -2941,6 +2942,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 e88d10d3e0..c4ce498595 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 <bson_object.h> #include <stdint.h> #include <memory> #include <set> #include <string> #include <vector> -#include <bson_object.h> #include "application_manager/application.h" #include "application_manager/application_impl.h" @@ -45,6 +45,7 @@ #include "application_manager/mock_app_service_manager.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" @@ -61,8 +62,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 { @@ -74,15 +75,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; @@ -101,11 +103,14 @@ const std::string kAppName = "appName"; // Cloud application params const std::string kEndpoint = "endpoint"; +const std::string kEndpoint2 = "https://fakesdlcloudapptesting.com:8080"; const std::string kAuthToken = "auth_token"; const std::string kCertificate = "cert"; const std::string kTransportType = "WS"; const mobile_api::HybridAppPreference::eType kHybridAppPreference = mobile_api::HybridAppPreference::CLOUD; +const std::string kHybridAppPreferenceStr = "CLOUD"; +const bool kEnabled = true; } // namespace class ApplicationManagerImplTest : public ::testing::Test { @@ -116,6 +121,8 @@ class ApplicationManagerImplTest : public ::testing::Test { std::make_shared<NiceMock<resumption_test::MockResumptionData> >( mock_app_mngr_)) , mock_rpc_service_(new MockRPCService) + , mock_policy_handler_( + new test::components::policy_test::MockPolicyHandlerInterface) , mock_app_service_manager_( new MockAppServiceManager(mock_app_mngr_, mock_last_state_)) , mock_message_helper_( @@ -215,6 +222,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<policy_test::MockPolicySettings> mock_policy_settings_; std::shared_ptr<NiceMock<resumption_test::MockResumptionData> > mock_storage_; @@ -224,6 +233,8 @@ class ApplicationManagerImplTest : public ::testing::Test { NiceMock<con_test::MockConnectionHandler> mock_connection_handler_; NiceMock<protocol_handler_test::MockSessionObserver> mock_session_observer_; NiceMock<MockApplicationManagerSettings> mock_application_manager_settings_; + test::components::policy_test::MockPolicyHandlerInterface* + mock_policy_handler_; application_manager_test::MockApplicationManager mock_app_mngr_; std::unique_ptr<am::ApplicationManagerImpl> app_manager_impl_; MockAppServiceManager* mock_app_service_manager_; @@ -1434,6 +1445,105 @@ TEST_F(ApplicationManagerImplTest, EXPECT_TRUE(file_system::RemoveDirectory(kDirectoryName, true)); } +void ApplicationManagerImplTest::AddCloudAppToPendingDeviceMap() { + app_manager_impl_->SetMockPolicyHandler(mock_policy_handler_); + std::vector<std::string> enabled_apps{"1234"}; + EXPECT_CALL(*mock_policy_handler_, GetEnabledCloudApps(_)) + .WillOnce(SetArgReferee<0>(enabled_apps)); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(kEnabled), + SetArgReferee<2>(kEndpoint2), + SetArgReferee<3>(kCertificate), + SetArgReferee<4>(kAuthToken), + SetArgReferee<5>(kTransportType), + SetArgReferee<6>(kHybridAppPreferenceStr), + Return(true))); + + std::vector<std::string> 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", kEndpoint2, "CLOUD_WEBSOCKET"); + std::vector<std::string> nicknames{"CloudApp"}; + EXPECT_CALL(*mock_policy_handler_, GetInitialAppData(_, _, _)) + .WillOnce(DoAll(SetArgPointee<1>(nicknames), Return(true))); + std::vector<std::string> enabled_apps{"1234"}; + + EXPECT_CALL(*mock_policy_handler_, GetStatisticManager()) + .WillOnce(Return(std::shared_ptr<usage_statistics::StatisticsManager>( + new usage_statistics_test::MockStatisticsManager()))); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(kEnabled), + SetArgReferee<2>(kEndpoint2), + SetArgReferee<3>(kCertificate), + SetArgReferee<4>(kAuthToken), + SetArgReferee<5>(kTransportType), + SetArgReferee<6>(kHybridAppPreferenceStr), + 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", kEndpoint2, "CLOUD_WEBSOCKET"); + + std::vector<std::string> enabled_apps{"1234"}; + + EXPECT_CALL(*mock_policy_handler_, GetEnabledCloudApps(_)) + .WillOnce(SetArgReferee<0>(enabled_apps)); + EXPECT_CALL(*mock_policy_handler_, GetCloudAppParameters(_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(kEnabled), + SetArgReferee<2>(kEndpoint2), + SetArgReferee<3>(kCertificate), + SetArgReferee<4>(kAuthToken), + SetArgReferee<5>(kTransportType), + SetArgReferee<6>(kHybridAppPreferenceStr), + Return(true))); + + std::vector<std::string> 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<plugin_manager::RPCPluginManager> 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<MockApplication> waiting_app = @@ -1548,6 +1658,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<MockDevice> mockdev = + std::make_shared<MockDevice>(dev_id, uniq_id); + DeviceVector devices{mockdev}; + transport_adapter.SearchDeviceDone(devices); + + // Create cloud app device with connection in pending state + std::shared_ptr<MockConnection> connection = + std::make_shared<MockConnection>(); + 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<std::string> 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<MockDevice> mockdev = + std::make_shared<MockDevice>(dev_id, uniq_id); + DeviceVector devices{mockdev}; + transport_adapter.SearchDeviceDone(devices); + + // Create cloud app device with connection in pending state + std::shared_ptr<MockConnection> connection = + std::make_shared<MockConnection>(); + 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<std::string> 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> 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<MockConnection>(); + 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<MockDevice> mockdev2 = + std::make_shared<MockDevice>(dev_id, uniq_id); + DeviceVector devices2{mockdev2}; + transport_adapter.SearchDeviceDone(devices2); + + std::shared_ptr<MockConnection> connection2 = + std::make_shared<MockConnection>(); + 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(); |