diff options
Diffstat (limited to 'src/components/application_manager/test/help_prompt_manager_test.cc')
| -rw-r--r-- | src/components/application_manager/test/help_prompt_manager_test.cc | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/src/components/application_manager/test/help_prompt_manager_test.cc b/src/components/application_manager/test/help_prompt_manager_test.cc new file mode 100644 index 0000000000..f921eb1dde --- /dev/null +++ b/src/components/application_manager/test/help_prompt_manager_test.cc @@ -0,0 +1,369 @@ +/* + * Copyright (c) 2018, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "application_manager/application_impl.h" +#include "application_manager/commands/command_request_test.h" +#include "application_manager/commands/commands_test.h" +#include "application_manager/hmi_state.h" +#include "application_manager/mock_application.h" +#include "application_manager/mock_event_dispatcher.h" +#include "application_manager/mock_help_prompt_manager.h" +#include "application_manager/mock_message_helper.h" +#include "application_manager/mock_resumption_data.h" +#include "connection_handler/mock_connection_handler.h" +#include "gtest/gtest.h" +#include "policy/usage_statistics/mock_statistics_manager.h" +#include "protocol_handler/mock_session_observer.h" +#include "sdl_rpc_plugin/commands/mobile/set_global_properties_request.h" +#include "utils/file_system.h" + +namespace test { +namespace components { +namespace application_manager_test { + +namespace { +const uint32_t kConnectionKey = 1u; +const uint32_t kCorrelationKey = 2u; +const uint32_t kAppId = 10u; +const uint32_t kCmdId = 1u; +const std::string kPolicyAppId = "fake_app_id"; +const uint32_t kTimeout = 10000u; +const std::string kText = "one"; +const uint32_t kPosition = 1u; +const std::string kFirstVrCommand = "first"; +const int32_t kGrammarId = 12; +const std::string kDirectoryName = "./test_storage"; +const uint8_t expected_tread_pool_size = 2u; +const uint8_t stop_streaming_timeout = 1u; +const std::vector<std::string> kTimeoutPrompt{"timeoutPrompt"}; +} // namespace + +using namespace application_manager; +using namespace policy; +using namespace test::components::commands_test; +using namespace mobile_apis; + +using am::HmiStatePtr; +using sdl_rpc_plugin::commands::SetGlobalPropertiesRequest; +using testing::_; +using testing::Mock; +using testing::NiceMock; +using testing::Return; +using testing::ReturnRef; +using usage_statistics_test::MockStatisticsManager; + +class ApplicationImplTest : public ApplicationImpl { + public: + ApplicationImplTest( + uint32_t application_id, + const std::string& policy_app_id, + const std::string& mac_address, + const connection_handler::DeviceHandle device_id, + const custom_str::CustomString& app_name, + std::shared_ptr<usage_statistics::StatisticsManager> statistics_manager, + ApplicationManager& application_manager, + MockHelpPromptManager& mock_help_prompt_manager) + : ApplicationImpl(application_id, + policy_app_id, + mac_address, + device_id, + app_name, + statistics_manager, + application_manager) + , mock_help_prompt_manager_(mock_help_prompt_manager) {} + + HelpPromptManager& help_prompt_manager() OVERRIDE { + return mock_help_prompt_manager_; + } + + private: + MockHelpPromptManager& mock_help_prompt_manager_; +}; + +class HelpPromptManagerTest : public ::testing::Test { + public: + HelpPromptManagerTest() + : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {} + void SetUp() OVERRIDE; + void TearDown() OVERRIDE; + MessageSharedPtr CreateMsgParams(); + void VRArraySetupHelper(MessageSharedPtr msg, + SmartObject& vr_help_title, + SmartObject& vr_help_array); + void CreateBasicParamsVRRequest(MessageSharedPtr msg); + void CreateApplication(MockHelpPromptManager& mock_help_prompt_manager); + HmiStatePtr CreateTestHmiState(); + + template <class Command> + std::shared_ptr<Command> CreateCommand(MessageSharedPtr& msg) { + return std::make_shared<Command>(msg, + app_mngr_, + mock_rpc_service_, + mock_hmi_capabilities_, + mock_policy_handler_); + } + + protected: + typedef CommandsTest<CommandsTestMocks::kIsNice>::MockAppManager + MockAppManager; + MockAppManager app_mngr_; + std::shared_ptr<ApplicationImplTest> app_impl_; + MockHmiInterfaces mock_hmi_interfaces_; + NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_; + NiceMock<MockApplicationManagerSettings> app_mngr_settings_; + std::shared_ptr<application_manager_test::MockApplication> mock_app_; + sync_primitives::Lock app_lock_; + MockRPCService mock_rpc_service_; + application_manager_test::MockHMICapabilities mock_hmi_capabilities_; + policy_test::MockPolicyHandlerInterface mock_policy_handler_; + MockMessageHelper& mock_message_helper_; + std::shared_ptr<MockHelpPromptManager> mock_help_prompt_manager_; +}; + +void HelpPromptManagerTest::SetUp() { + ON_CALL(app_mngr_, hmi_interfaces()) + .WillByDefault(ReturnRef(mock_hmi_interfaces_)); + ON_CALL(mock_hmi_interfaces_, GetInterfaceFromFunction(_)) + .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_SDL)); + ON_CALL(mock_hmi_interfaces_, GetInterfaceState(_)) + .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE)); + + ON_CALL(app_mngr_, get_settings()) + .WillByDefault(ReturnRef(app_mngr_settings_)); + ON_CALL(app_mngr_, event_dispatcher()) + .WillByDefault(ReturnRef(mock_event_dispatcher_)); + ON_CALL(app_mngr_settings_, default_timeout()) + .WillByDefault(ReturnRef(kTimeout)); + ON_CALL(app_mngr_settings_, app_icons_folder()) + .WillByDefault(ReturnRef(kDirectoryName)); + ON_CALL(app_mngr_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kDirectoryName)); + ON_CALL(app_mngr_settings_, audio_data_stopped_timeout()) + .WillByDefault(Return(0)); + ON_CALL(app_mngr_settings_, video_data_stopped_timeout()) + .WillByDefault(Return(0)); + + mock_help_prompt_manager_ = + std::shared_ptr<MockHelpPromptManager>(new MockHelpPromptManager()); + + HmiStatePtr state = std::make_shared<HmiState>( + static_cast<std::shared_ptr<Application> >(mock_app_), + app_mngr_, + HmiState::STATE_ID_REGULAR); + + std::string path = file_system::CreateDirectory("storage"); + file_system::CreateFile(path + "/" + "certificate"); + + mock_app_ = std::make_shared<application_manager_test::MockApplication>(); +} + +void HelpPromptManagerTest::TearDown() { + Mock::VerifyAndClearExpectations(&mock_message_helper_); +} + +MessageSharedPtr HelpPromptManagerTest::CreateMsgParams() { + MessageSharedPtr msg = + std::make_shared<SmartObject>(smart_objects::SmartType_Map); + (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey; + (*msg)[am::strings::msg_params][am::strings::app_id] = kAppId; + return msg; +} + +void HelpPromptManagerTest::VRArraySetupHelper(MessageSharedPtr msg, + SmartObject& vr_help_title, + SmartObject& vr_help_array) { + (*msg)[am::strings::msg_params][am::strings::vr_help_title] = vr_help_title; + vr_help_array[0] = SmartObject(smart_objects::SmartType_Map); + vr_help_array[0][am::strings::text] = kText; + vr_help_array[0][am::strings::position] = kPosition; + (*msg)[am::strings::msg_params][am::strings::vr_help] = vr_help_array; +} + +void HelpPromptManagerTest::CreateBasicParamsVRRequest(MessageSharedPtr msg) { + SmartObject& msg_params = (*msg)[strings::msg_params]; + msg_params[strings::cmd_id] = kCmdId; + msg_params[strings::vr_commands] = + SmartObject(smart_objects::SmartType_Array); + msg_params[strings::vr_commands][0] = kFirstVrCommand; + msg_params[strings::type] = kPosition; + msg_params[strings::grammar_id] = kGrammarId; + msg_params[strings::info] = "VR info"; +} + +HmiStatePtr HelpPromptManagerTest::CreateTestHmiState() { + HmiStatePtr testState = std::make_shared<HmiState>( + static_cast<std::shared_ptr<Application> >(app_impl_), + app_mngr_, + HmiState::STATE_ID_REGULAR); + testState->set_hmi_level(HMILevel::INVALID_ENUM); + testState->set_audio_streaming_state(AudioStreamingState::NOT_AUDIBLE); + testState->set_system_context(SystemContext::SYSCTXT_MAIN); + return testState; +} + +void HelpPromptManagerTest::CreateApplication( + MockHelpPromptManager& mock_help_prompt_manager) { + const std::string policy_app_id = "p_app_id"; + const std::string mac_address = "MA:CA:DD:RE:SS"; + const connection_handler::DeviceHandle device_id = 1; + const custom_str::CustomString app_name(""); + + app_impl_.reset( + new ApplicationImplTest(kAppId, + policy_app_id, + mac_address, + device_id, + app_name, + std::make_shared<MockStatisticsManager>(), + app_mngr_, + mock_help_prompt_manager)); + HmiStatePtr initial_state = CreateTestHmiState(); + app_impl_->SetInitialState(initial_state); +} + +TEST_F(HelpPromptManagerTest, AddCommand_OnVrCommandAdded) { + CreateApplication(*mock_help_prompt_manager_.get()); + MessageSharedPtr msg = + std::make_shared<SmartObject>(smart_objects::SmartType_Map); + CreateBasicParamsVRRequest(msg); + (*msg)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::SUCCESS; + (*msg)[strings::msg_params][strings::cmd_id] = kCmdId; + + app_impl_->AddCommand(kCmdId, (*msg)[strings::msg_params]); +} + +TEST_F(HelpPromptManagerTest, RemoveCommand_OnVrCommandDeleted) { + CreateApplication(*mock_help_prompt_manager_.get()); + MessageSharedPtr msg = + std::make_shared<SmartObject>(smart_objects::SmartType_Map); + CreateBasicParamsVRRequest(msg); + (*msg)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::SUCCESS; + (*msg)[strings::msg_params][strings::cmd_id] = kCmdId; + + app_impl_->AddCommand(kCmdId, (*msg)[strings::msg_params]); + app_impl_->RemoveCommand(kCmdId); +} + +TEST_F(HelpPromptManagerTest, + Request_OnSetGlobalPropertiesReceived_TTS_SUCCESS) { + MessageSharedPtr msg = CreateMsgParams(); + SmartObject help_prompt(smart_objects::SmartType_Array); + help_prompt[0][am::strings::text] = "Help_Prompt_One"; + (*msg)[am::strings::msg_params][am::strings::help_prompt] = help_prompt; + SmartObject timeout_prompt(smart_objects::SmartType_Array); + timeout_prompt[0][am::strings::text] = "Timeout_Prompt_One"; + (*msg)[am::strings::msg_params][am::strings::timeout_prompt] = timeout_prompt; + + EXPECT_CALL(mock_message_helper_, VerifyImageVrHelpItems(_, _, _)).Times(0); + EXPECT_CALL(mock_message_helper_, VerifyTtsFiles(help_prompt, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(mock_message_helper_, VerifyTtsFiles(timeout_prompt, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(mock_app_)); + EXPECT_CALL(app_mngr_, RemoveAppFromTTSGlobalPropertiesList(kConnectionKey)); + + EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId)); + EXPECT_CALL(*mock_app_, set_help_prompt(help_prompt)); + EXPECT_CALL(*mock_app_, help_prompt()).WillOnce(Return(&help_prompt)); + EXPECT_CALL(*mock_app_, set_timeout_prompt(timeout_prompt)); + EXPECT_CALL(*mock_app_, timeout_prompt()).WillOnce(Return(&timeout_prompt)); + EXPECT_CALL( + mock_hmi_interfaces_, + GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_SetGlobalProperties)) + .WillOnce(Return(am::HmiInterfaces::HMI_INTERFACE_TTS)); + + EXPECT_CALL(*mock_app_, help_prompt_manager()) + .WillOnce(ReturnRef(*mock_help_prompt_manager_.get())); + EXPECT_CALL(*mock_help_prompt_manager_, + OnSetGlobalPropertiesReceived(_, false)); + + std::shared_ptr<SetGlobalPropertiesRequest> command( + CreateCommand<SetGlobalPropertiesRequest>(msg)); + + command->Run(); +} + +TEST_F(HelpPromptManagerTest, + Request_OnSetGlobalPropertiesReceived_UI_SUCCESS) { + MessageSharedPtr msg = CreateMsgParams(); + SmartObject vr_help_title("yes"); + SmartObject vr_help_array(smart_objects::SmartType_Array); + VRArraySetupHelper(msg, vr_help_title, vr_help_array); + (*msg)[am::strings::msg_params][am::strings::vr_help] = vr_help_array; + SmartObject menu_title("Menu_Title"); + (*msg)[am::strings::msg_params][am::hmi_request::menu_title] = menu_title; + SmartObject menu_icon(smart_objects::SmartType_Map); + menu_icon[am::strings::value] = "1"; + (*msg)[am::strings::msg_params][am::hmi_request::menu_icon] = menu_icon; + SmartObject keyboard_properties(smart_objects::SmartType_Map); + (*msg)[am::strings::msg_params][am::hmi_request::keyboard_properties] = + keyboard_properties; + + EXPECT_CALL(mock_message_helper_, VerifyImage(menu_icon, _, _)) + .WillOnce((Return(mobile_apis::Result::SUCCESS))); + EXPECT_CALL(mock_message_helper_, VerifyImageVrHelpItems(vr_help_array, _, _)) + .WillOnce((Return(mobile_apis::Result::SUCCESS))); + EXPECT_CALL(app_mngr_, RemoveAppFromTTSGlobalPropertiesList(kConnectionKey)); + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillRepeatedly(Return(mock_app_)); + + EXPECT_CALL(*mock_app_, set_vr_help_title(vr_help_title)); + EXPECT_CALL(*mock_app_, set_vr_help(vr_help_array)); + EXPECT_CALL(*mock_app_, vr_help_title()).WillOnce(Return(&vr_help_title)); + EXPECT_CALL(*mock_app_, vr_help()).WillOnce(Return(&vr_help_array)); + EXPECT_CALL(*mock_app_, set_menu_title(menu_title)); + EXPECT_CALL(*mock_app_, set_menu_icon(menu_icon)); + EXPECT_CALL(*mock_app_, set_keyboard_props(keyboard_properties)); + EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId)); + EXPECT_CALL( + mock_hmi_interfaces_, + GetInterfaceFromFunction(hmi_apis::FunctionID::UI_SetGlobalProperties)) + .WillOnce(Return(am::HmiInterfaces::HMI_INTERFACE_UI)); + + EXPECT_CALL(*mock_app_, help_prompt_manager()) + .WillOnce(ReturnRef(*mock_help_prompt_manager_.get())); + EXPECT_CALL(*mock_help_prompt_manager_, + OnSetGlobalPropertiesReceived(_, false)); + + std::shared_ptr<SetGlobalPropertiesRequest> command( + CreateCommand<SetGlobalPropertiesRequest>(msg)); + + command->Run(); +} + +} // namespace application_manager_test +} // namespace components +} // namespace test |