diff options
author | Shobhit Adlakha <adlakhashobhit@gmail.com> | 2019-05-10 08:25:38 -0400 |
---|---|---|
committer | Shobhit Adlakha <adlakhashobhit@gmail.com> | 2019-05-10 08:25:38 -0400 |
commit | f129d99e24bbba2d302890120d1ac2edcbc3636b (patch) | |
tree | 776213ac5a8f021af66790cc8b2072dceacde9d6 | |
parent | 94a46dd9cdbb7b8a281c067f81c188f66cfc6a5d (diff) | |
download | sdl_core-f129d99e24bbba2d302890120d1ac2edcbc3636b.tar.gz |
Implemeted unit tests for the rpc_passing_handler class
3 files changed, 354 insertions, 5 deletions
diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt index 78bfd0c9ba..ccec05a795 100755 --- a/src/components/application_manager/test/CMakeLists.txt +++ b/src/components/application_manager/test/CMakeLists.txt @@ -65,6 +65,7 @@ set(testSources ${AM_TEST_DIR}/usage_statistics_test.cc ${AM_TEST_DIR}/policy_handler_test.cc ${AM_TEST_DIR}/app_service_manager_test.cc + ${AM_TEST_DIR}/rpc_passing_handler_test.cc ${AM_TEST_DIR}/application_manager_impl_test.cc ${AM_TEST_DIR}/application_helper_test.cc ${AM_TEST_DIR}/command_holder_test.cc diff --git a/src/components/application_manager/test/mobile_event_engine_test.cc b/src/components/application_manager/test/mobile_event_engine_test.cc index 7e8583d3fd..cad1ff14ff 100644 --- a/src/components/application_manager/test/mobile_event_engine_test.cc +++ b/src/components/application_manager/test/mobile_event_engine_test.cc @@ -32,13 +32,13 @@ #include "gtest/gtest.h" -#include "application_manager/event_engine/event_observer.h" #include "application_manager/event_engine/event.h" #include "application_manager/event_engine/event_dispatcher_impl.h" -#include "application_manager/mock_event_observer.h" +#include "application_manager/event_engine/event_observer.h" +#include "application_manager/message.h" #include "application_manager/mock_event_dispatcher.h" +#include "application_manager/mock_event_observer.h" #include "smart_objects/smart_object.h" -#include "application_manager/message.h" #include "interfaces/MOBILE_API.h" @@ -46,10 +46,10 @@ namespace test { namespace components { namespace event_engine_test { -using application_manager::event_engine::EventDispatcherImpl; using application_manager::event_engine::Event; -using application_manager::event_engine::MobileEvent; +using application_manager::event_engine::EventDispatcherImpl; using application_manager::event_engine::EventObserver; +using application_manager::event_engine::MobileEvent; using testing::_; using ::testing::An; using ::testing::Matcher; diff --git a/src/components/application_manager/test/rpc_passing_handler_test.cc b/src/components/application_manager/test/rpc_passing_handler_test.cc new file mode 100644 index 0000000000..c1ef29ca07 --- /dev/null +++ b/src/components/application_manager/test/rpc_passing_handler_test.cc @@ -0,0 +1,348 @@ +/* + * Copyright (c) 2019, 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 <gmock/gmock.h> +#include "gtest/gtest.h" + +#include "application_manager/rpc_passing_handler.h" + +// #include "application_manager/commands/command.h" +#include "application_manager/mock_app_service_manager.h" +#include "application_manager/mock_application.h" +#include "application_manager/mock_application_manager.h" +#include "application_manager/mock_application_manager_settings.h" +#include "application_manager/mock_message_helper.h" +#include "application_manager/mock_rpc_service.h" +#include "application_manager/policies/mock_policy_handler_interface.h" + +#include <vector> +#include "application_manager/smart_object_keys.h" +#include "resumption/mock_last_state.h" +#include "smart_objects/smart_object.h" + +namespace test { +namespace components { +namespace application_manager_test { + +namespace am = application_manager; +using ::testing::_; +using ::testing::DoAll; +using ::testing::InSequence; +using ::testing::Mock; +using ::testing::NiceMock; +using ::testing::Pointee; +using ::testing::Return; +using ::testing::ReturnRef; + +class RPCPassingHandlerTest : public ::testing::Test { + public: + RPCPassingHandlerTest() + : mock_app_service_manager_(mock_app_manager_, mock_last_state_) {} + + ~RPCPassingHandlerTest() {} + + void SetUp() OVERRIDE { + rpc_passing_handler_ = + new am::RPCPassingHandler(mock_app_service_manager_, mock_app_manager_); + app_services_.clear(); + + ON_CALL(mock_app_manager_, IncreaseForwardedRequestTimeout(_, _)) + .WillByDefault(Return()); + ON_CALL(mock_app_manager_, get_settings()) + .WillByDefault(ReturnRef(mock_app_manager_settings_)); + + ON_CALL(mock_app_manager_settings_, rpc_pass_through_timeout()) + .WillByDefault(Return(kRPCPassthroughTimeout)); + + ON_CALL(mock_app_manager_, GetRPCService()) + .WillByDefault(ReturnRef(mock_rpc_service_)); + ON_CALL(mock_rpc_service_, ManageMobileCommand(_, _)) + .WillByDefault(Return(true)); + ON_CALL(mock_rpc_service_, SendMessageToMobile(_, _)) + .WillByDefault(Return()); + + ON_CALL(mock_app_manager_, GetAppServiceManager()) + .WillByDefault(ReturnRef(mock_app_service_manager_)) + ON_CALL(mock_app_service_manager_, GetActiveServices()) + .WillByDefault(Return(app_services_)); + + // app_manager_.GetRPCHandler() + // rpc_handler.ValidateRpcSO(message, msg_version, report, false)) + } + + void TearDown() OVERRIDE { + delete rpc_passing_handler_; + rpc_passing_handler_ = NULL; + } + + protected: + am::AppService CreateAppService(uint32_t connection_key, + const std::string& service_id, + const std::string& service_type) { + am::AppService app_service; + + app_service.connection_key = connection_key; + app_service.mobile_service = true; + app_service.default_service = false; + + smart_objects::SmartObject record(smart_objects::SmartType::SmartType_Map); + record[am::strings::service_id] = service_id; + // record[am::strings::service_manifest][am::strings::service_name] = + // service_name; + record[am::strings::service_manifest][am::strings::service_type] = + service_type; + record[am::strings::service_manifest][am::strings::allow_app_consumers] = + true; + record[am::strings::service_manifest][am::strings::handled_rpcs] = + smart_objects::SmartObject(smart_objects::SmartType::SmartType_Array); + record[am::strings::service_manifest][am::strings::handled_rpcs][0] = + mobile_apis::FunctionID::SendLocationID; + record[am::strings::service_published] = true; + record[am::strings::service_active] = true; + app_service.record = record; + + return app_service; + } + + smart_objects::SmartObject CreatePassThroughRequest(uint32_t connection_key, + int32_t correlation_id) { + smart_objects::SmartObject record(smart_objects::SmartType::SmartType_Map); + record[am::strings::params][am::strings::connection_key] = connection_key; + record[am::strings::params][am::strings::correlation_id] = correlation_id; + record[am::strings::params][am::strings::function_id] = + mobile_apis::FunctionID::SendLocationID; + record[am::strings::params][am::strings::message_type] = + am::MessageType::kRequest; + record[am::strings::msg_params][am::strings::latitude_degrees] = 50; + record[am::strings::msg_params][am::strings::longitude_degrees] = 50; + record[am::strings::msg_params][am::strings::location_name] = + "TestLocation"; + + return record; + } + + smart_objects::SmartObject CreatePassThroughResponse( + uint32_t connection_key, + int32_t correlation_id, + mobile_apis::Result::eType result_code, + bool success, + std::string info = std::string()) { + smart_objects::SmartObject record(smart_objects::SmartType::SmartType_Map); + record[am::strings::params][am::strings::connection_key] = connection_key; + record[am::strings::params][am::strings::correlation_id] = correlation_id; + record[am::strings::params][am::strings::function_id] = + mobile_apis::FunctionID::SendLocationID; + record[am::strings::params][am::strings::message_type] = + am::MessageType::kResponse; + record[am::strings::msg_params][am::strings::result_code] = result_code; + record[am::strings::msg_params][am::strings::success] = success; + record[am::strings::msg_params][am::strings::info] = info; + + return record; + } + + void SendPassthroughRequestToMobile(uint32_t connection_key, + int32_t correlation_id) { + smart_objects::SmartObject request = + CreatePassThroughRequest(connection_key, correlation_id); + smart_objects::SmartObject forwarded_request = + CreatePassThroughRequest(connection_key + 1, correlation_id); + + { + InSequence dummy; + // Call RPCPassThrough with request smart object + + // Will call PopulateRPCRequestQueue + EXPECT_CALL(mock_app_service_manager_, GetActiveServices()) + .WillOnce(Return(app_services_)); + EXPECT_CALL( + mock_app_manager_, + IncreaseForwardedRequestTimeout(connection_key, correlation_id)); + + // Will call ForwardRequesttoMobile + EXPECT_CALL(mock_app_manager_, get_settings()); + EXPECT_CALL(mock_app_manager_settings_, rpc_pass_through_timeout()); + EXPECT_CALL(mock_app_manager_, GetRPCService()); + EXPECT_CALL(mock_rpc_service_, + SendMessageToMobile(Pointee(forwarded_request), false)); + } + + bool result = rpc_passing_handler_->RPCPassThrough(request); + EXPECT_EQ(result, true); + } + + void SendPassthroughResponseFromMobile(uint32_t connection_key, + int32_t correlation_id) {} + + // void (uint32_t connection_key, int32_t correlation_id){} + + MockApplicationManager mock_app_manager_; + MockApplicationManagerSettings mock_app_manager_settings_; + MockRPCService mock_rpc_service_; + resumption_test::MockLastState mock_last_state_; + MockAppServiceManager mock_app_service_manager_; + am::RPCPassingHandler* rpc_passing_handler_; + std::vector<am::AppService> app_services_; + + uint32_t kRPCPassthroughTimeout = 10000; +}; + +TEST_F(RPCPassingHandlerTest, RPCPassingTest_REQUEST_ForwardToMobile) { + int32_t correlation_id = 1; + uint32_t connection_key = 1; + app_services_.push_back( + CreateAppService(connection_key + 1, "service 1", "NAVIGATION")); + + SendPassthroughRequestToMobile(connection_key, correlation_id); +} + +// TEST_F(RPCPassingHandlerTest, RPCPassingTest_REQUEST_DuplicateCorrelationID) +// { +// int32_t correlation_id = 1; +// uint32_t connection_key = 1; +// app_services_.push_back(CreateAppService(connection_key + 1, "service 1", +// "NAVIGATION")); + +// SendPassthroughRequestToMobile(connection_key, correlation_id); +// smart_objects::SmartObject request = CreatePassThroughRequest(connection_key, +// correlation_id); + +// { +// InSequence dummy; +// // Call RPCPassThrough with request smart object +// // Will return true and send error message since correlation id already +// exists in map +// // FAILING ON NegativeResponse(The mock function has no default action set) +// EXPECT_CALL(mock_app_manager_, GetRPCService()); +// EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, +// am::commands::Command::SOURCE_SDL)); +// } + +// bool result = rpc_passing_handler_->RPCPassThrough(request); +// EXPECT_EQ(result, true); + +// } + +TEST_F(RPCPassingHandlerTest, RPCPassingTest_REQUEST_NoPassthrough) { + int32_t correlation_id = 1; + uint32_t connection_key = 1; + + smart_objects::SmartObject request = + CreatePassThroughRequest(connection_key, correlation_id); + + { + InSequence dummy; + // Call RPCPassThrough with request smart object + + // Will call PopulateRPCRequestQueue + EXPECT_CALL(mock_app_service_manager_, GetActiveServices()) + .WillOnce(Return(app_services_)); + EXPECT_CALL(mock_app_manager_, + IncreaseForwardedRequestTimeout(connection_key, correlation_id)) + .Times(0); + // Will return false since there are no active services to handle the rpc + EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0); + EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, _)).Times(0); + } + + bool result = rpc_passing_handler_->RPCPassThrough(request); + EXPECT_EQ(result, false); +} + +TEST_F(RPCPassingHandlerTest, RPCPassingTest_RESPONSE_UnknownCorrelationID) { + int32_t correlation_id = 1; + uint32_t connection_key = 1; + smart_objects::SmartObject response = CreatePassThroughResponse( + connection_key, correlation_id, mobile_apis::Result::SUCCESS, true); + + app_services_.push_back( + CreateAppService(connection_key + 1, "service 1", "NAVIGATION")); + + { + InSequence dummy; + // Call RPCPassThrough with response smart object + // Will return false since the correlation id does not exist in the map + EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0); + EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, _)).Times(0); + } + bool result = rpc_passing_handler_->RPCPassThrough(response); + EXPECT_EQ(result, false); +} + +TEST_F(RPCPassingHandlerTest, RPCPassingTest_SUCCESS) { + int32_t correlation_id = 1; + uint32_t connection_key = 1; + smart_objects::SmartObject response = CreatePassThroughResponse( + connection_key + 1, correlation_id, mobile_apis::Result::SUCCESS, true); + smart_objects::SmartObject forwarded_response = CreatePassThroughResponse( + connection_key, correlation_id, mobile_apis::Result::SUCCESS, true); + + app_services_.push_back( + CreateAppService(connection_key + 1, "service 1", "NAVIGATION")); + + SendPassthroughRequestToMobile(connection_key, correlation_id); + + { + InSequence dummy; + // Call RPCPassThrough with response smart object + // Will ForwardResponseToMobile + EXPECT_CALL(mock_app_manager_, GetRPCService()); + EXPECT_CALL(mock_rpc_service_, + SendMessageToMobile(Pointee(forwarded_response), false)); + } + bool result = rpc_passing_handler_->RPCPassThrough(response); + EXPECT_EQ(result, true); +} + +// TEST_F(RPCPassingHandlerTest, +// RPCPassingTest_UNSUPPORTED_REQUEST_ForwardToMobile) { +// int32_t correlation_id = 1; +// uint32_t connection_key = 1; +// smart_objects::SmartObject forwarded_response = +// CreatePassThroughResponse(connection_key, correlation_id, +// mobile_apis::Result::SUCCESS, true); + +// app_services_.push_back(CreateAppService(connection_key + 1, "service 1", +// "NAVIGATION")); + +// SendPassthroughRequestToMobile(connection_key, correlation_id); + +// Call RPCPassThrough with response smart object +// Will cycle to core (no other app services in list) + +// Call RPCPassThrough with request smart object +// Will return false +// } + +} // namespace application_manager_test +} // namespace components +} // namespace test |