1 files changed, 245 insertions, 40 deletions

diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
index fc3899e861..fe6ba7c4e3 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
@@ -33,17 +33,17 @@
 #include <stdint.h>
 #include <string>
 
-#include "gtest/gtest.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/smart_object_keys.h"
-#include "utils/lock.h"
-#include "utils/data_accessor.h"
 #include "application_manager/commands/commands_test.h"
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_application_manager.h"
 #include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/smart_object_keys.h"
+#include "gtest/gtest.h"
 #include "hmi/on_driver_distraction_notification.h"
 #include "interfaces/MOBILE_API.h"
+#include "smart_objects/smart_object.h"
+#include "utils/data_accessor.h"
+#include "utils/lock.h"
 
 namespace test {
 namespace components {
@@ -52,22 +52,65 @@ namespace hmi_commands_test {
 namespace on_driver_distraction_notification {
 
 using ::testing::_;
-using ::testing::Return;
+using ::testing::DoAll;
 using ::testing::Eq;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::SetArgumentPointee;
+
 namespace am = ::application_manager;
 using am::commands::MessageSharedPtr;
 using sdl_rpc_plugin::commands::hmi::OnDriverDistractionNotification;
 using namespace am::commands;
+using test::components::commands_test::MobileResultCodeIs;
+
+namespace {
+const std::string kDefaultLanguage = "en-us";
+const mobile_apis::Language::eType kMobileLanguage =
+    mobile_apis::Language::EN_US;
 
-typedef std::shared_ptr<OnDriverDistractionNotification> NotificationPtr;
+// LSDW - lock screen dismissal warning
+const std::string kLockScreenDismissalWarningMessage_en =
+    "Swipe down to dismiss, acknowledging that you are not the driver";
+const uint32_t kConnectionKey = 2u;
+}  // namespace
 
 class HMIOnDriverDistractionNotificationTest
     : public CommandsTest<CommandsTestMocks::kIsNice> {
  public:
   HMIOnDriverDistractionNotificationTest()
-      : app_set_lock_(std::make_shared<sync_primitives::Lock>()) {}
+      : mock_app_(CreateMockApp())
+      , app_set_lock_(std::make_shared<sync_primitives::Lock>())
+      , accessor(app_set_, app_set_lock_) {
+    app_set_.insert(mock_app_);
+    InitMocksRelations();
+  }
+
+  typedef std::shared_ptr<OnDriverDistractionNotification> NotificationPtr;
+  typedef boost::optional<bool> OptionalBool;
+
+  void SetUp() OVERRIDE {
+    ON_CALL(*mock_app_, ui_language())
+        .WillByDefault(ReturnRef(kMobileLanguage));
+    ON_CALL(app_mngr_, application(kConnectionKey))
+        .WillByDefault(Return(mock_app_));
+    ON_CALL(mock_message_helper_, MobileLanguageToString(kMobileLanguage))
+        .WillByDefault(Return(kDefaultLanguage));
+  }
+
+  MockAppPtr mock_app_;
   std::shared_ptr<sync_primitives::Lock> app_set_lock_;
-  policy_test::MockPolicyHandlerInterface mock_policy_handler_interface_;
+  am::ApplicationSet app_set_;
+  DataAccessor<am::ApplicationSet> accessor;
+  NiceMock<policy_test::MockPolicyHandlerInterface>
+      mock_policy_handler_interface_;
+
+  void InitMocksRelations() {
+    ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor));
+    ON_CALL(app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_interface_));
+  }
 };
 
 MATCHER_P2(CheckNotificationParams, function_id, state, "") {
@@ -83,76 +126,238 @@ MATCHER_P2(CheckNotificationParams, function_id, state, "") {
   return is_function_id_matched && is_state_matched;
 }
 
-ACTION_P(GetArg3, result) {
-  arg3 = *result;
+ACTION_P(GetArg4, result) {
+  arg4 = *result;
 }
 
-TEST_F(HMIOnDriverDistractionNotificationTest, Run_PushMobileMessage_SUCCESS) {
-  const hmi_apis::Common_DriverDistractionState::eType state =
-      hmi_apis::Common_DriverDistractionState::DD_ON;
+ACTION_P(SetMessage, lockScreenDismissalWarning) {
+  smart_objects::SmartObject& notification = arg0;
+
+  notification[application_manager::strings::msg_params]
+              [application_manager::mobile_notification::
+                   lock_screen_dismissal_warning] = lockScreenDismissalWarning;
+}
+
+TEST_F(HMIOnDriverDistractionNotificationTest,
+       Run_SendNotificationToMobile_SUCCESS) {
+  const auto state = hmi_apis::Common_DriverDistractionState::DD_ON;
   MessageSharedPtr commands_msg(CreateMessage(smart_objects::SmartType_Map));
   (*commands_msg)[am::strings::msg_params][am::hmi_notification::state] = state;
+  (*commands_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
 
   NotificationPtr command(
       CreateCommand<OnDriverDistractionNotification>(commands_msg));
 
   EXPECT_CALL(app_mngr_, set_driver_distraction_state(Eq(state)));
 
-  MockAppPtr mock_app = CreateMockApp();
-  am::ApplicationSet app_set;
-  app_set.insert(mock_app);
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalEnabledState())
+      .WillByDefault(Return(OptionalBool(true)));
+
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalWarningMessage(_))
+      .WillByDefault(Return(kLockScreenDismissalWarningMessage_en));
+
+  policy::CheckPermissionResult result;
+  result.hmi_level_permitted = policy::kRpcAllowed;
+  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _, _))
+      .WillOnce(GetArg4(&result));
+
+  MessageSharedPtr message_to_mobile(
+      CreateMessage(smart_objects::SmartType_Map));
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(
+                  CheckNotificationParams(
+                      am::mobile_api::FunctionID::OnDriverDistractionID, state),
+                  Command::CommandSource::SOURCE_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&message_to_mobile), Return(true)));
+  command->Run();
+
+  ASSERT_TRUE((*message_to_mobile)[am::strings::msg_params].keyExists(
+      am::mobile_notification::lock_screen_dismissal_warning));
+
+  auto LSDW_message =
+      (*message_to_mobile)
+          [am::strings::msg_params]
+          [am::mobile_notification::lock_screen_dismissal_warning]
+              .asString();
+
+  EXPECT_EQ(kLockScreenDismissalWarningMessage_en, LSDW_message);
+}
+
+TEST_F(HMIOnDriverDistractionNotificationTest,
+       Run_PushMobileMessage_If_DisallowedByPolicy) {
+  const auto state = hmi_apis::Common_DriverDistractionState::DD_ON;
+  MessageSharedPtr commands_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*commands_msg)[am::strings::msg_params][am::hmi_notification::state] = state;
+  (*commands_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
+  NotificationPtr command(
+      CreateCommand<OnDriverDistractionNotification>(commands_msg));
+
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalEnabledState())
+      .WillByDefault(Return(boost::optional<bool>(true)));
+
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalWarningMessage(_))
+      .WillByDefault(Return(kLockScreenDismissalWarningMessage_en));
 
-  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
   policy::CheckPermissionResult result;
   result.hmi_level_permitted = policy::kRpcDisallowed;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler())
-      .WillOnce(ReturnRef(mock_policy_handler_interface_));
-  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _))
-      .WillOnce(GetArg3(&result));
+  EXPECT_CALL(app_mngr_, GetPolicyHandler()).Times(3);
+  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _, _))
+      .WillOnce(GetArg4(&result));
 
-  EXPECT_CALL(*mock_app,
+  MessageSharedPtr pushed_message(CreateMessage(smart_objects::SmartType_Map));
+  EXPECT_CALL(*mock_app_,
               PushMobileMessage(CheckNotificationParams(
-                  am::mobile_api::FunctionID::OnDriverDistractionID, state)));
+                  am::mobile_api::FunctionID::OnDriverDistractionID, state)))
+      .WillOnce(SaveArg<0>(&pushed_message));
 
+  EXPECT_CALL(app_mngr_, set_driver_distraction_state(Eq(state)));
   command->Run();
+
+  ASSERT_TRUE((*pushed_message)[am::strings::msg_params].keyExists(
+      am::mobile_notification::lock_screen_dismissal_warning));
+
+  auto lock_screen_dismissal_warning_message =
+      (*pushed_message)[am::strings::msg_params]
+                       [am::mobile_notification::lock_screen_dismissal_warning]
+                           .asString();
+
+  EXPECT_EQ(kLockScreenDismissalWarningMessage_en,
+            lock_screen_dismissal_warning_message);
 }
 
 TEST_F(HMIOnDriverDistractionNotificationTest,
-       Run_SendNotificationToMobile_SUCCESS) {
-  const hmi_apis::Common_DriverDistractionState::eType state =
-      hmi_apis::Common_DriverDistractionState::DD_ON;
+       Run_SendNotificationIfLockScreenDismissalMissed) {
+  const auto state = hmi_apis::Common_DriverDistractionState::DD_ON;
   MessageSharedPtr commands_msg(CreateMessage(smart_objects::SmartType_Map));
   (*commands_msg)[am::strings::msg_params][am::hmi_notification::state] = state;
 
   NotificationPtr command(
       CreateCommand<OnDriverDistractionNotification>(commands_msg));
 
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalEnabledState())
+      .WillByDefault(Return(boost::optional<bool>()));
+
+  policy::CheckPermissionResult result;
+  result.hmi_level_permitted = policy::kRpcAllowed;
+  ON_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _, _))
+      .WillByDefault(GetArg4(&result));
+
+  MessageSharedPtr command_result;
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(_, Command::CommandSource::SOURCE_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true)));
+
+  command->Run();
+
+  auto& msg_params =
+      (*command_result)[application_manager::strings::msg_params];
+  EXPECT_FALSE(msg_params.keyExists(
+      application_manager::mobile_notification::lock_screen_dismissal_enabled));
+  EXPECT_FALSE(msg_params.keyExists(
+      application_manager::mobile_notification::lock_screen_dismissal_warning));
+}
+
+// LSDW - lock screen dimissal
+TEST_F(HMIOnDriverDistractionNotificationTest,
+       Run_SendNotificationToMobile_LSDWMessageIsAbsent_SUCCESS) {
+  const auto state = hmi_apis::Common_DriverDistractionState::DD_ON;
+  MessageSharedPtr commands_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*commands_msg)[am::strings::msg_params][am::hmi_notification::state] = state;
+  (*commands_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
+
+  NotificationPtr command(
+      CreateCommand<OnDriverDistractionNotification>(commands_msg));
+
   EXPECT_CALL(app_mngr_, set_driver_distraction_state(Eq(state)));
 
-  MockAppPtr mock_app = CreateMockApp();
-  am::ApplicationSet app_set;
-  app_set.insert(mock_app);
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalEnabledState())
+      .WillByDefault(Return(OptionalBool(false)));
 
-  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_);
-  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
+  // LockScreenDismissalWarning won't be added to message if value of
+  // LockScreenDismissalEnabledState is false
+  std::string required_language = "en-us";
+  EXPECT_CALL(mock_policy_handler_interface_,
+              LockScreenDismissalWarningMessage(required_language))
+      .Times(0);
 
   policy::CheckPermissionResult result;
   result.hmi_level_permitted = policy::kRpcAllowed;
-  EXPECT_CALL(app_mngr_, GetPolicyHandler())
-      .WillOnce(ReturnRef(mock_policy_handler_interface_));
-  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _))
-      .WillOnce(GetArg3(&result));
+  MessageSharedPtr message_to_mobile(
+      CreateMessage(smart_objects::SmartType_Map));
+  EXPECT_CALL(app_mngr_, GetPolicyHandler()).Times(2);
+  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _, _))
+      .WillOnce(GetArg4(&result));
   EXPECT_CALL(mock_rpc_service_,
               ManageMobileCommand(
                   CheckNotificationParams(
                       am::mobile_api::FunctionID::OnDriverDistractionID, state),
-                  Command::CommandSource::SOURCE_SDL));
-
+                  Command::CommandSource::SOURCE_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&message_to_mobile), Return(true)));
   command->Run();
+
+  EXPECT_FALSE((*message_to_mobile)[am::strings::msg_params].keyExists(
+      am::mobile_notification::lock_screen_dismissal_warning));
 }
 
-}  // on_driver_distraction_notification
+TEST_F(HMIOnDriverDistractionNotificationTest,
+       Run_SendNotificationToMobile_SpecifiedLanguageIsAbsent_SUCCESS) {
+  const auto state = hmi_apis::Common_DriverDistractionState::DD_ON;
+  MessageSharedPtr commands_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*commands_msg)[am::strings::msg_params][am::hmi_notification::state] = state;
+  (*commands_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
+
+  NotificationPtr command(
+      CreateCommand<OnDriverDistractionNotification>(commands_msg));
+
+  EXPECT_CALL(app_mngr_, set_driver_distraction_state(Eq(state)));
+
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalEnabledState())
+      .WillByDefault(Return(OptionalBool(true)));
+
+  ON_CALL(mock_policy_handler_interface_, LockScreenDismissalWarningMessage(_))
+      .WillByDefault(Return(kLockScreenDismissalWarningMessage_en));
+
+  // In case when specified language is absent in policy table, will added
+  // message on default language (en-us)
+  const mobile_apis::Language::eType mobile_language =
+      mobile_apis::Language::FR_FR;
+  std::string required_language = "FR-FR";
+  ON_CALL(*mock_app_, ui_language()).WillByDefault(ReturnRef(mobile_language));
+  ON_CALL(mock_message_helper_, MobileLanguageToString(mobile_language))
+      .WillByDefault(Return(required_language));
+
+  policy::CheckPermissionResult result;
+  result.hmi_level_permitted = policy::kRpcAllowed;
+  EXPECT_CALL(mock_policy_handler_interface_, CheckPermissions(_, _, _, _, _))
+      .WillOnce(GetArg4(&result));
+
+  MessageSharedPtr message_to_mobile(
+      CreateMessage(smart_objects::SmartType_Map));
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(
+                  CheckNotificationParams(
+                      am::mobile_api::FunctionID::OnDriverDistractionID, state),
+                  Command::CommandSource::SOURCE_SDL))
+      .WillOnce(DoAll(SaveArg<0>(&message_to_mobile), Return(true)));
+  command->Run();
+
+  ASSERT_TRUE((*message_to_mobile)[am::strings::msg_params].keyExists(
+      am::mobile_notification::lock_screen_dismissal_warning));
+
+  auto lock_screen_dismissal_warning_message =
+      (*message_to_mobile)
+          [am::strings::msg_params]
+          [am::mobile_notification::lock_screen_dismissal_warning]
+              .asString();
+
+  EXPECT_EQ(kLockScreenDismissalWarningMessage_en,
+            lock_screen_dismissal_warning_message);
+}
+}  // namespace on_driver_distraction_notification
 }  // namespace hmi_commands_test
 }  // namespace commands_test
 }  // namespace components