Add tests for RegisterApplication and RetryConnection

6 files changed, 277 insertions, 39 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 d7c03e0fa0..a3e3cece72 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
@@ -1499,12 +1499,28 @@ class ApplicationManagerImpl
   void AddMockApplication(ApplicationSharedPtr mock_app);
 
   /**
+   * @brief Add a mock application to the pending application list without going
+   * through the formal registration process. Only for unit testing.
+   * @param mock_app the mock app to be added to the pending application list
+   */
+  void AddMockPendingApplication(ApplicationSharedPtr mock_app);
+
+  /**
    * @brief set a mock media manager without running Init(). Only for unit
    * testing.
-   * @param mock_app the mock app to be registered
+   * @param mock_media_manager the mock media manager to be assigned
    */
   void SetMockMediaManager(media_manager::MediaManager* mock_media_manager);
 
+  /**
+   * @brief set a mock rpc service directly. Only for unit
+   * testing.
+   * @param mock_app the mock rpc service to be assigned
+   */
+  void SetMockRPCService(rpc_service::RPCService* rpc_service) {
+    rpc_service_.reset(rpc_service);
+  }
+
   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 8fd7f9e455..d2d2458ac0 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -614,6 +614,7 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   PolicyAppIdPredicate finder(application->policy_app_id());
   ApplicationSet::iterator it =
       std::find_if(apps_to_register_.begin(), apps_to_register_.end(), finder);
+  bool is_mismatched_cloud_app = false;
 
   if (apps_to_register_.end() == it) {
     DevicePredicate finder(application->device());
@@ -621,24 +622,8 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
         apps_to_register_.begin(), apps_to_register_.end(), finder);
 
     bool found = apps_to_register_.end() != it;
-    bool is_mismatched_cloud_app = found && (*it)->is_cloud_app() &&
-                                   policy_app_id != (*it)->policy_app_id();
-
-    // Reject registration request if a cloud app registers with the incorrect
-    // appID
-    if (is_mismatched_cloud_app) {
-      std::shared_ptr<smart_objects::SmartObject> response(
-          MessageHelper::CreateNegativeResponse(
-              connection_key,
-              mobile_apis::FunctionID::RegisterAppInterfaceID,
-              message[strings::params][strings::correlation_id].asUInt(),
-              mobile_apis::Result::DISALLOWED));
-      (*response)[strings::msg_params][strings::info] =
-          "Cloud app registered with incorrect app id";
-      rpc_service_->ManageMobileCommand(response,
-                                        commands::Command::SOURCE_SDL);
-      return ApplicationSharedPtr();
-    }
+    is_mismatched_cloud_app = found && (*it)->is_cloud_app() &&
+                              policy_app_id != (*it)->policy_app_id();
   } else {
     application->set_hmi_application_id((*it)->hmi_app_id());
 
@@ -653,6 +638,21 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   }
   apps_to_register_list_lock_ptr_->Release();
 
+  // Reject registration request if a cloud app registers with the incorrect
+  // appID
+  if (is_mismatched_cloud_app) {
+    std::shared_ptr<smart_objects::SmartObject> response(
+        MessageHelper::CreateNegativeResponse(
+            connection_key,
+            mobile_apis::FunctionID::RegisterAppInterfaceID,
+            message[strings::params][strings::correlation_id].asUInt(),
+            mobile_apis::Result::DISALLOWED));
+    (*response)[strings::msg_params][strings::info] =
+        "Cloud app registered with incorrect app id";
+    rpc_service_->ManageMobileCommand(response, commands::Command::SOURCE_SDL);
+    return ApplicationSharedPtr();
+  }
+
   if (!application->hmi_app_id()) {
     const bool is_saved =
         resume_controller().IsApplicationSaved(policy_app_id, device_mac);
@@ -3813,6 +3813,13 @@ void ApplicationManagerImpl::AddMockApplication(ApplicationSharedPtr mock_app) {
   applications_list_lock_ptr_->Release();
 }
 
+void ApplicationManagerImpl::AddMockPendingApplication(
+    ApplicationSharedPtr mock_app) {
+  apps_to_register_list_lock_ptr_->Acquire();
+  apps_to_register_.insert(mock_app);
+  apps_to_register_list_lock_ptr_->Release();
+}
+
 void ApplicationManagerImpl::SetMockMediaManager(
     media_manager::MediaManager* mock_media_manager) {
   media_manager_ = mock_media_manager;
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 7e57b51329..4ea44e5aca 100644
--- a/src/components/application_manager/test/application_manager_impl_test.cc
+++ b/src/components/application_manager/test/application_manager_impl_test.cc
@@ -96,6 +96,14 @@ connection_handler::DeviceHandle kDeviceId = 12345u;
 const std::string kAppId = "someID";
 const uint32_t kConnectionKey = 1232u;
 const std::string kAppName = "appName";
+
+// Cloud application params
+const std::string kEndpoint = "endpoint";
+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;
 }  // namespace
 
 class ApplicationManagerImplTest : public ::testing::Test {
@@ -122,11 +130,11 @@ class ApplicationManagerImplTest : public ::testing::Test {
  protected:
   void SetUp() OVERRIDE {
     CreateAppManager();
-    ON_CALL(mock_connection_handler_, GetDataOnSessionKey(_, _, _, &kDeviceId))
-        .WillByDefault(DoAll(SetArgPointee<3u>(app_id_), Return(0)));
+    ON_CALL(mock_session_observer_, GetDataOnSessionKey(_, _, _, _))
+        .WillByDefault(DoAll(SetArgPointee<3u>(kDeviceId), Return(0)));
     ON_CALL(mock_connection_handler_, get_session_observer())
         .WillByDefault(ReturnRef(mock_session_observer_));
-    app_manager_impl_->SetRPCService(mock_rpc_service_);
+    app_manager_impl_->SetMockRPCService(mock_rpc_service_);
     app_manager_impl_->resume_controller().set_resumption_storage(
         mock_storage_);
     app_manager_impl_->set_connection_handler(&mock_connection_handler_);
@@ -200,7 +208,7 @@ class ApplicationManagerImplTest : public ::testing::Test {
   NiceMock<policy_test::MockPolicySettings> mock_policy_settings_;
   std::shared_ptr<NiceMock<resumption_test::MockResumptionData> > mock_storage_;
 
-  std::unique_ptr<rpc_service::RPCService> mock_rpc_service_;
+  MockRPCService* mock_rpc_service_;
   NiceMock<con_test::MockConnectionHandler> mock_connection_handler_;
   NiceMock<protocol_handler_test::MockSessionObserver> mock_session_observer_;
   NiceMock<MockApplicationManagerSettings> mock_application_manager_settings_;
@@ -1413,6 +1421,121 @@ TEST_F(ApplicationManagerImplTest,
   EXPECT_TRUE(file_system::RemoveDirectory(kDirectoryName, true));
 }
 
+TEST_F(ApplicationManagerImplTest,
+       RegisterApplication_CloudAppRegisterSuccess) {
+  std::shared_ptr<MockApplication> waiting_app =
+      std::make_shared<MockApplication>();
+  ON_CALL(*waiting_app, device()).WillByDefault(Return(kDeviceId));
+  EXPECT_CALL(*waiting_app, cloud_app_endpoint())
+      .WillOnce(ReturnRef(kEndpoint));
+  EXPECT_CALL(*waiting_app, cloud_app_auth_token())
+      .WillOnce(ReturnRef(kAuthToken));
+  EXPECT_CALL(*waiting_app, cloud_app_certificate())
+      .WillOnce(ReturnRef(kCertificate));
+  EXPECT_CALL(*waiting_app, cloud_app_transport_type())
+      .WillOnce(ReturnRef(kTransportType));
+  EXPECT_CALL(*waiting_app, hybrid_app_preference())
+      .WillOnce(ReturnRef(kHybridAppPreference));
+  ON_CALL(*waiting_app, is_cloud_app()).WillByDefault(Return(true));
+  EXPECT_CALL(*waiting_app, policy_app_id()).WillRepeatedly(Return(kAppId));
+  app_manager_impl_->AddMockPendingApplication(waiting_app);
+
+  EXPECT_CALL(
+      mock_session_observer_,
+      GetDataOnSessionKey(kConnectionKey,
+                          _,
+                          _,
+                          testing::An<connection_handler::DeviceHandle*>()))
+      .WillOnce(DoAll(SetArgPointee<3u>(kDeviceId), Return(0)));
+  EXPECT_CALL(*mock_rpc_service_,
+              ManageMobileCommand(_, commands::Command::SOURCE_SDL)).Times(0);
+  smart_objects::SmartObject request_for_registration(
+      smart_objects::SmartType_Map);
+
+  smart_objects::SmartObject& params =
+      request_for_registration[strings::msg_params];
+  params[strings::app_id] = kAppId;
+  params[strings::language_desired] = mobile_api::Language::EN_US;
+  params[strings::hmi_display_language_desired] = mobile_api::Language::EN_US;
+
+  request_for_registration[strings::params][strings::connection_key] =
+      kConnectionKey;
+  request_for_registration[strings::msg_params][strings::app_name] = kAppName;
+  request_for_registration[strings::msg_params][strings::sync_msg_version]
+                          [strings::minor_version] = APIVersion::kAPIV2;
+  request_for_registration[strings::msg_params][strings::sync_msg_version]
+                          [strings::major_version] = APIVersion::kAPIV3;
+
+  request_for_registration[strings::params][strings::protocol_version] =
+      protocol_handler::MajorProtocolVersion::PROTOCOL_VERSION_2;
+
+  smart_objects::SmartObjectSPtr request_for_registration_ptr =
+      std::make_shared<smart_objects::SmartObject>(request_for_registration);
+
+  ApplicationSharedPtr application =
+      app_manager_impl_->RegisterApplication(request_for_registration_ptr);
+
+  EXPECT_EQ(protocol_handler::MajorProtocolVersion::PROTOCOL_VERSION_2,
+            application->protocol_version());
+  EXPECT_EQ(APIVersion::kAPIV2,
+            application->version().min_supported_api_version);
+  EXPECT_EQ(APIVersion::kAPIV3,
+            application->version().max_supported_api_version);
+  EXPECT_EQ(kEndpoint, application->cloud_app_endpoint());
+  EXPECT_EQ(kAuthToken, application->cloud_app_auth_token());
+  EXPECT_EQ(kCertificate, application->cloud_app_certificate());
+  EXPECT_EQ(kTransportType, application->cloud_app_transport_type());
+  EXPECT_EQ(kHybridAppPreference, application->hybrid_app_preference());
+}
+
+TEST_F(ApplicationManagerImplTest,
+       RegisterApplication_CloudAppRegisterFailed_DISALLOWED) {
+  std::shared_ptr<MockApplication> waiting_app =
+      std::make_shared<MockApplication>();
+  EXPECT_CALL(*waiting_app, device()).WillRepeatedly(Return(kDeviceId));
+  EXPECT_CALL(*waiting_app, is_cloud_app()).WillRepeatedly(Return(true));
+  EXPECT_CALL(*waiting_app, policy_app_id())
+      .WillRepeatedly(Return("Fake" + kAppId));
+  app_manager_impl_->AddMockPendingApplication(waiting_app);
+
+  EXPECT_CALL(
+      mock_session_observer_,
+      GetDataOnSessionKey(kConnectionKey,
+                          _,
+                          _,
+                          testing::An<connection_handler::DeviceHandle*>()))
+      .WillOnce(DoAll(SetArgPointee<3u>(kDeviceId), Return(0)));
+  EXPECT_CALL(*mock_rpc_service_,
+              ManageMobileCommand(_, commands::Command::SOURCE_SDL))
+      .WillOnce(Return(true));
+  smart_objects::SmartObject request_for_registration(
+      smart_objects::SmartType_Map);
+
+  smart_objects::SmartObject& params =
+      request_for_registration[strings::msg_params];
+  params[strings::app_id] = kAppId;
+  params[strings::language_desired] = mobile_api::Language::EN_US;
+  params[strings::hmi_display_language_desired] = mobile_api::Language::EN_US;
+
+  request_for_registration[strings::params][strings::connection_key] =
+      kConnectionKey;
+  request_for_registration[strings::msg_params][strings::app_name] = kAppName;
+  request_for_registration[strings::msg_params][strings::sync_msg_version]
+                          [strings::minor_version] = APIVersion::kAPIV2;
+  request_for_registration[strings::msg_params][strings::sync_msg_version]
+                          [strings::major_version] = APIVersion::kAPIV3;
+
+  request_for_registration[strings::params][strings::protocol_version] =
+      protocol_handler::MajorProtocolVersion::PROTOCOL_VERSION_2;
+
+  smart_objects::SmartObjectSPtr request_for_registration_ptr =
+      std::make_shared<smart_objects::SmartObject>(request_for_registration);
+
+  ApplicationSharedPtr application =
+      app_manager_impl_->RegisterApplication(request_for_registration_ptr);
+  EXPECT_EQ(0, application.use_count());
+}
+
 }  // application_manager_test
 }  // namespace components
 }  // namespace test
diff --git a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
index 7079a55264..8928ecb4d2 100644
--- a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
+++ b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
@@ -249,21 +249,21 @@ TransportAdapter::Error TransportAdapterImpl::ConnectDevice(
     if (FAIL == err && GetDeviceType() == DeviceType::CLOUD_WEBSOCKET) {
       LOG4CXX_TRACE(logger_,
                     "Error occurred while connecting cloud app: " << err);
-      if (device->connection_status() == ConnectionStatus::PENDING) {
-        device->set_connection_status(ConnectionStatus::RETRY);
-        device->reset_retry_count();
-        ConnectionStatusUpdated();
-      }
-
-      if (device->retry_count() >
+      // Update retry count
+      if (device->retry_count() >=
           get_settings().cloud_app_max_retry_attempts()) {
         device->set_connection_status(ConnectionStatus::PENDING);
         device->reset_retry_count();
         ConnectionStatusUpdated();
         return err;
+      } else if (device->connection_status() == ConnectionStatus::PENDING) {
+        device->set_connection_status(ConnectionStatus::RETRY);
+        ConnectionStatusUpdated();
       }
 
       device->next_retry();
+
+      // Start timer for next retry
       TimerSPtr retry_timer(std::make_shared<timer::Timer>(
           "RetryConnectionTimer",
           new timer::TimerTaskImpl<TransportAdapterImpl>(
@@ -296,6 +296,7 @@ void TransportAdapterImpl::RetryConnection() {
 }
 
 void TransportAdapterImpl::ClearCompletedTimers() {
+  // Cleanup any retry timers which have completed execution
   sync_primitives::AutoLock locker(completed_timer_pool_lock_);
   while (!completed_timer_pool_.empty()) {
     auto timer_entry = completed_timer_pool_.front();
@@ -312,8 +313,11 @@ DeviceUID TransportAdapterImpl::GetNextRetryDevice() {
   }
   auto timer_entry = retry_timer_pool_.front();
   retry_timer_pool_.pop();
+
+  // Store reference for cleanup later
   sync_primitives::AutoLock completed_locker(completed_timer_pool_lock_);
   completed_timer_pool_.push(timer_entry);
+
   return timer_entry.second;
 }
 
diff --git a/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_impl.h b/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_impl.h
index 384f55605a..e18d1bc53b 100644
--- a/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_impl.h
+++ b/src/components/transport_manager/test/include/transport_manager/transport_adapter/mock_transport_adapter_impl.h
@@ -70,15 +70,15 @@ class MockTransportAdapterImpl : public TransportAdapterImpl {
   }
   virtual ~MockTransportAdapterImpl() {}
 
-  virtual DeviceType GetDeviceType() const {
-    return DeviceType::UNKNOWN;
-  }
-
   MOCK_CONST_METHOD0(Store, void());
   MOCK_METHOD0(Restore, bool());
   MOCK_CONST_METHOD1(FindDevice,
                      transport_manager::transport_adapter::DeviceSptr(
                          const DeviceUID& device_id));
+  MOCK_METHOD0(ConnectionStatusUpdated, void());
+  MOCK_CONST_METHOD0(GetDeviceType,
+                     ::transport_manager::transport_adapter::DeviceType());
+  MOCK_METHOD0(RetryConnection, void());
 };
 
 }  // namespace transport_manager_test
diff --git a/src/components/transport_manager/test/transport_adapter_test.cc b/src/components/transport_manager/test/transport_adapter_test.cc
index 0a7db52c97..b917c60187 100644
--- a/src/components/transport_manager/test/transport_adapter_test.cc
+++ b/src/components/transport_manager/test/transport_adapter_test.cc
@@ -31,14 +31,15 @@
  */
 
 #include "gtest/gtest.h"
-#include "transport_manager/transport_adapter/mock_device_scanner.h"
+#include "transport_manager/mock_transport_manager_settings.h"
 #include "transport_manager/transport_adapter/mock_client_connection_listener.h"
-#include "transport_manager/transport_adapter/mock_server_connection_factory.h"
-#include "transport_manager/transport_adapter/mock_device.h"
 #include "transport_manager/transport_adapter/mock_connection.h"
-#include "transport_manager/transport_adapter/mock_transport_adapter_listener.h"
+#include "transport_manager/transport_adapter/mock_device.h"
+#include "transport_manager/transport_adapter/mock_device_scanner.h"
+#include "transport_manager/transport_adapter/mock_server_connection_factory.h"
 #include "transport_manager/transport_adapter/mock_transport_adapter_impl.h"
-#include "transport_manager/mock_transport_manager_settings.h"
+#include "transport_manager/transport_adapter/mock_transport_adapter_listener.h"
+#include "utils/test_async_waiter.h"
 
 #include "transport_manager/transport_adapter/transport_adapter_impl.h"
 #include "transport_manager/transport_adapter/transport_adapter_listener.h"
@@ -73,6 +74,11 @@ class TransportAdapterTest : public ::testing::Test {
         .WillByDefault(Return(true));
   }
 
+  void SetDefaultExpectations(MockTransportAdapterImpl& adapter) {
+    ON_CALL(adapter, GetDeviceType())
+        .WillByDefault(Return(DeviceType::UNKNOWN));
+  }
+
   NiceMock<MockTransportManagerSettings> transport_manager_settings;
   resumption::LastStateImpl last_state_;
   std::string dev_id;
@@ -89,6 +95,7 @@ TEST_F(TransportAdapterTest, Init) {
                                              clientMock,
                                              last_state_,
                                              transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -123,6 +130,7 @@ TEST_F(TransportAdapterTest, SearchDevices_DeviceNotInitialized) {
   MockDeviceScanner* dev_mock = new MockDeviceScanner();
   MockTransportAdapterImpl transport_adapter(
       dev_mock, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
@@ -138,6 +146,7 @@ TEST_F(TransportAdapterTest, SearchDevices_DeviceInitialized) {
   MockDeviceScanner* dev_mock = new MockDeviceScanner();
   MockTransportAdapterImpl transport_adapter(
       dev_mock, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
@@ -153,6 +162,7 @@ TEST_F(TransportAdapterTest, SearchDevices_DeviceInitialized) {
 TEST_F(TransportAdapterTest, SearchDeviceDone_DeviceExisting) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -169,6 +179,7 @@ TEST_F(TransportAdapterTest, SearchDeviceDone_DeviceExisting) {
 TEST_F(TransportAdapterTest, SearchDeviceFailed) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -183,6 +194,7 @@ TEST_F(TransportAdapterTest, SearchDeviceFailed) {
 TEST_F(TransportAdapterTest, AddDevice) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -200,6 +212,7 @@ TEST_F(TransportAdapterTest, Connect_ServerNotSupported) {
   MockClientConnectionListener* clientMock = new MockClientConnectionListener();
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, clientMock, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
@@ -217,6 +230,7 @@ TEST_F(TransportAdapterTest, Connect_ServerNotInitialized) {
   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));
@@ -234,6 +248,7 @@ TEST_F(TransportAdapterTest, Connect_Success) {
   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));
@@ -252,6 +267,7 @@ TEST_F(TransportAdapterTest, Connect_DeviceAddedTwice) {
   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));
@@ -274,6 +290,7 @@ TEST_F(TransportAdapterTest, Connect_DeviceAddedTwice) {
 TEST_F(TransportAdapterTest, ConnectDevice_ServerNotAdded_DeviceAdded) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -292,12 +309,14 @@ TEST_F(TransportAdapterTest, ConnectDevice_ServerNotAdded_DeviceAdded) {
 
   TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::FAIL, res);
+  EXPECT_NE(ConnectionStatus::CONNECTED, mockdev->connection_status());
 }
 
 TEST_F(TransportAdapterTest, ConnectDevice_DeviceNotAdded) {
   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();
@@ -318,6 +337,7 @@ TEST_F(TransportAdapterTest, ConnectDevice_DeviceAdded) {
   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));
@@ -339,16 +359,58 @@ TEST_F(TransportAdapterTest, ConnectDevice_DeviceAdded) {
   EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
       .WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::OK, res);
+  EXPECT_EQ(ConnectionStatus::CONNECTED, mockdev->connection_status());
 
   EXPECT_CALL(*serverMock, Terminate());
 }
 
+TEST_F(TransportAdapterTest, ConnectDevice_DeviceAdded_ConnectFailedRetry) {
+  MockServerConnectionFactory* server_mock = new MockServerConnectionFactory();
+  MockTransportAdapterImpl transport_adapter(
+      NULL, server_mock, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
+  // transport_adapter.SetDeviceType(DeviceType::CLOUD_WEBSOCKET);
+
+  EXPECT_CALL(*server_mock, Init()).WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
+  transport_adapter.Init();
+
+  std::shared_ptr<MockDevice> mockdev =
+      std::make_shared<MockDevice>(dev_id, uniq_id);
+  transport_adapter.AddDevice(mockdev);
+
+  std::vector<std::string> dev_list = transport_adapter.GetDeviceList();
+  ASSERT_EQ(1u, dev_list.size());
+  EXPECT_EQ(uniq_id, dev_list[0]);
+
+  int app_handle = 1;
+  std::vector<int> int_list = {app_handle};
+  EXPECT_CALL(*mockdev, GetApplicationList()).WillOnce(Return(int_list));
+
+  EXPECT_CALL(*server_mock, IsInitialised()).WillOnce(Return(true));
+  EXPECT_CALL(*server_mock, CreateConnection(uniq_id, app_handle))
+      .WillOnce(Return(TransportAdapter::FAIL));
+  EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, GetDeviceType())
+      .WillOnce(Return(DeviceType::CLOUD_WEBSOCKET));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
+  EXPECT_CALL(transport_manager_settings, cloud_app_max_retry_attempts())
+      .WillOnce(Return(0));
+  TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
+  EXPECT_EQ(TransportAdapter::FAIL, res);
+  EXPECT_EQ(ConnectionStatus::PENDING, mockdev->connection_status());
+
+  EXPECT_CALL(*server_mock, Terminate());
+}
+
 TEST_F(TransportAdapterTest, ConnectDevice_DeviceAddedTwice) {
   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));
@@ -370,8 +432,10 @@ TEST_F(TransportAdapterTest, ConnectDevice_DeviceAddedTwice) {
   EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
       .WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::OK, res);
+  EXPECT_EQ(ConnectionStatus::CONNECTED, mockdev->connection_status());
 
   // Try to connect device second time
 
@@ -380,8 +444,10 @@ TEST_F(TransportAdapterTest, ConnectDevice_DeviceAddedTwice) {
   EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
   EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle)).Times(0);
   EXPECT_CALL(transport_adapter, FindDevice(uniq_id)).WillOnce(Return(mockdev));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   TransportAdapter::Error newres = transport_adapter.ConnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::OK, newres);
+  EXPECT_EQ(ConnectionStatus::CONNECTED, mockdev->connection_status());
 
   EXPECT_CALL(*serverMock, Terminate());
 }
@@ -390,6 +456,7 @@ TEST_F(TransportAdapterTest, Disconnect_ConnectDoneSuccess) {
   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));
@@ -420,6 +487,7 @@ TEST_F(TransportAdapterTest, DisconnectDevice_DeviceAddedConnectionCreated) {
   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));
@@ -441,8 +509,10 @@ TEST_F(TransportAdapterTest, DisconnectDevice_DeviceAddedConnectionCreated) {
       .WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(transport_adapter, FindDevice(uniq_id))
       .WillRepeatedly(Return(mockdev));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   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, uniq_id, app_handle);
@@ -450,8 +520,10 @@ TEST_F(TransportAdapterTest, DisconnectDevice_DeviceAddedConnectionCreated) {
   EXPECT_CALL(*mock_connection, Disconnect())
       .WillOnce(Return(TransportAdapter::OK));
 
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   TransportAdapter::Error new_res = transport_adapter.DisconnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::OK, new_res);
+  EXPECT_EQ(ConnectionStatus::CLOSING, mockdev->connection_status());
 
   EXPECT_CALL(*serverMock, Terminate());
 }
@@ -460,6 +532,7 @@ TEST_F(TransportAdapterTest, DeviceDisconnected) {
   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));
@@ -483,8 +556,10 @@ TEST_F(TransportAdapterTest, DeviceDisconnected) {
   EXPECT_CALL(*serverMock, IsInitialised()).WillOnce(Return(true));
   EXPECT_CALL(*serverMock, CreateConnection(uniq_id, app_handle))
       .WillOnce(Return(TransportAdapter::OK));
+  EXPECT_CALL(transport_adapter, ConnectionStatusUpdated());
   TransportAdapter::Error res = transport_adapter.ConnectDevice(uniq_id);
   EXPECT_EQ(TransportAdapter::OK, res);
+  EXPECT_EQ(ConnectionStatus::CONNECTED, mockdev->connection_status());
 
   std::shared_ptr<MockConnection> mock_connection =
       std::make_shared<MockConnection>();
@@ -508,6 +583,7 @@ TEST_F(TransportAdapterTest, AbortedConnectSuccess) {
   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));
@@ -534,6 +610,7 @@ TEST_F(TransportAdapterTest, SendData) {
   MockServerConnectionFactory* serverMock = new MockServerConnectionFactory();
   MockTransportAdapterImpl transport_adapter(
       dev_mock, serverMock, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*serverMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -575,6 +652,7 @@ TEST_F(TransportAdapterTest, SendData_ConnectionNotEstablished) {
                                              clientMock,
                                              last_state_,
                                              transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -610,6 +688,7 @@ TEST_F(TransportAdapterTest, StartClientListening_ClientNotInitialized) {
   MockClientConnectionListener* clientMock = new MockClientConnectionListener();
   MockTransportAdapterImpl transport_adapter(
       dev_mock, NULL, clientMock, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -631,6 +710,7 @@ TEST_F(TransportAdapterTest, StartClientListening) {
   MockClientConnectionListener* clientMock = new MockClientConnectionListener();
   MockTransportAdapterImpl transport_adapter(
       dev_mock, NULL, clientMock, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -657,6 +737,7 @@ TEST_F(TransportAdapterTest, StopClientListening_Success) {
                                              clientMock,
                                              last_state_,
                                              transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -691,6 +772,7 @@ TEST_F(TransportAdapterTest, FindNewApplicationsRequest) {
                                              clientMock,
                                              last_state_,
                                              transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   EXPECT_CALL(*dev_mock, Init()).WillOnce(Return(TransportAdapter::OK));
   EXPECT_CALL(*clientMock, Init()).WillOnce(Return(TransportAdapter::OK));
@@ -712,6 +794,7 @@ TEST_F(TransportAdapterTest, FindNewApplicationsRequest) {
 TEST_F(TransportAdapterTest, GetDeviceAndApplicationLists) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -736,6 +819,7 @@ TEST_F(TransportAdapterTest, FindEstablishedConnection) {
   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));
@@ -765,6 +849,7 @@ TEST_F(TransportAdapterTest, RunAppOnDevice_NoDeviseWithAskedId_UNSUCCESS) {
 
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   std::shared_ptr<MockDevice> mock_device =
       std::make_shared<MockDevice>("test_device_name", "test_device_uid0");
@@ -784,6 +869,7 @@ TEST_F(TransportAdapterTest, RunAppOnDevice_DeviseWithAskedIdWasFound_SUCCESS) {
 
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
 
   std::shared_ptr<MockDevice> mock_device =
       std::make_shared<MockDevice>("test_device_name", device_uid);
@@ -815,6 +901,7 @@ TEST_F(TransportAdapterTest, StopDevice) {
 TEST_F(TransportAdapterTest, TransportConfigUpdated) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();
 
@@ -833,6 +920,7 @@ TEST_F(TransportAdapterTest, TransportConfigUpdated) {
 TEST_F(TransportAdapterTest, GetTransportConfigration) {
   MockTransportAdapterImpl transport_adapter(
       NULL, NULL, NULL, last_state_, transport_manager_settings);
+  SetDefaultExpectations(transport_adapter);
   EXPECT_CALL(transport_adapter, Restore()).WillOnce(Return(true));
   transport_adapter.Init();