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();