From 6202be2238f2cfe5ef9b91652889ad005b0b304b Mon Sep 17 00:00:00 2001 From: atimchenko Date: Thu, 1 Dec 2016 09:22:50 +0200 Subject: Cover send_location_request with unit tests Fully cover send_location_request with UT Related task APPLINK-28083 --- .../commands/mobile/send_location_request_test.cc | 412 +++++++++++++++++++++ 1 file changed, 412 insertions(+) create mode 100644 src/components/application_manager/test/commands/mobile/send_location_request_test.cc diff --git a/src/components/application_manager/test/commands/mobile/send_location_request_test.cc b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc new file mode 100644 index 0000000000..21f0f9abd1 --- /dev/null +++ b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc @@ -0,0 +1,412 @@ +/* + * Copyright (c) 2016, 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 +#include + +#include "gtest/gtest.h" +#include "application_manager/commands/mobile/send_location_request.h" +#include "application_manager/mock_hmi_capabilities.h" +#include "application_manager/mock_message_helper.h" +#include "utils/shared_ptr.h" +#include "commands/command_request_test.h" + +namespace test { +namespace components { +namespace commands_test { +namespace mobile_commands_test { +namespace send_location_request { + +using application_manager::commands::MessageSharedPtr; +using application_manager::commands::SendLocationRequest; +using application_manager::MockMessageHelper; +using test::components::application_manager_test::MockHMICapabilities; +using smart_objects::SmartObject; +using utils::SharedPtr; +using testing::_; +using testing::Return; +using testing::ReturnRef; + +namespace strings = application_manager::strings; +namespace hmi_response = application_manager::hmi_response; +namespace Common_TextFieldName = hmi_apis::Common_TextFieldName; + +namespace { +const uint32_t kConnectionKey = 1u; +const uint32_t kFunctionID = 2u; +const uint32_t kAppID = 3u; +const double kLongitudeDegrees = 13.4; +const std::string kLocationDescription = "Location_Description"; +const std::string kNewLine = "\\n"; +const std::string kAddressLine = "Address_Line"; +const std::string kPhoneNumber = "Phone_number"; +const std::string kCorrectAddress = "Correct address"; +const std::string kEmptyAddress = ""; +const std::string kAddressWithWrongSyntax = "Wrong Syntax\\n"; +} // namespace + +class SendLocationRequestTest + : public CommandRequestTest { + public: + class UnwrappedSendLocationRequest : public SendLocationRequest { + public: + UnwrappedSendLocationRequest( + const MessageSharedPtr& message, + application_manager::ApplicationManager& application_manager) + : SendLocationRequest(message, application_manager) {} + + ::application_manager::CommandParametersPermissions& + get_parameters_permissions() { + return parameters_permissions_; + } + }; + + typedef SharedPtr CommandSPrt; + + SendLocationRequestTest() + : mock_message_helper_(*MockMessageHelper::message_helper_mock()) { + mock_app_ = CreateMockApp(); + disp_cap_ = utils::MakeShared(smart_objects::SmartType_Map); + message_ = CreateMessage(); + command_ = CreateCommand(message_); + } + + void InitialSetup(MessageSharedPtr message_) { + (*message_)[strings::params][strings::connection_key] = kConnectionKey; + (*message_)[strings::params][strings::function_id] = kFunctionID; + (*message_)[strings::msg_params] = + SmartObject(smart_objects::SmartType_Map); + (*message_)[strings::msg_params][strings::address] = kCorrectAddress; + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(mock_app_)); + + AllowMandatoryFields(); + } + + void HMICapabilitiesSetupHelper() { + EXPECT_CALL(app_mngr_, hmi_capabilities()) + .WillOnce(ReturnRef(mock_hmi_capabilities_)); + EXPECT_CALL(mock_hmi_capabilities_, is_ui_cooperating()) + .WillOnce(Return(true)); + } + + void HMICapabilitiesSetupWithArguments( + Common_TextFieldName::eType field_name) { + HMICapabilitiesSetupHelper(); + (*disp_cap_)[hmi_response::text_fields] = + SmartObject(smart_objects::SmartType_Array); + (*disp_cap_)[hmi_response::text_fields][0] = + SmartObject(smart_objects::SmartType_Map); + (*disp_cap_)[hmi_response::text_fields][0][strings::name] = field_name; + EXPECT_CALL(mock_hmi_capabilities_, display_capabilities()) + .Times(2) + .WillRepeatedly(Return(disp_cap_.get())); + } + + void FinishSetup() { + EXPECT_CALL(*mock_app_, hmi_app_id()).WillOnce(Return(kAppID)); + EXPECT_CALL(app_mngr_, + ManageHMICommand(HMIResultCodeIs( + hmi_apis::FunctionID::Navigation_SendLocation))); + } + + void FinishSetupCancelled(mobile_apis::Result::eType result) { + EXPECT_CALL(*mock_app_, hmi_app_id()).Times(0); + EXPECT_CALL(app_mngr_, ManageHMICommand(_)).Times(0); + EXPECT_CALL(app_mngr_, ManageMobileCommand(MobileResultCodeIs(result), _)); + } + + void AllowMandatoryFields() { + application_manager::CommandParametersPermissions& permissions = + command_->get_parameters_permissions(); + permissions.allowed_params.push_back(strings::longitude_degrees); + permissions.allowed_params.push_back(strings::latitude_degrees); + } + + MockAppPtr mock_app_; + MockHMICapabilities mock_hmi_capabilities_; + MockMessageHelper& mock_message_helper_; + SharedPtr disp_cap_; + MessageSharedPtr message_; + CommandSPrt command_; +}; + +TEST_F(SendLocationRequestTest, Run_InvalidApp_Success) { + (*message_)[strings::params][strings::connection_key] = kConnectionKey; + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(MockAppPtr())); + FinishSetupCancelled(mobile_apis::Result::APPLICATION_NOT_REGISTERED); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_DeliveryMode_Success) { + InitialSetup(message_); + SmartObject msg_params = (*message_)[strings::msg_params]; + msg_params[strings::delivery_mode] = SmartObject(); + (*message_)[strings::msg_params] = msg_params; + msg_params.erase(strings::delivery_mode); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationNameIsAllowed_Success) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_name] = "Location_Name"; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationName); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationNameIsNotAllowed_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_name] = "Location_Name"; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM); + FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationNameWrongSyntax_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_name] = "Location_Name\\n"; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationName); + FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationDescriptionIsAllowed_Success) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_description] = + kLocationDescription; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationDescription); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationDescriptionIsNotAllowed_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_description] = + kLocationDescription; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM); + FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationDescriptionWrongSyntax_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_description] = + kLocationDescription + kNewLine; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationDescription); + FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_AddressLinesAreAllowed_Success) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::address_lines] = + SmartObject(smart_objects::SmartType_Array); + (*message_)[strings::msg_params][strings::address_lines][0] = kAddressLine; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::addressLines); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_AddressLinesAreNotAllowed_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::address_lines] = + SmartObject(smart_objects::SmartType_Array); + (*message_)[strings::msg_params][strings::address_lines][0] = kAddressLine; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM); + FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_AddressLinesWrongSyntax_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::address_lines] = + SmartObject(smart_objects::SmartType_Array); + (*message_)[strings::msg_params][strings::address_lines][0] = + kAddressLine + kNewLine; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::addressLines); + FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_PhoneNumberIsAllowed_Success) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::phoneNumber); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_PhoneNumberIsNotAllowed_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::INVALID_ENUM); + FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_PhoneNumberWrongSyntax_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::phone_number] = + kPhoneNumber + kNewLine; + HMICapabilitiesSetupWithArguments(Common_TextFieldName::phoneNumber); + FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_AddressesContainWrongSyntax_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::address] = + SmartObject(smart_objects::SmartType_Array); + (*message_)[strings::msg_params][strings::address]["Address 1"] = + kCorrectAddress; + (*message_)[strings::msg_params][strings::address]["Address 2"] = + kAddressWithWrongSyntax; + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationImageValid_Success) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_image] = + SmartObject(smart_objects::SmartType_Map); + (*message_)[strings::msg_params][strings::location_image][strings::value] = + "1"; + EXPECT_CALL( + mock_message_helper_, + VerifyImage( + (*message_)[strings::msg_params][strings::location_image], _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetup(); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_LocationImageInvalid_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::location_image] = + SmartObject(smart_objects::SmartType_Map); + (*message_)[strings::msg_params][strings::location_image][strings::value] = + "1"; + EXPECT_CALL( + mock_message_helper_, + VerifyImage( + (*message_)[strings::msg_params][strings::location_image], _, _)) + .WillOnce(Return(mobile_apis::Result::ABORTED)); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + FinishSetupCancelled(mobile_apis::Result::ABORTED); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, Run_HMIUINotCoop_Cancelled) { + InitialSetup(message_); + (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber; + (*disp_cap_)[hmi_response::text_fields] = + SmartObject(smart_objects::SmartType_Array); + (*disp_cap_)[hmi_response::text_fields][0] = + SmartObject(smart_objects::SmartType_Map); + (*disp_cap_)[hmi_response::text_fields][0][strings::name] = + Common_TextFieldName::phoneNumber; + EXPECT_CALL(app_mngr_, hmi_capabilities()) + .WillOnce(ReturnRef(mock_hmi_capabilities_)); + EXPECT_CALL(mock_hmi_capabilities_, is_ui_cooperating()) + .WillOnce(Return(false)); + FinishSetupCancelled(mobile_apis::Result::UNSUPPORTED_RESOURCE); + command_->Run(); +} + +TEST_F(SendLocationRequestTest, OnEvent_Success) { + mobile_apis::Result::eType response_code = mobile_apis::Result::SUCCESS; + (*message_)[strings::params][hmi_response::code] = response_code; + Event event(hmi_apis::FunctionID::Navigation_SendLocation); + event.set_smart_object(*message_); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::SUCCESS)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + command_->on_event(event); +} + +TEST_F(SendLocationRequestTest, OnEvent_Cancelled) { + (*message_)[strings::params][hmi_response::code] = + mobile_apis::Result::SUCCESS; + Event event(hmi_apis::FunctionID::Navigation_OnWayPointChange); + event.set_smart_object(*message_); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _)) + .Times(0); + command_->on_event(event); +} + +TEST_F(SendLocationRequestTest, Run_MandatoryParamsDisallowed_InvalidData) { + (*message_)[strings::params][strings::connection_key] = kConnectionKey; + (*message_)[strings::params][strings::function_id] = kFunctionID; + (*message_)[strings::msg_params] = SmartObject(smart_objects::SmartType_Map); + (*message_)[strings::msg_params][strings::address] = kCorrectAddress; + (*message_)[strings::msg_params][strings::longitude_degrees] = + kLongitudeDegrees; + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(mock_app_)); + application_manager::CommandParametersPermissions& permissions = + command_->get_parameters_permissions(); + // 1st one allowed + permissions.allowed_params.push_back(strings::longitude_degrees); + // 2nd one disallowed + permissions.disallowed_params.push_back(strings::latitude_degrees); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) + .WillOnce(Return(false)); + command_->Run(); +} + +} // namespace send_location_request +} // namespace mobile_commands_test +} // namespace commands_test +} // namespace components +} // namespace test -- cgit v1.2.1 From abde010cde52f5aa4f399479b2433eb8d0da9b92 Mon Sep 17 00:00:00 2001 From: atimchenko Date: Thu, 1 Dec 2016 10:35:09 +0200 Subject: Cover add_command_request with unit tests Move aplicable Unit Tests for add_command Related task APPLINK-28083 --- .../commands/mobile/add_command_request_test.cc | 896 ++++++++++++++++----- 1 file changed, 699 insertions(+), 197 deletions(-) diff --git a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc index 78a6aa2f4d..ea42630ea2 100644 --- a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc @@ -57,285 +57,787 @@ namespace mobile_commands_test { namespace add_command_request { namespace am = application_manager; - -using am::commands::AddCommandRequest; using am::commands::CommandImpl; using am::ApplicationManager; using am::commands::MessageSharedPtr; using am::ApplicationSharedPtr; using am::MockMessageHelper; using am::MockHmiInterfaces; - using ::testing::_; -using ::testing::Mock; -using ::testing::Return; -using ::testing::ReturnRef; using ::utils::SharedPtr; +using ::testing::Return; +using ::testing::Mock; +using ::testing::InSequence; +using am::commands::AddCommandRequest; +using NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr; using ::test::components::application_manager_test::MockApplication; +using am::event_engine::EventObserver; +using namespace smart_objects; namespace custom_str = utils::custom_string; namespace strings = ::application_manager::strings; +namespace mobile_result = mobile_apis::Result; namespace hmi_response = ::application_manager::hmi_response; +namespace hmi_request = ::application_manager::hmi_request; +using namespace strings; namespace { -const int32_t kCommandId = 1; +const hmi_apis::FunctionID::eType kInvalidFunctionId = + hmi_apis::FunctionID::INVALID_ENUM; const uint32_t kAppId = 1u; const uint32_t kCmdId = 1u; const uint32_t kConnectionKey = 2u; +const std::string kMenuName = "LG"; +const uint32_t kFirstParentId = 10u; +const uint32_t kSecondParentId = 1u; +const std::string kFirstVrCommand = "lamer"; +const std::string kSecondVrCommand = "hacker"; +const uint32_t kFirstCommandId = 10u; +const uint32_t kSecondCommandId = 11u; +const int32_t kType = 34; +const int32_t kGrammarId = 12; +const int32_t kPosition = 10; } // namespace class AddCommandRequestTest : public CommandRequestTest { - public: + protected: AddCommandRequestTest() - : mock_message_helper_(*MockMessageHelper::message_helper_mock()) - , mock_app_(CreateMockApp()) {} + : msg_(CreateMessage()) + , default_app_name_("test_default_app_name_") + , mock_message_helper_(*MockMessageHelper::message_helper_mock()) + , mock_app_(CreateMockApp()) { + Mock::VerifyAndClearExpectations(&mock_message_helper_); + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillRepeatedly(Return(mock_app_)); + InitGetters(); + InitBasicMessage(); + } - protected: - MessageSharedPtr CreateFullParamsVRSO() { - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[strings::params][strings::connection_key] = kConnectionKey; - smart_objects::SmartObject msg_params = - smart_objects::SmartObject(smart_objects::SmartType_Map); - msg_params[strings::cmd_id] = kCmdId; - msg_params[strings::vr_commands] = - smart_objects::SmartObject(smart_objects::SmartType_Array); - msg_params[strings::vr_commands][0] = "lamer"; - msg_params[strings::type] = 34; - msg_params[strings::grammar_id] = 12; - msg_params[strings::app_id] = kAppId; - (*msg)[strings::msg_params] = msg_params; - - return msg; + ~AddCommandRequestTest() { + Mock::VerifyAndClearExpectations(&mock_message_helper_); } - MessageSharedPtr CreateFullParamsUISO() { - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey; - smart_objects::SmartObject menu_params = - smart_objects::SmartObject(smart_objects::SmartType_Map); - menu_params[am::strings::position] = 10; - menu_params[am::strings::menu_name] = "LG"; - - smart_objects::SmartObject msg_params = - smart_objects::SmartObject(smart_objects::SmartType_Map); - msg_params[am::strings::cmd_id] = kCmdId; - msg_params[am::strings::menu_params] = menu_params; - msg_params[am::strings::app_id] = kAppId; - msg_params[am::strings::cmd_icon] = 1; - msg_params[am::strings::cmd_icon][am::strings::value] = "10"; - (*msg)[am::strings::msg_params] = msg_params; - - return msg; + void InitBasicMessage() { + (*msg_)[params][connection_key] = kConnectionKey; + (*msg_)[msg_params][app_id] = kAppId; + (*msg_)[msg_params][app_name] = default_app_name_; } - MessageSharedPtr CreateParamsUISOWithOutCmdIcon() { - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey; - smart_objects::SmartObject menu_params = - smart_objects::SmartObject(smart_objects::SmartType_Map); - menu_params[am::strings::position] = 10; - menu_params[am::strings::menu_name] = "LG"; - - smart_objects::SmartObject msg_params = - smart_objects::SmartObject(smart_objects::SmartType_Map); - msg_params[am::strings::cmd_id] = kCmdId; - msg_params[am::strings::menu_params] = menu_params; - msg_params[am::strings::app_id] = kAppId; - (*msg)[am::strings::msg_params] = msg_params; - - return msg; + void InitGetters() { + ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId)); + ON_CALL(*mock_app_, FindCommand(kCmdId)) + .WillByDefault(Return(so_ptr_.get())); } - void SetUp() OVERRIDE { - ON_CALL(app_mngr_, application(kConnectionKey)) - .WillByDefault(Return(mock_app_)); - ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey)); - ON_CALL(app_mngr_, hmi_interfaces()) - .WillByDefault(ReturnRef(hmi_interfaces_)); + void CreateBasicParamsUIRequest() { + SmartObject menu_params = SmartObject(SmartType_Map); + menu_params[position] = kPosition; + menu_params[menu_name] = kMenuName; + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[cmd_id] = kCmdId; + msg_params[strings::menu_params] = menu_params; + msg_params[cmd_icon] = 1; + msg_params[cmd_icon][value] = "10"; + msg_params[info] = "UI info"; } - void TearDown() OVERRIDE { - Mock::VerifyAndClearExpectations(&mock_message_helper_); + void CreateBasicParamsVRRequest() { + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[cmd_id] = kCmdId; + msg_params[vr_commands] = SmartObject(SmartType_Array); + msg_params[vr_commands][0] = kFirstVrCommand; + msg_params[type] = kPosition; + msg_params[grammar_id] = kGrammarId; + msg_params[info] = "VR info"; + } + + const am::CommandsMap CreateCommandsMap(SmartObject& first_command, + SmartObject& second_command) { + second_command[menu_params] = SmartObject(SmartType_Map); + second_command[menu_params][hmi_request::parent_id] = kFirstParentId; + second_command[menu_params][menu_name] = kMenuName; + second_command[vr_commands] = SmartObject(SmartType_Array); + second_command[vr_commands][0] = kSecondVrCommand; + am::CommandsMap commands_map; + commands_map.insert(std::make_pair(kFirstCommandId, &first_command)); + commands_map.insert(std::make_pair(kSecondCommandId, &second_command)); + return commands_map; } - void ResultCommandExpectations(MessageSharedPtr msg, - const std::string& info) { - EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(), - true); - EXPECT_EQ( - (*msg)[am::strings::msg_params][am::strings::result_code].asInt(), - static_cast(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE)); - EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(), - info); + void CheckOnTimeOutCommandDeletion( + const hmi_apis::FunctionID::eType incoming_cmd, + const hmi_apis::FunctionID::eType cmd_to_delete) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kSecondParentId; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)) + .WillOnce(Return(so_ptr_.get())); + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return(DataAccessor( + commands_map, lock_))); + so_ptr_ = utils::MakeShared(SmartType_Map); + EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId)) + .WillOnce(Return(so_ptr_.get())); + { + InSequence dummy; + EXPECT_CALL(app_mngr_, + ManageHMICommand( + HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL(app_mngr_, + ManageHMICommand( + HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + Event event(incoming_cmd); + event.set_smart_object(*msg_); + request_ptr->on_event(event); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + EXPECT_CALL(app_mngr_, ManageHMICommand(HMIResultCodeIs(cmd_to_delete))) + .WillOnce(Return(true)); + SmartObjectSPtr response; + EXPECT_CALL( + mock_message_helper_, + CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR)) + .WillOnce(Return(response)); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand(response, + am::commands::Command::CommandOrigin::ORIGIN_SDL)); + utils::SharedPtr base_class_request = + static_cast >(request_ptr); + base_class_request->onTimeOut(); } + MessageSharedPtr msg_; + SmartObjectSPtr so_ptr_; + const utils::custom_string::CustomString default_app_name_; + am::MockMessageHelper& mock_message_helper_; sync_primitives::Lock lock_; - NiceMock hmi_interfaces_; - MockMessageHelper& mock_message_helper_; MockAppPtr mock_app_; }; -TEST_F(AddCommandRequestTest, OnTimeout_GENERIC_ERROR) { - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[strings::msg_params][strings::result_code] = - am::mobile_api::Result::GENERIC_ERROR; - (*msg)[strings::msg_params][strings::success] = false; - (*msg)[strings::params][strings::connection_key] = kConnectionKey; +TEST_F(AddCommandRequestTest, Run_AppNotExisted_EXPECT_AppNotRegistered) { + CreateBasicParamsUIRequest(); + Mock::VerifyAndClearExpectations(&app_mngr_); + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(ApplicationSharedPtr())); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_result::APPLICATION_NOT_REGISTERED), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} + +TEST_F(AddCommandRequestTest, Run_ImageVerificationFailed_EXPECT_INVALID_DATA) { + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::INVALID_DATA)); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} + +TEST_F(AddCommandRequestTest, Run_MenuNameHasSyntaxError_EXPECT_INVALID_DATA) { + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kFirstParentId; + const std::string errored_menu_name = "L\nG"; + msg_params[menu_params][menu_name] = errored_menu_name; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + SmartObject parent = SmartObject(SmartType_Map); + EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(&parent)); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} + +TEST_F(AddCommandRequestTest, + Run_VRCommandsHaveSyntaxError_EXPECT_INVALID_DATA) { + CreateBasicParamsVRRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + const std::string errored_vr_command = "l\namer"; + msg_params[vr_commands][0] = errored_vr_command; + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} - utils::SharedPtr command = +TEST_F(AddCommandRequestTest, Run_CMDIconHasError_EXPECT_INVALID_DATA) { + MessageSharedPtr msg = CreateMessage(); + SmartObject& msg_params = (*msg)[strings::msg_params]; + (*msg)[params][connection_key] = kConnectionKey; + msg_params[cmd_id] = kCmdId; + msg_params[cmd_icon] = 1; + const std::string errored_cmd_icon_value = "1\n0"; + msg_params[cmd_icon][value] = errored_cmd_icon_value; + msg_params[vr_commands][0] = kFirstVrCommand; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + utils::SharedPtr request_ptr = CreateCommand(msg); + request_ptr->Run(); +} - ON_CALL(*mock_app_, get_grammar_id()).WillByDefault(Return(kConnectionKey)); - ON_CALL(*mock_app_, RemoveCommand(_)).WillByDefault(Return()); +TEST_F(AddCommandRequestTest, Run_CommandIDAlreadyExists_EXPECT_INVALID_ID) { + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + so_ptr_ = utils::MakeShared(SmartType_Map); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} - EXPECT_CALL( - mock_message_helper_, - CreateNegativeResponse(_, _, _, am::mobile_api::Result::GENERIC_ERROR)) - .WillOnce(Return(msg)); +TEST_F(AddCommandRequestTest, + Run_CommandNameAlreadyExists_EXPECT_DUPLICATE_NAME) { + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kFirstParentId; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} - MessageSharedPtr command_result; - EXPECT_CALL( - app_mngr_, - ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL)) - .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true))); - - command->onTimeOut(); - EXPECT_EQ((*command_result)[strings::msg_params][strings::success].asBool(), - false); - EXPECT_EQ( - (*command_result)[strings::msg_params][strings::result_code].asInt(), - static_cast(am::mobile_api::Result::GENERIC_ERROR)); +TEST_F(AddCommandRequestTest, + Run_CmdAndMsgParentIDsAreDifferentSubmenuNotExisted_EXPECT_INVALID_ID) { + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kSecondParentId; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); } -TEST_F(AddCommandRequestTest, OnEvent_VR_HmiSendSuccess_UNSUPPORTED_RESOURCE) { - MessageSharedPtr msg_vr = CreateFullParamsVRSO(); - (*msg_vr)[strings::msg_params][strings::menu_params] - [am::hmi_request::parent_id] = 10u; - (*msg_vr)[strings::msg_params][strings::menu_params][strings::menu_name] = - "menu_name"; - - utils::SharedPtr command = - CreateCommand(msg_vr); - - ON_CALL(*mock_app_, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr))); - ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_)) - .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR)); - ON_CALL(hmi_interfaces_, GetInterfaceState(_)) - .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE)); - - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[strings::params][hmi_response::code] = - hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; - (*msg)[am::strings::msg_params][am::strings::info] = - "VR is not supported by system"; - (*msg)[strings::msg_params][strings::cmd_id] = kCommandId; +TEST_F(AddCommandRequestTest, + Run_CmdAndMsgVrSynonymsAreTheSame_EXPECT_DUPLICATE_NAME) { + CreateBasicParamsVRRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kSecondParentId; + msg_params[vr_commands][0] = kSecondVrCommand; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + so_ptr_ = utils::MakeShared(SmartType_Map); + EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} - Event event(hmi_apis::FunctionID::VR_AddCommand); - event.set_smart_object(*msg); +TEST_F(AddCommandRequestTest, Run_MsgDataEmpty_EXPECT_INVALID_DATA) { + MessageSharedPtr msg = CreateMessage(); + (*msg)[params][connection_key] = kConnectionKey; + SmartObject& msg_params = (*msg)[strings::msg_params]; + msg_params[app_id] = kAppId; + msg_params[cmd_id] = kCmdId; + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg); + request_ptr->Run(); +} - smart_objects::SmartObject* ptr = NULL; - ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(ptr)); +TEST_F(AddCommandRequestTest, + Run_CmdAndMsg_UI_and_Vr_AreCorrect_EXPECT_VR_AND_UI_SENT) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + msg_params[menu_params][hmi_request::parent_id] = kSecondParentId; + SmartObject& image = msg_params[cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + so_ptr_ = utils::MakeShared(SmartType_Map); + EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} - ON_CALL(mock_message_helper_, HMIToMobileResult(_)) - .WillByDefault(Return(mobile_apis::Result::SUCCESS)); +TEST_F(AddCommandRequestTest, GetRunMethods_SUCCESS) { + CreateBasicParamsUIRequest(); + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params])); - EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_vr)[strings::msg_params])); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); +} + +TEST_F(AddCommandRequestTest, OnEvent_UI_SUCCESS) { + CreateBasicParamsUIRequest(); + (*msg_)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params])); am::CommandsMap commands_map; - ON_CALL(*mock_app_, commands_map()) - .WillByDefault( + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly( Return(DataAccessor(commands_map, lock_))); + Event event(hmi_apis::FunctionID::UI_AddCommand); + event.set_smart_object(*msg_); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::SUCCESS)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); EXPECT_CALL(*mock_app_, UpdateHash()); + request_ptr->on_event(event); +} - MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map)); - (*msg_ui)[am::strings::params][am::hmi_response::code] = - hmi_apis::Common_Result::SUCCESS; +TEST_F(AddCommandRequestTest, OnEvent_VR_SUCCESS) { + CreateBasicParamsVRRequest(); + MessageSharedPtr msg = CreateMessage(SmartType_Map); + (*msg)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + (*msg)[msg_params][cmd_id] = kCmdId; - Event event_ui(hmi_apis::FunctionID::UI_AddCommand); - event_ui.set_smart_object(*msg_ui); - - command->Run(); - command->on_event(event_ui); + Event event(hmi_apis::FunctionID::VR_AddCommand); + event.set_smart_object(*msg); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::SUCCESS)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, AddCommand(kCmdId, (*msg_)[msg_params])); - MessageSharedPtr vr_command_result; + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly( + Return(DataAccessor(commands_map, lock_))); + EXPECT_CALL(*mock_app_, UpdateHash()); EXPECT_CALL( app_mngr_, - ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL)) - .WillOnce(DoAll(SaveArg<0>(&vr_command_result), Return(true))); - - command->on_event(event); - - ResultCommandExpectations(vr_command_result, "VR is not supported by system"); + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + request_ptr->on_event(event); } -TEST_F(AddCommandRequestTest, OnEvent_UI_HmiSendSuccess_UNSUPPORTED_RESOURCE) { - MessageSharedPtr msg_vr = CreateFullParamsUISO(); - (*msg_vr)[am::strings::msg_params][am::strings::vr_commands][0] = - "vr_command"; +TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_VR_DeleteCommand) { + CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::VR_AddCommand, + hmi_apis::FunctionID::VR_DeleteCommand); +} - utils::SharedPtr command = - CreateCommand(msg_vr); +TEST_F(AddCommandRequestTest, OnTimeOut_EXPECT_UI_DeleteCommand) { + CheckOnTimeOutCommandDeletion(hmi_apis::FunctionID::UI_AddCommand, + hmi_apis::FunctionID::UI_DeleteCommand); +} - ON_CALL(*mock_app_, FindSubMenu(_)).WillByDefault(Return(&(*msg_vr))); +TEST_F(AddCommandRequestTest, OnEvent_BothSend_SUCCESS) { + MessageSharedPtr command_msg = CreateMessage(SmartType_Map); + (*command_msg)[params][connection_key] = kConnectionKey; + MessageSharedPtr event_msg = CreateMessage(SmartType_Map); + (*event_msg)[params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + (*event_msg)[msg_params][cmd_id] = kCmdId; - ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_)) - .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI)); - ON_CALL(hmi_interfaces_, - GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI)) - .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE)); - ON_CALL(hmi_interfaces_, - GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR)) - .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE)); + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*event_msg); - MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map); - (*msg)[am::strings::params][am::hmi_response::code] = - hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; - (*msg)[am::strings::msg_params][am::strings::info] = - "UI is not supported by system"; - (*msg)[am::strings::msg_params][am::strings::cmd_id] = kCommandId; + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + event_vr.set_smart_object(*event_msg); - Event event(hmi_apis::FunctionID::UI_AddCommand); - event.set_smart_object(*msg); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0); - smart_objects::SmartObject* ptr = NULL; - ON_CALL(*mock_app_, FindCommand(kCmdId)).WillByDefault(Return(ptr)); - EXPECT_EQ(NULL, ptr); + utils::SharedPtr request_ptr = + CreateCommand(command_msg); + request_ptr->Run(); + request_ptr->on_event(event_ui); + request_ptr->on_event(event_vr); +} - ON_CALL(mock_message_helper_, HMIToMobileResult(_)) - .WillByDefault(Return(mobile_apis::Result::SUCCESS)); +TEST_F(AddCommandRequestTest, OnEvent_UnknownEvent_UNSUCCESS) { + EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + Event event(hmi_apis::FunctionID::INVALID_ENUM); + request_ptr->on_event(event); +} - ON_CALL(mock_message_helper_, VerifyImage(_, _, _)) - .WillByDefault(Return(mobile_apis::Result::SUCCESS)); - EXPECT_CALL(*mock_app_, - AddCommand(kCmdId, (*msg_vr)[am::strings::msg_params])); +TEST_F(AddCommandRequestTest, OnEvent_AppNotExisted_UNSUCCESS) { + CreateBasicParamsUIRequest(); + Mock::VerifyAndClearExpectations(&app_mngr_); + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(ApplicationSharedPtr())); + Event event(hmi_apis::FunctionID::UI_AddCommand); + EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->on_event(event); +} +TEST_F(AddCommandRequestTest, + OnEvent_HmiResponseCodeIsRejected_ExpectUICommandRemoved) { + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::REJECTED; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); am::CommandsMap commands_map; - ON_CALL(*mock_app_, commands_map()) - .WillByDefault( - Return(DataAccessor(commands_map, lock_))); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::REJECTED)) + .WillOnce(Return(mobile_apis::Result::REJECTED)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::REJECTED), _)); + Event event(hmi_apis::FunctionID::UI_AddCommand); + event.set_smart_object(*msg_); + request_ptr->on_event(event); +} +TEST_F(AddCommandRequestTest, + OnEvent_HmiResponseCodeIsWarnings_ExpectCommandUpdated) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::WARNINGS; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::WARNINGS), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_); + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + event_vr.set_smart_object(*msg_); EXPECT_CALL(*mock_app_, UpdateHash()); + request_ptr->on_event(event_ui); + request_ptr->on_event(event_vr); +} - MessageSharedPtr msg_ui(CreateMessage(smart_objects::SmartType_Map)); - (*msg_ui)[am::strings::params][am::hmi_response::code] = - hmi_apis::Common_Result::SUCCESS; - +TEST_F(AddCommandRequestTest, + OnEvent_UI_EventWithNotSuccesResponseCode_ExpectVRCommandDelete) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + + MessageSharedPtr msg_ui = CreateMessage(SmartType_Map); + (*msg_ui)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::ABORTED; + (*msg_ui)[msg_params][cmd_id] = kCmdId; + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_ui); Event event_vr(hmi_apis::FunctionID::VR_AddCommand); - event_vr.set_smart_object(*msg_vr); + event_vr.set_smart_object(*msg_); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::ABORTED)) + .WillOnce(Return(mobile_apis::Result::ABORTED)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_DeleteCommand))) + .WillOnce(Return(true)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2); + request_ptr->on_event(event_ui); + request_ptr->on_event(event_vr); +} - command->Run(); - command->on_event(event_vr); - MessageSharedPtr ui_command_result; +TEST_F(AddCommandRequestTest, + OnEvent_UI_VR_Events_VRErrorPresent_ExpectRemoveCommand) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::ABORTED)) + .WillOnce(Return(mobile_apis::Result::ABORTED)); + + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_); + request_ptr->on_event(event_ui); EXPECT_CALL( app_mngr_, - ManageMobileCommand(_, am::commands::Command::CommandOrigin::ORIGIN_SDL)) - .WillOnce(DoAll(SaveArg<0>(&ui_command_result), Return(true))); + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_DeleteCommand))) + .WillOnce(Return(true)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(2); + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + MessageSharedPtr msg_vr = CreateMessage(SmartType_Map); + (*msg_vr)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::ABORTED; + (*msg_vr)[msg_params][cmd_id] = kCmdId; + event_vr.set_smart_object(*msg_vr); + request_ptr->on_event(event_vr); +} - command->on_event(event); +TEST_F(AddCommandRequestTest, + OnTimeOut_AppNotExisted_NoAppRemoveCommandCalled) { + CreateBasicParamsUIRequest(); + Mock::VerifyAndClearExpectations(&app_mngr_); + EXPECT_CALL(app_mngr_, application(kConnectionKey)) + .WillOnce(Return(ApplicationSharedPtr())); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0); + SmartObjectSPtr response; + EXPECT_CALL( + mock_message_helper_, + CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR)) + .WillOnce(Return(response)); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + response, am::commands::Command::CommandOrigin::ORIGIN_SDL)); + utils::SharedPtr base_class_request = + static_cast >( + CreateCommand(msg_)); + base_class_request->onTimeOut(); +} - ResultCommandExpectations(ui_command_result, "UI is not supported by system"); +TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& msg_params = (*msg_)[strings::msg_params]; + SmartObject& image = msg_params[cmd_icon]; + msg_params[menu_params][hmi_request::parent_id] = kSecondParentId; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); + SmartObject first_command = SmartObject(SmartType_Map); + SmartObject second_command = SmartObject(SmartType_Map); + const am::CommandsMap commands_map = + CreateCommandsMap(first_command, second_command); + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + so_ptr_ = utils::MakeShared(SmartType_Map); + EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + EXPECT_CALL(app_mngr_, ManageMobileCommand(_, _)).Times(0); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + SmartObjectSPtr response; + EXPECT_CALL( + mock_message_helper_, + CreateNegativeResponse(_, _, _, mobile_apis::Result::GENERIC_ERROR)) + .WillOnce(Return(response)); + EXPECT_CALL(app_mngr_, + ManageMobileCommand( + response, am::commands::Command::CommandOrigin::ORIGIN_SDL)); + utils::SharedPtr base_class_request = + static_cast >(request_ptr); + base_class_request->onTimeOut(); } } // namespace add_command_test -- cgit v1.2.1 From c69ff858bd8beb8b9c44c4b626e98b5b0e700475 Mon Sep 17 00:00:00 2001 From: atimchenko Date: Thu, 1 Dec 2016 12:19:40 +0200 Subject: Fully cover add_command_request with unit tests Add Unit Tests for add_command (sdl_core) Related task APPLINK-28083 --- .../commands/mobile/add_command_request_test.cc | 265 +++++++++++++++++++++ 1 file changed, 265 insertions(+) diff --git a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc index ea42630ea2..e19bbf00d2 100644 --- a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc @@ -670,6 +670,271 @@ TEST_F(AddCommandRequestTest, request_ptr->on_event(event_vr); } +TEST_F( + AddCommandRequestTest, + OnEvent_UI_HmiResponseCodeIsGenericError_VR_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::GENERIC_ERROR)) + .WillRepeatedly(Return(mobile_apis::Result::GENERIC_ERROR)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_); + request_ptr->on_event(event_ui); + + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + MessageSharedPtr msg_vr = CreateMessage(SmartType_Map); + (*msg_vr)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + (*msg_vr)[msg_params][cmd_id] = kCmdId; + event_vr.set_smart_object(*msg_vr); + request_ptr->on_event(event_vr); +} + +TEST_F( + AddCommandRequestTest, + OnEvent_VR_HmiResponseCodeIsGenericError_UI_HmiResponseCodeIsUnsupportedResourse_ExpectCommandRemoved) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::GENERIC_ERROR; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + + EXPECT_CALL(mock_message_helper_, + HMIToMobileResult(hmi_apis::Common_Result::GENERIC_ERROR)) + .WillRepeatedly(Return(mobile_apis::Result::GENERIC_ERROR)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + event_vr.set_smart_object(*msg_); + request_ptr->on_event(event_vr); + + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + MessageSharedPtr msg_ui = CreateMessage(SmartType_Map); + (*msg_ui)[strings::params][hmi_response::code] = + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + (*msg_ui)[msg_params][cmd_id] = kCmdId; + event_ui.set_smart_object(*msg_ui); + request_ptr->on_event(event_ui); +} + +TEST_F( + AddCommandRequestTest, + OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_UI_NotAvailableInterfaceState_ExpectCommandRemoved) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR)) + .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE)); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_); + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + event_vr.set_smart_object(*msg_); + request_ptr->on_event(event_ui); + request_ptr->on_event(event_vr); +} + +TEST_F( + AddCommandRequestTest, + OnEvent_UI_VR_HmiResponseCodeIsUnsupportedResourse_VR_NotAvailableInterfaceState_ExpectCommandRemoved) { + CreateBasicParamsVRRequest(); + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + { + InSequence dummy; + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + } + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI)) + .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE)); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + Event event_ui(hmi_apis::FunctionID::UI_AddCommand); + event_ui.set_smart_object(*msg_); + Event event_vr(hmi_apis::FunctionID::VR_AddCommand); + event_vr.set_smart_object(*msg_); + request_ptr->on_event(event_ui); + request_ptr->on_event(event_vr); +} + +TEST_F( + AddCommandRequestTest, + OnEvent_UI_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) { + CreateBasicParamsUIRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + SmartObject& image = (*msg_)[msg_params][cmd_icon]; + EXPECT_CALL(mock_message_helper_, VerifyImage(image, _, _)) + .WillOnce(Return(mobile_apis::Result::SUCCESS)); + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _)); + Event event(hmi_apis::FunctionID::UI_AddCommand); + event.set_smart_object(*msg_); + request_ptr->on_event(event); +} + +TEST_F( + AddCommandRequestTest, + OnEvent_VR_HmiResponseCodeIsUnsupportedResource_NotAvailableInterfaceState_ExpectCommandRemoved) { + CreateBasicParamsVRRequest(); + SmartObject& params = (*msg_)[strings::params]; + params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + am::CommandsMap commands_map; + EXPECT_CALL(*mock_app_, commands_map()) + .WillRepeatedly(Return( + DataAccessor(commands_map, lock_))); + EXPECT_CALL( + app_mngr_, + ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand))) + .WillOnce(Return(true)); + utils::SharedPtr request_ptr = + CreateCommand(msg_); + request_ptr->Run(); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL(mock_hmi_interfaces_, + GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR)) + .WillRepeatedly( + Return(am::HmiInterfaces::InterfaceState::STATE_NOT_AVAILABLE)); + EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)); + EXPECT_CALL( + app_mngr_, + ManageMobileCommand( + MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _)); + Event event(hmi_apis::FunctionID::VR_AddCommand); + event.set_smart_object(*msg_); + request_ptr->on_event(event); +} + TEST_F(AddCommandRequestTest, OnEvent_UI_EventWithNotSuccesResponseCode_ExpectVRCommandDelete) { CreateBasicParamsVRRequest(); -- cgit v1.2.1 From ec864a8291b716715225f676699913d36b361995 Mon Sep 17 00:00:00 2001 From: atimchenko Date: Thu, 1 Dec 2016 17:43:18 +0200 Subject: Fixes for unit tests Fixes for unit tests, suggested in pull request Related task APPLINK-28083 --- .../commands/mobile/add_command_request_test.cc | 25 ++++++++++++---------- .../commands/mobile/send_location_request_test.cc | 23 +++++--------------- 2 files changed, 19 insertions(+), 29 deletions(-) diff --git a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc index e19bbf00d2..567c3d32f9 100644 --- a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc @@ -90,6 +90,7 @@ const uint32_t kConnectionKey = 2u; const std::string kMenuName = "LG"; const uint32_t kFirstParentId = 10u; const uint32_t kSecondParentId = 1u; +const std::string kErroredVRCommand = "l\namer"; const std::string kFirstVrCommand = "lamer"; const std::string kSecondVrCommand = "hacker"; const uint32_t kFirstCommandId = 10u; @@ -101,7 +102,7 @@ const int32_t kPosition = 10; class AddCommandRequestTest : public CommandRequestTest { - protected: + public: AddCommandRequestTest() : msg_(CreateMessage()) , default_app_name_("test_default_app_name_") @@ -118,6 +119,7 @@ class AddCommandRequestTest Mock::VerifyAndClearExpectations(&mock_message_helper_); } + protected: void InitBasicMessage() { (*msg_)[params][connection_key] = kConnectionKey; (*msg_)[msg_params][app_id] = kAppId; @@ -232,7 +234,6 @@ class AddCommandRequestTest TEST_F(AddCommandRequestTest, Run_AppNotExisted_EXPECT_AppNotRegistered) { CreateBasicParamsUIRequest(); - Mock::VerifyAndClearExpectations(&app_mngr_); EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillOnce(Return(ApplicationSharedPtr())); EXPECT_CALL( @@ -273,7 +274,8 @@ TEST_F(AddCommandRequestTest, Run_MenuNameHasSyntaxError_EXPECT_INVALID_DATA) { .WillRepeatedly(Return( DataAccessor(commands_map, lock_))); SmartObject parent = SmartObject(SmartType_Map); - EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(&parent)); + EXPECT_CALL(*mock_app_, FindSubMenu(kFirstParentId)) + .WillOnce(Return(&parent)); EXPECT_CALL(app_mngr_, ManageMobileCommand( MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); @@ -286,8 +288,7 @@ TEST_F(AddCommandRequestTest, Run_VRCommandsHaveSyntaxError_EXPECT_INVALID_DATA) { CreateBasicParamsVRRequest(); SmartObject& msg_params = (*msg_)[strings::msg_params]; - const std::string errored_vr_command = "l\namer"; - msg_params[vr_commands][0] = errored_vr_command; + msg_params[vr_commands][0] = kErroredVRCommand; EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get())); am::CommandsMap commands_map; EXPECT_CALL(*mock_app_, commands_map()) @@ -382,7 +383,8 @@ TEST_F(AddCommandRequestTest, EXPECT_CALL(*mock_app_, commands_map()) .WillRepeatedly(Return( DataAccessor(commands_map, lock_))); - EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId)) + .WillOnce(Return(so_ptr_.get())); EXPECT_CALL(app_mngr_, ManageMobileCommand( MobileResultCodeIs(mobile_apis::Result::INVALID_ID), _)); @@ -410,7 +412,8 @@ TEST_F(AddCommandRequestTest, .WillRepeatedly(Return( DataAccessor(commands_map, lock_))); so_ptr_ = utils::MakeShared(SmartType_Map); - EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId)) + .WillOnce(Return(so_ptr_.get())); EXPECT_CALL(app_mngr_, ManageMobileCommand( MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _)); @@ -452,7 +455,8 @@ TEST_F(AddCommandRequestTest, .WillRepeatedly(Return( DataAccessor(commands_map, lock_))); so_ptr_ = utils::MakeShared(SmartType_Map); - EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId)) + .WillOnce(Return(so_ptr_.get())); { InSequence dummy; EXPECT_CALL( @@ -590,7 +594,6 @@ TEST_F(AddCommandRequestTest, OnEvent_UnknownEvent_UNSUCCESS) { TEST_F(AddCommandRequestTest, OnEvent_AppNotExisted_UNSUCCESS) { CreateBasicParamsUIRequest(); - Mock::VerifyAndClearExpectations(&app_mngr_); EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillOnce(Return(ApplicationSharedPtr())); Event event(hmi_apis::FunctionID::UI_AddCommand); @@ -1040,7 +1043,6 @@ TEST_F(AddCommandRequestTest, TEST_F(AddCommandRequestTest, OnTimeOut_AppNotExisted_NoAppRemoveCommandCalled) { CreateBasicParamsUIRequest(); - Mock::VerifyAndClearExpectations(&app_mngr_); EXPECT_CALL(app_mngr_, application(kConnectionKey)) .WillOnce(Return(ApplicationSharedPtr())); EXPECT_CALL(*mock_app_, RemoveCommand(kCmdId)).Times(0); @@ -1075,7 +1077,8 @@ TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) { .WillRepeatedly(Return( DataAccessor(commands_map, lock_))); so_ptr_ = utils::MakeShared(SmartType_Map); - EXPECT_CALL(*mock_app_, FindSubMenu(_)).WillOnce(Return(so_ptr_.get())); + EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId)) + .WillOnce(Return(so_ptr_.get())); { InSequence dummy; EXPECT_CALL( diff --git a/src/components/application_manager/test/commands/mobile/send_location_request_test.cc b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc index 21f0f9abd1..7d197010c7 100644 --- a/src/components/application_manager/test/commands/mobile/send_location_request_test.cc +++ b/src/components/application_manager/test/commands/mobile/send_location_request_test.cc @@ -54,6 +54,7 @@ using utils::SharedPtr; using testing::_; using testing::Return; using testing::ReturnRef; +using ::testing::Mock; namespace strings = application_manager::strings; namespace hmi_response = application_manager::hmi_response; @@ -99,6 +100,10 @@ class SendLocationRequestTest command_ = CreateCommand(message_); } + void TearDown() OVERRIDE { + Mock::VerifyAndClearExpectations(&mock_message_helper_); + } + void InitialSetup(MessageSharedPtr message_) { (*message_)[strings::params][strings::connection_key] = kConnectionKey; (*message_)[strings::params][strings::function_id] = kFunctionID; @@ -173,8 +178,6 @@ TEST_F(SendLocationRequestTest, Run_DeliveryMode_Success) { msg_params[strings::delivery_mode] = SmartObject(); (*message_)[strings::msg_params] = msg_params; msg_params.erase(strings::delivery_mode); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -183,8 +186,6 @@ TEST_F(SendLocationRequestTest, Run_LocationNameIsAllowed_Success) { InitialSetup(message_); (*message_)[strings::msg_params][strings::location_name] = "Location_Name"; HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationName); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -210,8 +211,6 @@ TEST_F(SendLocationRequestTest, Run_LocationDescriptionIsAllowed_Success) { (*message_)[strings::msg_params][strings::location_description] = kLocationDescription; HMICapabilitiesSetupWithArguments(Common_TextFieldName::locationDescription); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -240,8 +239,6 @@ TEST_F(SendLocationRequestTest, Run_AddressLinesAreAllowed_Success) { SmartObject(smart_objects::SmartType_Array); (*message_)[strings::msg_params][strings::address_lines][0] = kAddressLine; HMICapabilitiesSetupWithArguments(Common_TextFieldName::addressLines); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -271,8 +268,6 @@ TEST_F(SendLocationRequestTest, Run_PhoneNumberIsAllowed_Success) { InitialSetup(message_); (*message_)[strings::msg_params][strings::phone_number] = kPhoneNumber; HMICapabilitiesSetupWithArguments(Common_TextFieldName::phoneNumber); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -302,8 +297,6 @@ TEST_F(SendLocationRequestTest, Run_AddressesContainWrongSyntax_Cancelled) { kCorrectAddress; (*message_)[strings::msg_params][strings::address]["Address 2"] = kAddressWithWrongSyntax; - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetupCancelled(mobile_apis::Result::INVALID_DATA); command_->Run(); } @@ -319,8 +312,6 @@ TEST_F(SendLocationRequestTest, Run_LocationImageValid_Success) { VerifyImage( (*message_)[strings::msg_params][strings::location_image], _, _)) .WillOnce(Return(mobile_apis::Result::SUCCESS)); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetup(); command_->Run(); } @@ -336,8 +327,6 @@ TEST_F(SendLocationRequestTest, Run_LocationImageInvalid_Cancelled) { VerifyImage( (*message_)[strings::msg_params][strings::location_image], _, _)) .WillOnce(Return(mobile_apis::Result::ABORTED)); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); FinishSetupCancelled(mobile_apis::Result::ABORTED); command_->Run(); } @@ -400,8 +389,6 @@ TEST_F(SendLocationRequestTest, Run_MandatoryParamsDisallowed_InvalidData) { EXPECT_CALL(app_mngr_, ManageMobileCommand( MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _)); - EXPECT_CALL(mock_message_helper_, PrintSmartObject(_)) - .WillOnce(Return(false)); command_->Run(); } -- cgit v1.2.1