diff options
Diffstat (limited to 'src/components/application_manager/test')
6 files changed, 550 insertions, 15 deletions
diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt index 02cf58485a..4851a6b37e 100755 --- a/src/components/application_manager/test/CMakeLists.txt +++ b/src/components/application_manager/test/CMakeLists.txt @@ -63,6 +63,7 @@ set(testSources ${AM_TEST_DIR}/application_state_test.cc ${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}/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/app_service_manager_test.cc b/src/components/application_manager/test/app_service_manager_test.cc new file mode 100644 index 0000000000..406f6fe0ce --- /dev/null +++ b/src/components/application_manager/test/app_service_manager_test.cc @@ -0,0 +1,440 @@ +/* + * Copyright (c) 2017, 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 "application_manager/commands/command.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/smart_object_keys.h" +#include "resumption/mock_last_state.h" +#include "smart_objects/smart_object.h" + +namespace test { +namespace components { +namespace application_manager_test { + +using testing::_; +using ::testing::DoAll; +using ::testing::Mock; +using ::testing::Return; +using ::testing::ReturnRef; +using ::testing::SaveArg; + +namespace am = application_manager; + +const char* kAppServiceSection = "AppServices"; +const char* kDefaults = "defaults"; +const std::string kServiceType = "MEDIA"; +const std::string kServiceName = "service_name"; +const std::string kServiceId = "service_id"; +const std::string kPolicyAppId = "p_app_id"; +const uint32_t kConnectionKey = 43629; +const uint32_t kHMIConnectionKey = 0; + +MATCHER_P(CapabilityUpdateMatcher, reason, "") { + smart_objects::SmartObject& services_updated = + arg[am::strings::system_capability] + [am::strings::app_services_capabilities][am::strings::app_services]; + if (smart_objects::SmartType_Array != services_updated.getType()) { + return false; + } + for (size_t i = 0; i < services_updated.length(); i++) { + smart_objects::SmartObject& service_cap = services_updated[i]; + if (reason == service_cap[am::strings::update_reason].asInt()) { + return true; + } + } + return false; +} + +class AppServiceManagerTest : public testing::Test { + public: + AppServiceManagerTest() + : mock_app_ptr_(new MockApplication) + , app_service_manager_(mock_app_manager_, mock_last_state_) + , mock_message_helper_( + application_manager::MockMessageHelper::message_helper_mock()) { + Mock::VerifyAndClearExpectations(mock_message_helper_); + } + ~AppServiceManagerTest() { + Mock::VerifyAndClearExpectations(mock_message_helper_); + } + + void SetUp() OVERRIDE { + ON_CALL(*mock_message_helper_, BroadcastCapabilityUpdate(_, _)) + .WillByDefault(Return()); + ON_CALL(mock_settings_, embedded_services()) + .WillByDefault(ReturnRef(embedded_services_)); + ON_CALL(mock_app_manager_, get_settings()) + .WillByDefault(ReturnRef(mock_settings_)); + ON_CALL(*mock_app_ptr_, policy_app_id()) + .WillByDefault(Return(kPolicyAppId)); + ON_CALL(mock_last_state_, get_dictionary()).WillByDefault(ReturnRef(dict_)); + auto app_ptr = std::static_pointer_cast<am::Application>(mock_app_ptr_); + ON_CALL(mock_app_manager_, application(kConnectionKey)) + .WillByDefault(Return(app_ptr)); + } + + protected: + smart_objects::SmartObject GenerateMediaManifest( + bool allow_app_consumers, std::string app_service_name = kServiceName) { + smart_objects::SmartObject manifest(smart_objects::SmartType_Map); + manifest[am::strings::service_type] = "MEDIA"; + manifest[am::strings::service_name] = app_service_name; + manifest[am::strings::allow_app_consumers] = allow_app_consumers; + manifest[am::strings::media_service_manifest] = + smart_objects::SmartObject(smart_objects::SmartType_Map); + return manifest; + } + + smart_objects::SmartObject PublishService( + uint32_t connection_key = kConnectionKey, bool first_run = true) { + smart_objects::SmartObject manifest = GenerateMediaManifest(true); + + Json::Value empty_json; + EXPECT_CALL(mock_last_state_, get_dictionary()) + .WillOnce(ReturnRef(empty_json)); + + EXPECT_CALL(*mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher( + mobile_apis::ServiceUpdateReason::PUBLISHED), + _)).WillOnce(Return()); + if (first_run) { + EXPECT_CALL(*mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher( + mobile_apis::ServiceUpdateReason::ACTIVATED), + _)).WillOnce(Return()); + } + bool mobile_service = connection_key != kHMIConnectionKey; + return app_service_manager_.PublishAppService( + manifest, mobile_service, connection_key); + } + + void CheckCapabilityUpdate(smart_objects::SmartObject& msg_params, + size_t length, + std::string service_id, + mobile_apis::ServiceUpdateReason::eType reason, + bool published, + bool active) { + smart_objects::SmartObject& services_updated = msg_params + [am::strings::system_capability][am::strings::app_services_capabilities] + [am::strings::app_services]; + ASSERT_EQ(smart_objects::SmartType_Array, services_updated.getType()); + EXPECT_EQ(length, services_updated.length()); + for (size_t i = 0; i < services_updated.length(); i++) { + smart_objects::SmartObject& service_cap = services_updated[i]; + if (service_id == + service_cap[am::strings::updated_app_service_record] + [am::strings::service_id].asString()) { + CheckCapability(service_cap, service_id, reason, published, active); + return; + } + } + FAIL() << "Unable to find service in capability update with service_id: " + << service_id; + } + + void CheckCapability(smart_objects::SmartObject& app_service_capability, + std::string service_id, + mobile_apis::ServiceUpdateReason::eType reason, + bool published, + bool active) { + EXPECT_EQ(reason, + app_service_capability[am::strings::update_reason].asInt()); + smart_objects::SmartObject& updated_record = + app_service_capability[am::strings::updated_app_service_record]; + EXPECT_EQ(service_id, updated_record[am::strings::service_id].asString()); + EXPECT_EQ(published, + updated_record[am::strings::service_published].asBool()); + EXPECT_EQ(active, updated_record[am::strings::service_active].asBool()); + } + + Json::Value dict_; + std::vector<std::string> embedded_services_; + std::shared_ptr<MockApplication> mock_app_ptr_; + MockApplicationManager mock_app_manager_; + resumption_test::MockLastState mock_last_state_; + MockApplicationManagerSettings mock_settings_; + application_manager::AppServiceManager app_service_manager_; + application_manager::MockMessageHelper* mock_message_helper_; +}; + +TEST_F(AppServiceManagerTest, PublishAppService_Mobile_SUCCESS) { + smart_objects::SmartObject manifest = GenerateMediaManifest(true); + + Json::Value empty_json; + // dict[kAppServiceSection][kDefaults][kServiceType] = kPolicyAppId; + EXPECT_CALL(mock_last_state_, get_dictionary()) + .WillOnce(ReturnRef(empty_json)); + + smart_objects::SmartObject syscap_update_published; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::PUBLISHED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_published), Return())); + + smart_objects::SmartObject syscap_update_activated; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::ACTIVATED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_activated), Return())); + + auto record = + app_service_manager_.PublishAppService(manifest, true, kConnectionKey); + + // Check final record + std::string service_id = record[am::strings::service_id].asString(); + EXPECT_EQ(manifest, record[am::strings::service_manifest]); + EXPECT_EQ(true, record[am::strings::service_published].asBool()); + EXPECT_EQ(true, record[am::strings::service_active].asBool()); + + // Check first capability update + CheckCapabilityUpdate(syscap_update_published, + 1, + service_id, + mobile_apis::ServiceUpdateReason::PUBLISHED, + true, + false); + + // Check second capability update + CheckCapabilityUpdate(syscap_update_activated, + 1, + service_id, + mobile_apis::ServiceUpdateReason::ACTIVATED, + true, + true); +} + +TEST_F(AppServiceManagerTest, PublishAppService_HMI_SUCCESS) { + smart_objects::SmartObject manifest = GenerateMediaManifest(true); + + Json::Value empty_json; + EXPECT_CALL(mock_last_state_, get_dictionary()) + .WillOnce(ReturnRef(empty_json)); + + smart_objects::SmartObject syscap_update_published; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::PUBLISHED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_published), Return())); + + smart_objects::SmartObject syscap_update_activated; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::ACTIVATED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_activated), Return())); + + auto record = app_service_manager_.PublishAppService(manifest, false); + + // Check final record + std::string service_id = record[am::strings::service_id].asString(); + EXPECT_EQ(manifest, record[am::strings::service_manifest]); + EXPECT_EQ(true, record[am::strings::service_published].asBool()); + EXPECT_EQ(true, record[am::strings::service_active].asBool()); + + // Check first capability update + CheckCapabilityUpdate(syscap_update_published, + 1, + service_id, + mobile_apis::ServiceUpdateReason::PUBLISHED, + true, + false); + + // Check second capability update + CheckCapabilityUpdate(syscap_update_activated, + 1, + service_id, + mobile_apis::ServiceUpdateReason::ACTIVATED, + true, + true); +} + +TEST_F(AppServiceManagerTest, UnpublishAppService_SUCCESS) { + auto record = PublishService(); + + smart_objects::SmartObject syscap_update_unpublished; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::REMOVED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_unpublished), Return())); + std::string service_id = record[am::strings::service_id].asString(); + + EXPECT_TRUE(app_service_manager_.UnpublishAppService(service_id)); + + // Check removed capability update + CheckCapabilityUpdate(syscap_update_unpublished, + 1, + service_id, + mobile_apis::ServiceUpdateReason::REMOVED, + false, + false); +} + +TEST_F(AppServiceManagerTest, ActivateAppService_AlreadyActivated) { + auto record = PublishService(); + + // No capability update + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::ACTIVATED), + _)).Times(0); + std::string service_id = record[am::strings::service_id].asString(); + + EXPECT_TRUE(app_service_manager_.ActivateAppService(service_id)); +} + +TEST_F(AppServiceManagerTest, ActivateAppService_TwoApps_SUCCESS) { + // Register two services with the same service type, the first is activated + // automatically + auto record = PublishService(); + auto record2 = PublishService(kConnectionKey + 1, false); + + // No capability update + smart_objects::SmartObject syscap_update_activated; + EXPECT_CALL( + *mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher(mobile_apis::ServiceUpdateReason::ACTIVATED), + _)).WillOnce(DoAll(SaveArg<0>(&syscap_update_activated), Return())); + std::string service_id = record[am::strings::service_id].asString(); + std::string service_id2 = record2[am::strings::service_id].asString(); + + // Activate the second service + EXPECT_TRUE(app_service_manager_.ActivateAppService(service_id2)); + + // Check that the first service is deactivated + CheckCapabilityUpdate(syscap_update_activated, + 2, + service_id, + mobile_apis::ServiceUpdateReason::DEACTIVATED, + true, + false); + + // Check that the second service is activated + CheckCapabilityUpdate(syscap_update_activated, + 2, + service_id2, + mobile_apis::ServiceUpdateReason::ACTIVATED, + true, + true); +} + +TEST_F(AppServiceManagerTest, DeactivateAppService_SUCCESS) { + auto record = PublishService(); + + smart_objects::SmartObject syscap_update_deactivated; + EXPECT_CALL(*mock_message_helper_, + BroadcastCapabilityUpdate( + CapabilityUpdateMatcher( + mobile_apis::ServiceUpdateReason::DEACTIVATED), + _)) + .WillOnce(DoAll(SaveArg<0>(&syscap_update_deactivated), Return())); + std::string service_id = record[am::strings::service_id].asString(); + + EXPECT_TRUE(app_service_manager_.DeactivateAppService(service_id)); + + // Check deactivated capability update + CheckCapabilityUpdate(syscap_update_deactivated, + 1, + service_id, + mobile_apis::ServiceUpdateReason::DEACTIVATED, + true, + false); +} + +TEST_F(AppServiceManagerTest, ActiveServiceForType_SUCCESS) { + auto record = PublishService(); + + auto service = app_service_manager_.ActiveServiceForType(kServiceType); + + ASSERT_FALSE(service == NULL); + EXPECT_EQ(record, service->record); + EXPECT_EQ(kConnectionKey, service->connection_key); + EXPECT_EQ(true, service->mobile_service); +} + +TEST_F(AppServiceManagerTest, EmbeddedServiceForType_SUCCESS) { + auto record = PublishService(kHMIConnectionKey); + + auto service = app_service_manager_.EmbeddedServiceForType(kServiceType); + + ASSERT_FALSE(service == NULL); + EXPECT_EQ(record, service->record); + EXPECT_EQ(false, service->mobile_service); +} + +TEST_F(AppServiceManagerTest, FindServiceByID_SUCCESS) { + auto record = PublishService(); + + std::string service_id = record[am::strings::service_id].asString(); + auto service = app_service_manager_.FindServiceByID(service_id); + + ASSERT_FALSE(service == NULL); + EXPECT_EQ(record, service->record); + EXPECT_EQ(kConnectionKey, service->connection_key); + EXPECT_EQ(true, service->mobile_service); +} + +TEST_F(AppServiceManagerTest, GetAllServiceRecords_OneService_SUCCESS) { + auto record = PublishService(); + + auto records = app_service_manager_.GetAllServiceRecords(); + + ASSERT_EQ(1u, records.size()); + EXPECT_EQ(record, records[0]); +} + +TEST_F(AppServiceManagerTest, GetActiveServices_OneService_SUCCESS) { + auto record = PublishService(); + + auto services = app_service_manager_.GetActiveServices(); + + ASSERT_EQ(1u, services.size()); + EXPECT_EQ(record, services[0].record); + EXPECT_EQ(kConnectionKey, services[0].connection_key); + EXPECT_EQ(true, services[0].mobile_service); +} + +} // namespace application_manager_test +} // namespace components +} // namespace test
\ No newline at end of file diff --git a/src/components/application_manager/test/commands/command_impl_test.cc b/src/components/application_manager/test/commands/command_impl_test.cc index 222f16ef46..53e8534c2b 100644 --- a/src/components/application_manager/test/commands/command_impl_test.cc +++ b/src/components/application_manager/test/commands/command_impl_test.cc @@ -85,11 +85,12 @@ class CommandImplTest : public CommandsTest<CommandsTestMocks::kIsNice> { using CommandImpl::ReplaceMobileWithHMIAppId; using CommandImpl::ReplaceHMIWithMobileAppId; - UnwrappedCommandImpl(const MessageSharedPtr& message, - ApplicationManager& application_manager, - app_mngr::rpc_service::RPCService& rpc_service, - app_mngr::HMICapabilities& hmi_capabilities, - policy::PolicyHandlerInterface& policy_handler) + UnwrappedCommandImpl( + const MessageSharedPtr& message, + ApplicationManager& application_manager, + application_manager::rpc_service::RPCService& rpc_service, + application_manager::HMICapabilities& hmi_capabilities, + policy::PolicyHandlerInterface& policy_handler) : CommandImpl(message, application_manager, rpc_service, diff --git a/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h b/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h index cad71f98ab..f77b5685da 100644 --- a/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h +++ b/src/components/application_manager/test/include/application_manager/mock_app_service_manager.h @@ -61,9 +61,8 @@ class MockAppServiceManager : public application_manager::AppServiceManager { MOCK_METHOD1(ActivateAppService, bool(const std::string service_id)); MOCK_METHOD1(DeactivateAppService, bool(const std::string service_id)); MOCK_METHOD0(GetAllServiceRecords, std::vector<smart_objects::SmartObject>()); - MOCK_METHOD0( - GetActiveServices, - std::vector<std::pair<std::string, application_manager::AppService> >()); + MOCK_METHOD0(GetActiveServices, + std::vector<application_manager::AppService>()); MOCK_METHOD4(GetProviderByType, void(const std::string& service_type, const bool mobile_consumer, @@ -82,8 +81,6 @@ class MockAppServiceManager : public application_manager::AppServiceManager { application_manager::AppService*(const std::string service_type)); MOCK_METHOD1(FindServiceByID, application_manager::AppService*(const std::string service_id)); - MOCK_METHOD1(DefaultServiceByType, - std::string(const std::string service_type)); MOCK_METHOD2(SetServicePublished, void(const std::string service_id, const bool service_published)); diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc index f43062dc53..92be221ec9 100644 --- a/src/components/application_manager/test/message_helper/message_helper_test.cc +++ b/src/components/application_manager/test/message_helper/message_helper_test.cc @@ -42,7 +42,7 @@ #include "utils/custom_string.h" #include "utils/lock.h" #include "policy/mock_policy_settings.h" -#include "application_manager/policies/policy_handler.h" +#include "application_manager/commands/command_impl.h" #include "application_manager/mock_application_manager.h" #include "application_manager/mock_rpc_service.h" #include "application_manager/event_engine/event_dispatcher.h" diff --git a/src/components/application_manager/test/policy_handler_test.cc b/src/components/application_manager/test/policy_handler_test.cc index a1471eff36..25024ff50d 100644 --- a/src/components/application_manager/test/policy_handler_test.cc +++ b/src/components/application_manager/test/policy_handler_test.cc @@ -81,15 +81,13 @@ using namespace application_manager; using namespace policy; using namespace utils::custom_string; using testing::_; +using ::testing::DoAll; using ::testing::Mock; +using ::testing::NiceMock; using ::testing::Return; using ::testing::ReturnRef; -using ::testing::NiceMock; -using ::testing::SetArgReferee; using ::testing::SetArgPointee; -using ::testing::DoAll; using ::testing::SetArgReferee; -using ::testing::Mock; typedef NiceMock<application_manager_test::MockRPCService> MockRPCService; @@ -2536,6 +2534,104 @@ TEST_F(PolicyHandlerTest, RemoteAppsUrl_SUCCESS) { EXPECT_EQ(url, policy_handler_.RemoteAppsUrl()); } +TEST_F(PolicyHandlerTest, OnSetCloudAppProperties_AllProperties_SUCCESS) { + EnablePolicyAndPolicyManagerMock(); + + bool enabled = true; + std::string app_name = "anAppName"; + std::string auth_token = "anAuthToken"; + std::string cloud_transport_type = "aTransportType"; + mobile_apis::HybridAppPreference::eType hybrid_app_preference = + mobile_apis::HybridAppPreference::CLOUD; + std::string hybrid_app_preference_str = "CLOUD"; + std::string endpoint = "anEndpoint"; + + StringArray nicknames_vec; + nicknames_vec.push_back(app_name); + + smart_objects::SmartObject message(smart_objects::SmartType_Map); + smart_objects::SmartObject properties(smart_objects::SmartType_Map); + smart_objects::SmartObject nicknames(smart_objects::SmartType_Array); + + properties[strings::app_id] = kPolicyAppId_; + nicknames[0] = app_name; + properties[strings::nicknames] = nicknames; + properties[strings::enabled] = enabled; + properties[strings::auth_token] = auth_token; + properties[strings::cloud_transport_type] = cloud_transport_type; + properties[strings::hybrid_app_preference] = hybrid_app_preference; + properties[strings::endpoint] = endpoint; + message[strings::msg_params][strings::properties] = properties; + + application_manager_test::MockPolicyHandlerObserver policy_handler_observer; + policy_handler_.add_listener(&policy_handler_observer); + + EXPECT_CALL(*mock_policy_manager_, InitCloudApp(kPolicyAppId_)); + EXPECT_CALL(*mock_policy_manager_, + SetCloudAppEnabled(kPolicyAppId_, enabled)); + EXPECT_CALL(*mock_policy_manager_, + SetAppNicknames(kPolicyAppId_, nicknames_vec)); + EXPECT_CALL(*mock_policy_manager_, + SetAppAuthToken(kPolicyAppId_, auth_token)); + EXPECT_CALL(*mock_policy_manager_, + SetAppCloudTransportType(kPolicyAppId_, cloud_transport_type)); + EXPECT_CALL(*mock_policy_manager_, + SetHybridAppPreference(kPolicyAppId_, hybrid_app_preference_str)); + EXPECT_CALL(*mock_policy_manager_, SetAppEndpoint(kPolicyAppId_, endpoint)); + EXPECT_CALL(*mock_policy_manager_, + GetCloudAppParameters(kPolicyAppId_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<4>(auth_token), Return(true))); + EXPECT_CALL(app_manager_, RefreshCloudAppInformation()); + EXPECT_CALL(policy_handler_observer, + OnAuthTokenUpdated(kPolicyAppId_, auth_token)); + + policy_handler_.OnSetCloudAppProperties(message); +} + +TEST_F(PolicyHandlerTest, GetCloudAppParameters_AllProperties_SUCCESS) { + EnablePolicyAndPolicyManagerMock(); + + bool enabled = true; + std::string certificate = "aCertificate"; + std::string auth_token = "anAuthToken"; + std::string cloud_transport_type = "aTransportType"; + std::string hybrid_app_preference_str = "CLOUD"; + std::string endpoint = "anEndpoint"; + + application_manager_test::MockPolicyHandlerObserver policy_handler_observer; + policy_handler_.add_listener(&policy_handler_observer); + + EXPECT_CALL(*mock_policy_manager_, + GetCloudAppParameters(kPolicyAppId_, _, _, _, _, _, _)) + .WillOnce(DoAll(SetArgReferee<1>(enabled), + SetArgReferee<2>(endpoint), + SetArgReferee<3>(certificate), + SetArgReferee<4>(auth_token), + SetArgReferee<5>(cloud_transport_type), + SetArgReferee<6>(hybrid_app_preference_str), + Return(true))); + + bool enabled_out; + std::string endpoint_out; + std::string cert_out; + std::string auth_token_out; + std::string ctt_out; + std::string hap_out; + EXPECT_TRUE(policy_handler_.GetCloudAppParameters(kPolicyAppId_, + enabled_out, + endpoint_out, + cert_out, + auth_token_out, + ctt_out, + hap_out)); + EXPECT_EQ(enabled, enabled_out); + EXPECT_EQ(endpoint, endpoint_out); + EXPECT_EQ(certificate, cert_out); + EXPECT_EQ(auth_token, auth_token_out); + EXPECT_EQ(cloud_transport_type, ctt_out); + EXPECT_EQ(hybrid_app_preference_str, hap_out); +} + } // namespace policy_handler_test } // namespace components } // namespace test |