diff options
Diffstat (limited to 'src/components/policy/policy_external/test/sql_pt_representation_test.cc')
| -rw-r--r-- | src/components/policy/policy_external/test/sql_pt_representation_test.cc | 1845 |
1 files changed, 1845 insertions, 0 deletions
diff --git a/src/components/policy/policy_external/test/sql_pt_representation_test.cc b/src/components/policy/policy_external/test/sql_pt_representation_test.cc new file mode 100644 index 0000000000..5530db8b3f --- /dev/null +++ b/src/components/policy/policy_external/test/sql_pt_representation_test.cc @@ -0,0 +1,1845 @@ +/* Copyright (c) 2015, 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 <vector> +#include <string> +#include <algorithm> +#include <fstream> +#include <stdio.h> +#include <sys/stat.h> +#include <memory> + +#include "gtest/gtest.h" +#include "policy/sql_pt_representation.h" +#include "utils/file_system.h" +#include "utils/system.h" +#include "policy/sql_wrapper.h" +#include "policy/policy_types.h" +#include "json/writer.h" +#include "json/reader.h" +#include "policy/policy_table/types.h" +#include "policy/policy_table/enums.h" +#include "rpc_base/rpc_base.h" +#include "policy/mock_policy_settings.h" +#include "utils/shared_ptr.h" + +namespace policy_table = rpc::policy_table_interface_base; +using policy::SQLPTRepresentation; +using policy::CheckPermissionResult; +using policy::UserFriendlyMessage; +using policy::EndpointUrls; +using policy::VehicleInfo; + +using testing::ReturnRef; +using testing::Return; +using testing::NiceMock; +using testing::Mock; +namespace test { +namespace components { +namespace policy_test { + +class SQLPTRepresentationTest : public SQLPTRepresentation, + public ::testing::Test { + public: + static const bool in_memory_; + + protected: + static SQLPTRepresentation* reps; + static const std::string kDatabaseName; + static utils::dbms::SQLQuery* query_wrapper_; + // Gtest can show message that this object doesn't destroyed + static std::auto_ptr<policy_handler_test::MockPolicySettings> + policy_settings_; + + static void SetUpTestCase() { + const std::string kAppStorageFolder = "storage1"; + reps = new SQLPTRepresentation(in_memory_); + ASSERT_TRUE(reps != NULL); + policy_settings_ = std::auto_ptr<policy_handler_test::MockPolicySettings>( + new policy_handler_test::MockPolicySettings()); + ON_CALL(*policy_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kAppStorageFolder)); + EXPECT_EQ(::policy::SUCCESS, reps->Init(policy_settings_.get())); + query_wrapper_ = new utils::dbms::SQLQuery(reps->db()); + ASSERT_TRUE(query_wrapper_ != NULL); + } + + void TearDown() OVERRIDE { + EXPECT_TRUE(reps->Clear()); + } + + static void TearDownTestCase() { + delete query_wrapper_; + EXPECT_TRUE(reps->Drop()); + EXPECT_TRUE(reps->Close()); + reps->RemoveDB(); + delete reps; + policy_settings_.reset(); + } + + virtual utils::dbms::SQLDatabase* db() const { + return reps->db(); + } + + void GatherModuleMeta(policy_table::ModuleMeta* meta) const { + ::SQLPTRepresentation::GatherModuleMeta(meta); + } + + void GatherModuleConfig(policy_table::ModuleConfig* config) const { + ::SQLPTRepresentation::GatherModuleConfig(config); + } + + bool GatherUsageAndErrorCounts( + policy_table::UsageAndErrorCounts* counts) const { + return ::SQLPTRepresentation::GatherUsageAndErrorCounts(counts); + } + + bool GatherApplicationPoliciesSection( + policy_table::ApplicationPoliciesSection* policies) const { + return ::SQLPTRepresentation::GatherApplicationPoliciesSection(policies); + } + virtual void GatherDeviceData(policy_table::DeviceData* data) const { + ::SQLPTRepresentation::GatherDeviceData(data); + } + + virtual bool GatherConsumerFriendlyMessages( + policy_table::ConsumerFriendlyMessages* messages) const { + return ::SQLPTRepresentation::GatherConsumerFriendlyMessages(messages); + } + + bool GatherAppGroup(const std::string& app_id, + policy_table::Strings* app_groups) const { + return ::SQLPTRepresentation::GatherAppGroup(app_id, app_groups); + } + + bool GatherAppType(const std::string& app_id, + policy_table::AppHMITypes* app_types) const { + return ::SQLPTRepresentation::GatherAppType(app_id, app_types); + } + + bool GatherRequestType(const std::string& app_id, + policy_table::RequestTypes* request_types) const { + return ::SQLPTRepresentation::GatherRequestType(app_id, request_types); + } + + bool GatherNickName(const std::string& app_id, + policy_table::Strings* nicknames) const { + return ::SQLPTRepresentation::GatherNickName(app_id, nicknames); + } + + void CheckAppPoliciesSection( + policy_table::ApplicationPoliciesSection& policies, + uint16_t apps_size, + policy_table::Priority prio, + const std::string& section, + uint16_t memory_kb, + uint32_t heart_beat_timeout_ms, + policy_table::Strings& groups) const { + if (section != "device") { + policy_table::ApplicationPolicies& apps = policies.apps; + EXPECT_EQ(apps_size, apps.size()); + policy_table::ApplicationPolicies::iterator apps_iter = + apps.find(section); + ASSERT_TRUE(apps.end() != apps_iter); + policy_table::Strings& temp_groups = apps_iter->second.groups; + StringsCompare(groups, temp_groups); + EXPECT_EQ(0u, (*(apps_iter->second.nicknames)).size()); + EXPECT_EQ(prio, apps_iter->second.priority); + EXPECT_EQ(0u, (*(apps_iter->second.AppHMIType)).size()); + EXPECT_EQ(memory_kb, (*(apps_iter->second.memory_kb))); + EXPECT_EQ(heart_beat_timeout_ms, + (*(apps_iter->second.heart_beat_timeout_ms))); + } else { + policy_table::DevicePolicy& device = policies.device; + EXPECT_EQ(prio, device.priority); + } + } + + void StringsCompare(policy_table::Strings& groups1, + policy_table::Strings& groups2) const { + EXPECT_EQ(groups1.size(), groups2.size()); + std::sort(groups1.begin(), groups1.end()); + std::sort(groups2.begin(), groups2.end()); + EXPECT_TRUE(groups1 == groups2); + } + + void CheckAppGroups(const std::string& app_id, + policy_table::Strings& groups) { + policy_table::Strings app_groups; + GatherAppGroup(app_id, &app_groups); + StringsCompare(groups, app_groups); + } + + void PolicyTableUpdatePrepare(Json::Value& table) { + PolicyTableUpdatePrepareNoParameters(table); + + table["policy_table"]["functional_groupings"]["default"]["rpcs"]["Update"] + ["parameters"] = Json::Value(Json::arrayValue); + table["policy_table"]["functional_groupings"]["default"]["rpcs"]["Update"] + ["parameters"][0] = Json::Value("speed"); + } + + void PolicyTableUpdatePrepareEmptyParameters(Json::Value& table) { + PolicyTableUpdatePrepareNoParameters(table); + + // Parameters are empty + table["policy_table"]["functional_groupings"]["default"]["rpcs"]["Update"] + ["parameters"] = Json::Value(Json::arrayValue); + } + + void PolicyTableUpdatePrepareNoParameters(Json::Value& table) { + table["policy_table"] = Json::Value(Json::objectValue); + Json::Value& policy_table = table["policy_table"]; + policy_table["module_config"] = Json::Value(Json::objectValue); + policy_table["functional_groupings"] = Json::Value(Json::objectValue); + policy_table["consumer_friendly_messages"] = Json::Value(Json::objectValue); + policy_table["app_policies"] = Json::Value(Json::objectValue); + + Json::Value& module_config = policy_table["module_config"]; + module_config["exchange_after_x_ignition_cycles"] = Json::Value(10); + module_config["exchange_after_x_kilometers"] = Json::Value(100); + module_config["exchange_after_x_days"] = Json::Value(5); + module_config["timeout_after_x_seconds"] = Json::Value(500); + module_config["seconds_between_retries"] = Json::Value(Json::arrayValue); + Json::Value& seconds_between_retries = + module_config["seconds_between_retries"]; + seconds_between_retries[0] = Json::Value(10); + seconds_between_retries[1] = Json::Value(20); + seconds_between_retries[2] = Json::Value(30); + module_config["endpoints"] = Json::Value(Json::objectValue); + Json::Value& endpoins = module_config["endpoints"]; + endpoins["0x00"] = Json::Value(Json::objectValue); + endpoins["0x00"]["default"] = Json::Value(Json::arrayValue); + endpoins["0x00"]["default"][0] = + Json::Value("http://ford.com/cloud/default"); + module_config["notifications_per_minute_by_priority"] = + Json::Value(Json::objectValue); + module_config["notifications_per_minute_by_priority"]["emergency"] = + Json::Value(1); + module_config["notifications_per_minute_by_priority"]["navigation"] = + Json::Value(2); + module_config["notifications_per_minute_by_priority"]["VOICECOMM"] = + Json::Value(3); + module_config["notifications_per_minute_by_priority"]["communication"] = + Json::Value(4); + module_config["notifications_per_minute_by_priority"]["normal"] = + Json::Value(5); + module_config["notifications_per_minute_by_priority"]["none"] = + Json::Value(6); + module_config["vehicle_make"] = Json::Value("MakeT"); + module_config["vehicle_model"] = Json::Value("ModelT"); + module_config["vehicle_year"] = Json::Value("2014"); + module_config["certificate"] = Json::Value("my_cert"); + + Json::Value& functional_groupings = policy_table["functional_groupings"]; + functional_groupings["default"] = Json::Value(Json::objectValue); + Json::Value& default_group = functional_groupings["default"]; + default_group["rpcs"] = Json::Value(Json::objectValue); + default_group["rpcs"]["Update"] = Json::Value(Json::objectValue); + default_group["rpcs"]["Update"]["hmi_levels"] = + Json::Value(Json::arrayValue); + default_group["rpcs"]["Update"]["hmi_levels"][0] = Json::Value("FULL"); + // No parameters + + Json::Value& consumer_friendly_messages = + policy_table["consumer_friendly_messages"]; + consumer_friendly_messages["version"] = Json::Value("1.2"); + consumer_friendly_messages["messages"] = Json::Value(Json::objectValue); + consumer_friendly_messages["messages"]["MSG1"] = + Json::Value(Json::objectValue); + Json::Value& msg1 = consumer_friendly_messages["messages"]["MSG1"]; + msg1["languages"] = Json::Value(Json::objectValue); + msg1["languages"]["en-us"] = Json::Value(Json::objectValue); + msg1["languages"]["en-us"]["tts"] = Json::Value("TTS message"); + msg1["languages"]["en-us"]["label"] = Json::Value("LABEL message"); + msg1["languages"]["en-us"]["line1"] = Json::Value("LINE1 message"); + msg1["languages"]["en-us"]["line2"] = Json::Value("LINE2 message"); + msg1["languages"]["en-us"]["textBody"] = Json::Value("TEXTBODY message"); + + Json::Value& app_policies = policy_table["app_policies"]; + app_policies["default"] = Json::Value(Json::objectValue); + app_policies["default"]["priority"] = Json::Value("EMERGENCY"); + app_policies["default"]["memory_kb"] = Json::Value(50); + app_policies["default"]["heart_beat_timeout_ms"] = Json::Value(100); + app_policies["default"]["groups"] = Json::Value(Json::arrayValue); + app_policies["default"]["groups"][0] = Json::Value("default"); + app_policies["default"]["priority"] = Json::Value("EMERGENCY"); + app_policies["default"]["is_revoked"] = Json::Value(true); + app_policies["default"]["default_hmi"] = Json::Value("FULL"); + app_policies["default"]["keep_context"] = Json::Value(true); + app_policies["default"]["steal_focus"] = Json::Value(true); + + app_policies["pre_DataConsent"] = Json::Value(Json::objectValue); + app_policies["pre_DataConsent"]["memory_kb"] = Json::Value(40); + app_policies["pre_DataConsent"]["heart_beat_timeout_ms"] = Json::Value(90); + app_policies["pre_DataConsent"]["groups"] = Json::Value(Json::arrayValue); + app_policies["pre_DataConsent"]["groups"][0] = Json::Value("default"); + app_policies["pre_DataConsent"]["priority"] = Json::Value("EMERGENCY"); + app_policies["pre_DataConsent"]["default_hmi"] = Json::Value("FULL"); + app_policies["pre_DataConsent"]["is_revoked"] = Json::Value(false); + app_policies["pre_DataConsent"]["keep_context"] = Json::Value(true); + app_policies["pre_DataConsent"]["steal_focus"] = Json::Value(true); + app_policies["1234"] = Json::Value(Json::objectValue); + app_policies["1234"]["memory_kb"] = Json::Value(150); + app_policies["1234"]["heart_beat_timeout_ms"] = Json::Value(200); + app_policies["1234"]["groups"] = Json::Value(Json::arrayValue); + app_policies["1234"]["groups"][0] = Json::Value("default"); + app_policies["1234"]["priority"] = Json::Value("EMERGENCY"); + app_policies["1234"]["default_hmi"] = Json::Value("FULL"); + app_policies["1234"]["is_revoked"] = Json::Value(true); + app_policies["1234"]["keep_context"] = Json::Value(false); + app_policies["1234"]["steal_focus"] = Json::Value(false); + app_policies["device"] = Json::Value(Json::objectValue); + app_policies["device"]["groups"] = Json::Value(Json::arrayValue); + app_policies["device"]["groups"][0] = Json::Value("default"); + app_policies["device"]["priority"] = Json::Value("EMERGENCY"); + app_policies["device"]["is_revoked"] = Json::Value(true); + app_policies["device"]["default_hmi"] = Json::Value("FULL"); + app_policies["device"]["keep_context"] = Json::Value(true); + app_policies["device"]["steal_focus"] = Json::Value(true); + } + + ::testing::AssertionResult IsValid(const policy_table::Table& table) { + if (table.is_valid()) { + return ::testing::AssertionSuccess(); + } else { + ::rpc::ValidationReport report(" - table"); + table.ReportErrors(&report); + return ::testing::AssertionFailure() << ::rpc::PrettyFormat(report); + } + } +}; + +SQLPTRepresentation* SQLPTRepresentationTest::reps = 0; +utils::dbms::SQLQuery* SQLPTRepresentationTest::query_wrapper_ = 0; +const std::string SQLPTRepresentationTest::kDatabaseName = ":memory:"; +const bool SQLPTRepresentationTest::in_memory_ = true; +std::auto_ptr<policy_handler_test::MockPolicySettings> + SQLPTRepresentationTest::policy_settings_; + +class SQLPTRepresentationTest2 : public ::testing::Test { + protected: + SQLPTRepresentation* reps; + NiceMock<policy_handler_test::MockPolicySettings> policy_settings_; + virtual void SetUp() OVERRIDE { + file_system::CreateDirectory(kAppStorageFolder); + chmod(kAppStorageFolder.c_str(), 00000); + ON_CALL(policy_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kAppStorageFolder)); + ON_CALL(policy_settings_, open_attempt_timeout_ms()) + .WillByDefault(Return(kOpenAttemptTimeoutMs)); + ON_CALL(policy_settings_, attempts_to_open_policy_db()) + .WillByDefault(Return(kAttemptsToOpenPolicyDB)); + reps = new SQLPTRepresentation; + ASSERT_TRUE(reps != NULL); + } + + virtual void TearDown() OVERRIDE { + file_system::RemoveDirectory(kAppStorageFolder, true); + delete reps; + } + const std::string kAppStorageFolder = "storage123"; + const uint16_t kOpenAttemptTimeoutMs = 70u; + const uint16_t kAttemptsToOpenPolicyDB = 2u; +}; + +TEST_F(SQLPTRepresentationTest2, + CheckActualAttemptsToOpenDB_ExpectCorrectNumber) { + EXPECT_EQ(::policy::FAIL, reps->Init(&policy_settings_)); + // Check Actual attempts number made to try to open DB + EXPECT_EQ(kAttemptsToOpenPolicyDB, reps->open_counter()); +} + +TEST_F(SQLPTRepresentationTest, + RefreshDB_DropExistedPTThenRefreshDB_ExpectTablesWithInitialData) { + // Check + utils::dbms::SQLQuery query(reps->db()); + const std::string query_select = + "SELECT COUNT(*) FROM sqlite_master WHERE `type` = 'table'"; + // In normally created PT there are more than 0 tables + query.Prepare(query_select); + query.Next(); + ASSERT_GT(query.GetInteger(0), 0); + query.Finalize(); + + ASSERT_TRUE(reps->Drop()); + query.Prepare(query_select); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + query.Finalize(); + + ASSERT_TRUE(reps->RefreshDB()); + // Check PT structure destroyed and tables number is 0 + query.Prepare(query_select); + query.Next(); + ASSERT_EQ(25, query.GetInteger(0)); + + const std::string query_select_count_of_iap_buffer_full = + "SELECT `count_of_iap_buffer_full` FROM `usage_and_error_count`"; + const std::string query_select_count_sync_out_of_memory = + "SELECT `count_sync_out_of_memory` FROM `usage_and_error_count`"; + const std::string query_select_count_of_sync_reboots = + "SELECT `count_of_sync_reboots` FROM `usage_and_error_count`"; + const std::string query_select_pt_exchanged_at_odometer_x = + "SELECT `pt_exchanged_at_odometer_x` FROM `module_meta`"; + const std::string query_select_pt_exchanged_x_days_after_epoch = + "SELECT `pt_exchanged_x_days_after_epoch` FROM `module_meta`"; + const std::string query_select_flag_update_required = + "SELECT `flag_update_required` FROM `module_meta`"; + const std::string query_select_ignition_cycles_since_last_exchange = + "SELECT `ignition_cycles_since_last_exchange` FROM `module_meta`"; + const std::string query_select_preloaded_pt = + "SELECT `preloaded_pt` FROM `module_config`"; + const std::string query_select_is_first_run = + "SELECT `is_first_run` FROM `module_config`"; + const std::string query_select_exchange_after_x_ignition_cycles = + "SELECT `exchange_after_x_ignition_cycles` FROM `module_config`"; + const std::string query_select_exchange_after_x_kilometers = + "SELECT `exchange_after_x_kilometers` FROM `module_config`"; + const std::string query_select_exchange_after_x_days = + "SELECT `exchange_after_x_days` FROM `module_config`"; + const std::string query_select_timeout_after_x_seconds = + "SELECT `timeout_after_x_seconds` FROM `module_config`"; + const std::string query_select_priorities = + "SELECT COUNT(`value`) FROM `priority`"; + const std::string query_select_hmi_levels = + "SELECT COUNT(`value`) FROM `hmi_level`"; + const std::string query_select_version = "SELECT `number` FROM `version`"; + + query.Prepare(query_select_count_of_iap_buffer_full); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_count_sync_out_of_memory); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_count_of_sync_reboots); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_pt_exchanged_at_odometer_x); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_pt_exchanged_x_days_after_epoch); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_ignition_cycles_since_last_exchange); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_flag_update_required); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_preloaded_pt); + query.Next(); + ASSERT_EQ(1, query.GetInteger(0)); + + query.Prepare(query_select_is_first_run); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_exchange_after_x_ignition_cycles); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_exchange_after_x_kilometers); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_exchange_after_x_days); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_timeout_after_x_seconds); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_priorities); + query.Next(); + ASSERT_EQ(6, query.GetInteger(0)); + + query.Prepare(query_select_hmi_levels); + query.Next(); + ASSERT_EQ(4, query.GetInteger(0)); + + query.Prepare(query_select_version); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); +} + +TEST_F( + SQLPTRepresentationTest, + CheckPermissionsAllowed_SetValuesInAppGroupRpcFunctionalGroup_GetEqualParamsInCheckPermissionResult) { + // Arrange + const std::string query = + "INSERT OR REPLACE INTO `application` (`id`, `memory_kb`," + " `heart_beat_timeout_ms`) VALUES ('12345', 5, 10); " + "INSERT OR REPLACE INTO functional_group (`id`, `name`)" + " VALUES (1, 'Base-4'); " + "INSERT OR REPLACE INTO `app_group` (`application_id`," + " `functional_group_id`) VALUES ('12345', 1); " + "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`," + " `functional_group_id`) VALUES ('Update', 'gps', 'FULL', 1); " + "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`," + " `functional_group_id`) VALUES ('Update', 'speed', 'FULL', 1);"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query)); + + // Act + CheckPermissionResult ret; + reps->CheckPermissions("12345", "FULL", "Update", ret); + + // Assert + EXPECT_TRUE(ret.hmi_level_permitted == ::policy::kRpcAllowed); + ASSERT_EQ(2u, ret.list_of_allowed_params.size()); + EXPECT_TRUE(ret.list_of_allowed_params.end() != + ret.list_of_allowed_params.find("gps")); + EXPECT_TRUE(ret.list_of_allowed_params.end() != + ret.list_of_allowed_params.find("speed")); +} + +TEST_F( + SQLPTRepresentationTest, + CheckPermissionsAllowedWithoutParameters_SetLimitedPermissions_ExpectEmptyListOfAllowedParams) { + // Arrange + const std::string query = + "INSERT OR REPLACE INTO `application` (`id`, `memory_kb`," + " `heart_beat_timeout_ms`) VALUES ('12345', 5, 10); " + "INSERT OR REPLACE INTO functional_group (`id`, `name`)" + " VALUES (1, 'Base-4'); " + "INSERT OR REPLACE INTO `app_group` (`application_id`," + " `functional_group_id`) VALUES ('12345', 1); " + "DELETE FROM `rpc`; " + "INSERT OR REPLACE INTO `rpc` (`name`, `hmi_level_value`," + " `functional_group_id`) VALUES ('Update', 'LIMITED', 1);"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query)); + + // Act + CheckPermissionResult ret; + reps->CheckPermissions("12345", "LIMITED", "Update", ret); + + // Assert + EXPECT_TRUE(ret.hmi_level_permitted == ::policy::kRpcAllowed); + EXPECT_TRUE(ret.list_of_allowed_params.empty()); +} + +TEST_F( + SQLPTRepresentationTest, + CheckPermissionsDisallowedWithoutParameters_DeletedAppGroupAndSetFULLLevel_ExpectHmiLevelIsDissalowed) { + // Arrange + const std::string query = "DELETE FROM `app_group`"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query)); + + // Act + CheckPermissionResult ret; + reps->CheckPermissions("12345", "FULL", "Update", ret); + + // Assert + EXPECT_EQ(::policy::kRpcDisallowed, ret.hmi_level_permitted); + EXPECT_TRUE(ret.list_of_allowed_params.empty()); +} + +TEST_F(SQLPTRepresentationTest, + PTPReloaded_UpdateModuleConfig_ReturnIsPTPreloadedTRUE) { + // Arrange + const std::string query = "UPDATE `module_config` SET `preloaded_pt` = 1"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query)); + EXPECT_TRUE(reps->IsPTPreloaded()); +} + +TEST_F(SQLPTRepresentationTest, + GetUpdateUrls_DeleteAndInsertEndpoints_ExpectUpdateUrls) { + // Arrange + const std::string query_delete = "DELETE FROM `endpoint`; "; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_delete)); + + // Act + EndpointUrls ret = reps->GetUpdateUrls(7); + + // Assert + EXPECT_TRUE(ret.empty()); + + // Act + const std::string query_insert = + "INSERT INTO `endpoint` (`application_id`, `url`, `service`) " + " VALUES ('12345', 'http://ford.com/cloud/1', 7);" + "INSERT INTO `endpoint` (`application_id`, `url`, `service`) " + " VALUES ('12345', 'http://ford.com/cloud/2', 7);"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + // Act + ret = reps->GetUpdateUrls(7); + + // Assert + ASSERT_EQ(2u, ret.size()); + EXPECT_EQ("http://ford.com/cloud/1", ret[0].url[0]); + EXPECT_EQ("http://ford.com/cloud/2", ret[1].url[0]); + + // Act + ret = reps->GetUpdateUrls(0); + + // Assert + EXPECT_TRUE(ret.empty()); +} + +TEST_F(SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithParametersOfQueryEqualZero) { + // Arrange + const std::string query_zeros = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = 0; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 0"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_zeros)); + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); + + // Act + reps->IncrementIgnitionCycles(); + + // Assert + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F(SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithParametersOfQueryAreLessLimit) { + // Arrange + const std::string query_less_limit = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = 5; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_less_limit)); + EXPECT_EQ(5, reps->IgnitionCyclesBeforeExchange()); + + // Act + reps->IncrementIgnitionCycles(); + + // Assert + EXPECT_EQ(4, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F(SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithLimitCountOfParametersOfQuery) { + // Arrange + const std::string query_limit = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = 9; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_limit)); + EXPECT_EQ(1, reps->IgnitionCyclesBeforeExchange()); + // Act + reps->IncrementIgnitionCycles(); + // Assert + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F(SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithMoreLimitCountOfParametersOfQuery) { + // Arrange + const std::string query_more_limit = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = 12; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_more_limit)); + // Chceck + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F(SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithNegativeLimitOfParametersOfQuery) { + // Arrange + const std::string query_negative_limit = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = 3; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = -1"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_limit)); + // Check + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F( + SQLPTRepresentationTest, + IgnitionCyclesBeforeExchange_WithNegativeLimitOfCurrentParameterOfQuery) { + // Arrange + const std::string query_negative_current = + "UPDATE `module_meta` SET " + " `ignition_cycles_since_last_exchange` = -1; " + " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 2"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_current)); + // Check + EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange()); +} + +TEST_F(SQLPTRepresentationTest, + KilometersBeforeExchange_WithParametersOfQueryEqualZero) { + // Arrange + const std::string query_zeros = + "UPDATE `module_meta` SET " + " `pt_exchanged_at_odometer_x` = 0; " + " UPDATE `module_config` SET `exchange_after_x_kilometers` = 0"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_zeros)); + // Checks + EXPECT_EQ(0, reps->KilometersBeforeExchange(0)); + EXPECT_EQ(0, reps->KilometersBeforeExchange(-10)); + EXPECT_EQ(0, reps->KilometersBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, + KilometersBeforeExchange_QueryWithNegativeLimit) { + // Arrange + const std::string query_negative_limit = + "UPDATE `module_meta` SET " + " `pt_exchanged_at_odometer_x` = 10; " + " UPDATE `module_config` SET `exchange_after_x_kilometers` = -10"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_limit)); + // Checks + EXPECT_EQ(0, reps->KilometersBeforeExchange(0)); + EXPECT_EQ(0, reps->KilometersBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, + KilometersBeforeExchange_QueryWithNegativeCurrentLimit) { + // Arrange + const std::string query_negative_last = + "UPDATE `module_meta` SET " + " `pt_exchanged_at_odometer_x` = -10; " + " UPDATE `module_config` SET `exchange_after_x_kilometers` = 20"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_last)); + // Checks + EXPECT_EQ(0, reps->KilometersBeforeExchange(0)); + EXPECT_EQ(0, reps->KilometersBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, + KilometersBeforeExchange_QueryWithLimitParameters) { + // Arrange + const std::string query_limit = + "UPDATE `module_meta` SET " + " `pt_exchanged_at_odometer_x` = 10; " + " UPDATE `module_config` SET `exchange_after_x_kilometers` = 100"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_limit)); + // Checks + EXPECT_EQ(0, reps->KilometersBeforeExchange(120)); + EXPECT_EQ(60, reps->KilometersBeforeExchange(50)); + EXPECT_EQ(0, reps->KilometersBeforeExchange(5)); +} + +TEST_F(SQLPTRepresentationTest, + DaysBeforeExchange_WithParametersOfQueryEqualZero) { + // Arrange + const std::string query_zeros = + "UPDATE `module_meta` SET " + " `pt_exchanged_x_days_after_epoch` = 0; " + " UPDATE `module_config` SET `exchange_after_x_days` = 0"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_zeros)); + // Checks + EXPECT_EQ(0, reps->DaysBeforeExchange(0)); + EXPECT_EQ(0, reps->DaysBeforeExchange(-10)); + EXPECT_EQ(0, reps->DaysBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, DaysBeforeExchange_QueryWithNegativeLimit) { + // Arrange + const std::string query_negative_limit = + "UPDATE `module_meta` SET " + " `pt_exchanged_x_days_after_epoch` = 10; " + " UPDATE `module_config` SET `exchange_after_x_days` = -10"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_limit)); + // Checks + EXPECT_EQ(0, reps->DaysBeforeExchange(0)); + EXPECT_EQ(0, reps->DaysBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, + DaysBeforeExchange_QueryWithNegativeCurrentLimit) { + // Arrange + const std::string query_negative_last = + "UPDATE `module_meta` SET " + " `pt_exchanged_x_days_after_epoch` = -10; " + " UPDATE `module_config` SET `exchange_after_x_days` = 20"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_negative_last)); + // Checks + EXPECT_EQ(0, reps->DaysBeforeExchange(0)); + EXPECT_EQ(0, reps->DaysBeforeExchange(10)); +} + +TEST_F(SQLPTRepresentationTest, DaysBeforeExchange_QueryWithLimitParameters) { + // Arrange + const std::string query_limit = + "UPDATE `module_meta` SET " + " `pt_exchanged_x_days_after_epoch` = 10; " + " UPDATE `module_config` SET `exchange_after_x_days` = 100"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_limit)); + // Checks + EXPECT_EQ(0, reps->DaysBeforeExchange(120)); + EXPECT_EQ(60, reps->DaysBeforeExchange(50)); + EXPECT_EQ(0, reps->DaysBeforeExchange(5)); +} + +TEST_F( + SQLPTRepresentationTest, + SecondsBetweenRetries_DeletedAndInsertedSecondsBetweenRetry_ExpectCountOfSecondsEqualInserted) { + // Arrange + std::vector<int> seconds; + const std::string query_delete = "DELETE FROM `seconds_between_retry`; "; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_delete)); + ASSERT_TRUE(reps->SecondsBetweenRetries(&seconds)); + EXPECT_EQ(0u, seconds.size()); + + // Arrange + const std::string query_insert = + "INSERT INTO `seconds_between_retry` (`index`, `value`) " + " VALUES (0, 10); " + "INSERT INTO `seconds_between_retry` (`index`, `value`) " + " VALUES (1, 20); "; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + ASSERT_TRUE(reps->SecondsBetweenRetries(&seconds)); + // Checks + ASSERT_EQ(2u, seconds.size()); + EXPECT_EQ(10, seconds[0]); + EXPECT_EQ(20, seconds[1]); +} + +TEST_F(SQLPTRepresentationTest, TimeoutResponse_Set60Seconds_GetEqualTimeout) { + // Arrange + const std::string query = + "UPDATE `module_config` SET `timeout_after_x_seconds` = 60"; + + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query)); + // Check + EXPECT_EQ(60000, reps->TimeoutResponse()); +} + +TEST_F(SQLPTRepresentationTest, + IsPTPreloaded_SetPTPreloadedThenCheck_ExpectCorrectValue) { + // Arrange + const std::string query_insert = + "UPDATE `module_config` SET `preloaded_pt` = 1"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + // Check + ASSERT_TRUE(reps->IsPTPreloaded()); +} + +TEST_F( + SQLPTRepresentationTest, + SetCountersPassedForSuccessfulUpdate_SetCounters_ExpectValueChangedInPT) { + // Arrange + utils::dbms::SQLQuery query(reps->db()); + const std::string query_select_odometer = + "SELECT `pt_exchanged_at_odometer_x` FROM`module_meta`"; + const std::string query_select_days_after_epoch = + "SELECT `pt_exchanged_x_days_after_epoch` FROM`module_meta`"; + query.Prepare(query_select_odometer); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + query.Prepare(query_select_days_after_epoch); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + + // Act + ASSERT_TRUE(reps->SetCountersPassedForSuccessfulUpdate(100, 10000)); + query.Prepare(query_select_odometer); + query.Next(); + ASSERT_EQ(100, query.GetInteger(0)); + + query.Prepare(query_select_days_after_epoch); + query.Next(); + ASSERT_EQ(10000, query.GetInteger(0)); +} + +TEST_F( + SQLPTRepresentationTest, + IncrementIgnitionCycles_SetIgnitionCyclesValueThenIncrement_ExpectValueIncrementedInPT) { + // Arrange + utils::dbms::SQLQuery query(reps->db()); + const std::string query_insert = + "UPDATE `module_meta` SET `ignition_cycles_since_last_exchange` = 54"; + const std::string query_select = + "SELECT `ignition_cycles_since_last_exchange`FROM `module_meta`"; + ASSERT_TRUE(query.Exec(query_insert)); + // Act + reps->IncrementIgnitionCycles(); + // Check + query.Prepare(query_select); + query.Next(); + ASSERT_EQ(55, query.GetInteger(0)); +} + +TEST_F( + SQLPTRepresentationTest, + ResetIgnitionCycles_SetIgnitionCyclesValueThenReset_ExpectZeroValueInPT) { + // Arrange + utils::dbms::SQLQuery query(reps->db()); + const std::string query_insert = + "UPDATE `module_meta` SET `ignition_cycles_since_last_exchange` = 55"; + const std::string query_select = + "SELECT `ignition_cycles_since_last_exchange` FROM `module_meta`"; + ASSERT_TRUE(query.Exec(query_insert)); + // Act + reps->ResetIgnitionCycles(); + // Check + query.Prepare(query_select); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); +} + +TEST_F( + SQLPTRepresentationTest, + GetVehicleInfo_ManuallySetVehcleInfoThenCallGetVehicleInfo_ExpectValuesReceived) { + // Check + const std::string query_insert_module_config = + "UPDATE `module_config` SET `preloaded_pt` = 1, " + " `exchange_after_x_ignition_cycles` = 50," + " `exchange_after_x_kilometers` = 2000, `exchange_after_x_days` = 30," + " `timeout_after_x_seconds` = 5, `vehicle_make` = 'FORD', " + " `vehicle_model` = 'MUSTANG', `vehicle_year` = '2003', " + "`preloaded_date` = '25.04.2015'"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_module_config)); + VehicleInfo info = reps->GetVehicleInfo(); + + ASSERT_EQ("FORD", info.vehicle_make); + ASSERT_EQ("MUSTANG", info.vehicle_model); + ASSERT_EQ("2003", info.vehicle_year); +} + +TEST_F(SQLPTRepresentationTest, + GetUserFriendlyMsg_SetMsg_ExpectReceivedMsgSetInParams) { + // Arrange + + const std::string query_insert_language_code = + "INSERT INTO `message` (`language_code`, `message_type_name`) VALUES " + "('en-en', 'AppPermissions')"; + + ASSERT_TRUE(query_wrapper_->Exec(query_insert_language_code)); + const std::string query_insert_name = + "INSERT INTO `message_type` (`name`) VALUES ('AppPermissions')"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_name)); + std::vector<std::string> msg_code; + msg_code.push_back("AppPermissions"); + // Act + std::vector<UserFriendlyMessage> result = + reps->GetUserFriendlyMsg(msg_code, std::string("en-en")); + // Checks + ASSERT_EQ(1u, result.size()); + EXPECT_EQ(result[0].message_code, "AppPermissions"); +} + +TEST_F( + SQLPTRepresentationTest, + GetNotificationNumber_SetNotificationsPriorities_ExpectReceivedValuesCorrect) { + // Arrange + const std::string query_insert = + "INSERT INTO `notifications_by_priority` (`priority_value`, `value`) " + "VALUES ('NAVIGATION', 15) , " + "('COMMUNICATION', 6), ('EMERGENCY', 60), ('NONE', 0), ('NORMAL', 4), " + "('VOICECOMMUNICATION', 20)"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + EXPECT_EQ(6, reps->GetNotificationsNumber("COMMUNICATION")); + EXPECT_EQ(60, reps->GetNotificationsNumber("EMERGENCY")); + EXPECT_EQ(15, reps->GetNotificationsNumber("NAVIGATION")); + EXPECT_EQ(0, reps->GetNotificationsNumber("NONE")); + EXPECT_EQ(4, reps->GetNotificationsNumber("NORMAL")); + EXPECT_EQ(20, reps->GetNotificationsNumber("VOICECOMMUNICATION")); +} + +TEST_F(SQLPTRepresentationTest, + GetPriority_SetAppsPrioritiesThenGet_ExpectReceivedValuesCorrect) { + // Arrange + const std::string query_insert_app_default = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'default', 0, 0, 'NONE', 'NONE', 0, " + "0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_default)); + + const std::string query_insert_app_pre_DataConsent = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'pre_DataConsent', 0, 0, 'NONE', " + "'NONE', 0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_pre_DataConsent)); + + const std::string query_insert_app_device = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'device', 0, 0, 'NONE', " + "'COMMUNICATION', 0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_device)); + + const std::string query_insert_app_12345 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '12345', 0, 0, 'NONE', 'EMERGENCY', " + "0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_12345)); + + std::string priority; + // Checks + EXPECT_TRUE(reps->GetPriority("default", &priority)); + EXPECT_EQ("NONE", priority); + EXPECT_TRUE(reps->GetPriority("pre_DataConsent", &priority)); + EXPECT_EQ("NONE", priority); + EXPECT_TRUE(reps->GetPriority("device", &priority)); + EXPECT_EQ("COMMUNICATION", priority); + EXPECT_TRUE(reps->GetPriority("12345", &priority)); + EXPECT_EQ("EMERGENCY", priority); +} + +namespace { +const std::string kAppStorageFolder = "storage"; +} +TEST(SQLPTRepresentationTest3, Init_InitNewDataBase_ExpectResultSuccess) { + // Arrange + const bool in_memory_ = true; + NiceMock<policy_handler_test::MockPolicySettings> policy_settings_; + SQLPTRepresentation reps(in_memory_); + // Checks + ON_CALL(policy_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kAppStorageFolder)); + EXPECT_EQ(::policy::SUCCESS, reps.Init(&policy_settings_)); + EXPECT_EQ(::policy::EXISTS, reps.Init(&policy_settings_)); + reps.RemoveDB(); +} + +TEST(SQLPTRepresentationTest3, + Init_TryInitNotExistingDataBase_ExpectResultFail) { + // Arrange + NiceMock<policy_handler_test::MockPolicySettings> policy_settings_; + const std::string not_existing_path = "/not/existing/path"; + ON_CALL(policy_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(not_existing_path)); + SQLPTRepresentation reps; + // Check + EXPECT_EQ(::policy::FAIL, reps.Init(&policy_settings_)); +} + +TEST(SQLPTRepresentationTest3, + Close_InitNewDataBaseThenClose_ExpectResultSuccess) { + // Arrange + NiceMock<policy_handler_test::MockPolicySettings> policy_settings_; + ON_CALL(policy_settings_, app_storage_folder()) + .WillByDefault(ReturnRef(kAppStorageFolder)); + const bool in_memory_ = true; + SQLPTRepresentation reps(in_memory_); + EXPECT_EQ(::policy::SUCCESS, reps.Init(&policy_settings_)); + EXPECT_TRUE(reps.Close()); + utils::dbms::SQLError error(utils::dbms::Error::OK); + // Checks + EXPECT_EQ(error.number(), (reps.db()->LastError().number())); + reps.RemoveDB(); +} + +TEST_F(SQLPTRepresentationTest, + Clear_InitNewDataBaseThenClear_ExpectResultSuccess) { + // Arrange + const std::string query_insert_app_default = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'default', 0, 0, 'NONE', 'NONE', 0, " + "0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_default)); + + const std::string query_insert_app_pre_DataConsent = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'pre_DataConsent', 0, 0, 'NONE', " + "'NONE', 0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_pre_DataConsent)); + + const std::string query_insert_app_device = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'device', 0, 0, 'NONE', " + "'COMMUNICATION', 0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_device)); + + const std::string query_insert_app_12345 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '12345', 0, 0, 'NONE', 'EMERGENCY', " + "0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_12345)); + + const std::string query_insert = + "INSERT INTO `notifications_by_priority` (`priority_value`, `value`) " + "VALUES ('NAVIGATION', 15) , " + "('COMMUNICATION', 6), ('EMERGENCY', 60), ('NONE', 0), ('NORMAL', 4), " + "('VOICECOMMUNICATION', 20)"; + + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + EXPECT_TRUE(reps->Clear()); + utils::dbms::SQLError error(utils::dbms::Error::OK); + EXPECT_EQ(error.number(), (reps->db()->LastError().number())); +} + +TEST_F(SQLPTRepresentationTest, + GetInitialAppData_SetData_ExpectCorrectValuesReceived) { + // Arrange + const std::string query_insert_nickname = + "INSERT INTO `nickname` (`application_id`, `name`)" + "VALUES ('1111', 'first_app') , " + "('2222', 'second_app'), ('3333', 'third_app')"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_nickname)); + + const std::string query_insert_app_type = + "INSERT INTO `app_type` (`application_id`, `name`)" + "VALUES ('1111', 'NAVIGATION') , " + "('1111', 'MEDIA'), ('3333', 'COMMUNICATION')"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_type)); + ::policy::StringArray nicknames; + ::policy::StringArray app_types; + ASSERT_TRUE(reps->GetInitialAppData("1111", &nicknames, &app_types)); + EXPECT_EQ(1u, nicknames.size()); + EXPECT_TRUE(nicknames.end() != + std::find(nicknames.begin(), nicknames.end(), "first_app")); + EXPECT_EQ(2u, app_types.size()); + EXPECT_TRUE(app_types.end() != + std::find(app_types.begin(), app_types.end(), "NAVIGATION")); + EXPECT_TRUE(app_types.end() != + std::find(app_types.begin(), app_types.end(), "MEDIA")); + nicknames.clear(); + app_types.clear(); + ASSERT_TRUE(reps->GetInitialAppData("2222", &nicknames, &app_types)); + EXPECT_EQ(1u, nicknames.size()); + EXPECT_TRUE(nicknames.end() != + std::find(nicknames.begin(), nicknames.end(), "second_app")); + EXPECT_EQ(0u, app_types.size()); + nicknames.clear(); + app_types.clear(); + ASSERT_TRUE(reps->GetInitialAppData("3333", &nicknames, &app_types)); + EXPECT_EQ(1u, nicknames.size()); + EXPECT_TRUE(nicknames.end() != + std::find(nicknames.begin(), nicknames.end(), "third_app")); + EXPECT_EQ(1u, app_types.size()); + EXPECT_TRUE(app_types.end() != + std::find(app_types.begin(), app_types.end(), "COMMUNICATION")); +} + +TEST_F( + SQLPTRepresentationTest, + GetFunctionalGroupings_SetFunctionalGroupings_ExpectCorrectValuesReceived) { + // Arrange + const std::string query_insert_functional_group = + "INSERT INTO `functional_group` (`id`, `user_consent_prompt`, `name`) " + "VALUES (73072936, null, 'SendLocation'), (1533011474, null, " + "'OnKeyboardInputOnlyGroup')"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_functional_group)); + + const std::string query_insert_SendLocation = + "INSERT INTO `rpc` (`name`, `hmi_level_value`, `functional_group_id`) " + "VALUES ('SendLocation', 'BACKGROUND', 73072936), ('SendLocation', " + "'FULL', 73072936), ('SendLocation', 'LIMITED', 73072936)"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_SendLocation)); + + const std::string query_insert_OnKeyboardInput = + "INSERT INTO `rpc` (`name`, `hmi_level_value`, `functional_group_id`) " + "VALUES ('OnKeyboardInput', 'FULL', 1533011474)"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_OnKeyboardInput)); + + policy_table::FunctionalGroupings func_groups; + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + EXPECT_EQ(2u, func_groups.size()); + policy_table::FunctionalGroupings::iterator func_groups_it = + func_groups.find("SendLocation"); + EXPECT_TRUE(func_groups.end() != func_groups_it); + policy_table::Rpcs& rpcs = func_groups_it->second; + EXPECT_EQ("", static_cast<std::string>(*rpcs.user_consent_prompt)); + policy_table::Rpc& rpc = rpcs.rpcs; + EXPECT_EQ(1u, rpc.size()); + policy_table::Rpc::const_iterator rpc_it = rpc.find("SendLocation"); + EXPECT_TRUE(rpc.end() != rpc_it); + const policy_table::HmiLevels& hmi_levels1 = rpc_it->second.hmi_levels; + EXPECT_EQ(3u, hmi_levels1.size()); + EXPECT_TRUE(hmi_levels1.end() != + std::find(hmi_levels1.begin(), + hmi_levels1.end(), + policy_table::HmiLevel::HL_BACKGROUND)); + EXPECT_TRUE(hmi_levels1.end() != + std::find(hmi_levels1.begin(), + hmi_levels1.end(), + policy_table::HmiLevel::HL_LIMITED)); + EXPECT_TRUE(hmi_levels1.end() != std::find(hmi_levels1.begin(), + hmi_levels1.end(), + policy_table::HmiLevel::HL_FULL)); + + func_groups_it = func_groups.find("OnKeyboardInputOnlyGroup"); + EXPECT_TRUE(func_groups.end() != func_groups_it); + policy_table::Rpcs& rpcs2 = func_groups_it->second; + EXPECT_EQ("", static_cast<std::string>(*rpcs2.user_consent_prompt)); + policy_table::Rpc& rpc2 = rpcs2.rpcs; + EXPECT_EQ(1u, rpc2.size()); + rpc_it = rpc2.find("OnKeyboardInput"); + EXPECT_TRUE(rpc2.end() != rpc_it); + const policy_table::HmiLevels& hmi_levels2 = rpc_it->second.hmi_levels; + EXPECT_EQ(1u, hmi_levels2.size()); + EXPECT_TRUE(hmi_levels2.end() != std::find(hmi_levels2.begin(), + hmi_levels2.end(), + policy_table::HmiLevel::HL_FULL)); +} + +TEST_F( + SQLPTRepresentationTest, + UpdateRequired_SetUpdateNotRequiredFlagThenCheck_ExpectUpdateNotRequired) { + // Arrange + EXPECT_FALSE(reps->UpdateRequired()); +} + +TEST_F(SQLPTRepresentationTest, + UpdateRequired_SetUpdateRequiredFlagThenCheck_ExpectUpdateRequired) { + // Arrange + const std::string query_insert = + "UPDATE `module_meta` SET `flag_update_required` = 1"; + // Assert + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + // Check + EXPECT_TRUE(reps->UpdateRequired()); +} + +TEST_F(SQLPTRepresentationTest, + SaveUpdateRequired_SaveUpdateRequired_ExpectCorrectValues) { + // Arrange + reps->SaveUpdateRequired(true); + // Check + EXPECT_TRUE(reps->UpdateRequired()); + // Act + reps->SaveUpdateRequired(false); + // Check + EXPECT_FALSE(reps->UpdateRequired()); +} + +TEST_F(SQLPTRepresentationTest, + IsApplicationRepresented_Check_ExpectCorrectResult) { + // Arrange + const std::string query_insert_app_default = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'default', 0, 0, 'NONE', 'NONE', 0, " + "0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_default)); + + const std::string query_insert_app_device = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'device', 0, 0, 'NONE', " + "'COMMUNICATION', 0, 0, 0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_device)); + + const std::string query_insert_app_12345 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '12345', 0, 0, 'NONE', 'EMERGENCY', " + "0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_12345)); + // Checks + EXPECT_TRUE(reps->IsApplicationRepresented("default")); + EXPECT_TRUE(reps->IsApplicationRepresented("device")); + EXPECT_TRUE(reps->IsApplicationRepresented("12345")); + EXPECT_FALSE(reps->IsApplicationRepresented("1234")); +} + +TEST_F(SQLPTRepresentationTest, + IsApplicationRevoked_CheckApps_ExpectCorrectResult) { + // Arrange + const std::string query_insert_app_7777 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '7777', 0, 0, 'NONE', 'NONE', 1, " + "0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_7777)); + + const std::string query_insert_app_12345 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '12345', 0, 0, 'NONE', 'EMERGENCY', " + "0, 0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_12345)); + // Checks + EXPECT_TRUE(reps->IsApplicationRevoked("7777")); + EXPECT_FALSE(reps->IsApplicationRevoked("12345")); +} + +TEST_F(SQLPTRepresentationTest, + CopyApplication_CopyApplication_ExpectAppCopiedSuccesfully) { + // Arrange + const std::string query_insert_app_default = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'default', 0, 0, 'NONE', 'NONE', 0, " + "1, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_default)); + + const std::string query_insert_app_123 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '123', 1, 0, 'FULL', " + "'COMMUNICATION', 1, 1, 0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_123)); + EXPECT_FALSE(reps->IsApplicationRepresented("7777")); + EXPECT_FALSE(reps->IsApplicationRepresented("9999")); + // Act + EXPECT_TRUE(reps->CopyApplication("default", "7777")); + EXPECT_TRUE(reps->CopyApplication("123", "9999")); + // Checks + EXPECT_TRUE(reps->IsApplicationRepresented("7777")); + EXPECT_TRUE(reps->IsApplicationRepresented("9999")); + EXPECT_FALSE(reps->IsApplicationRevoked("7777")); + EXPECT_TRUE(reps->IsApplicationRevoked("9999")); + EXPECT_TRUE(reps->IsDefaultPolicy("7777")); + std::string priority1; + std::string priority2; + EXPECT_TRUE(reps->GetPriority("default", &priority1)); + EXPECT_TRUE(reps->GetPriority("7777", &priority2)); + EXPECT_EQ(priority1, priority2); + EXPECT_TRUE(reps->GetPriority("123", &priority1)); + EXPECT_TRUE(reps->GetPriority("9999", &priority2)); + EXPECT_EQ(priority1, priority2); +} + +TEST_F(SQLPTRepresentationTest, + IsDefaultPolicy_SetAppPreDataThenCheck_ExpectNotDefaultPolicySet) { + // Arrange + const std::string query_insert_app = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( '12345', 0, 0, 'NONE', 'NONE', 0, " + "0, " + "1, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app)); + // Check + EXPECT_FALSE(reps->IsDefaultPolicy("12345")); +} + +TEST_F(SQLPTRepresentationTest, + IsDefaultPolicy_SetAppDefaultThenCheck_ExpectNotDefaultPolicySet) { + // Arrange + const std::string query_insert_app = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, `default_hmi`, `priority_value`, `is_revoked`, " + "`is_default`, `is_predata`, `memory_kb`, `heart_beat_timeout_ms`) " + "VALUES( '1234567', 0, 0, 'NONE', 'NONE', 0, 1, 0, 64, 10) "; + + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app)); + // Check + EXPECT_TRUE(reps->IsDefaultPolicy("1234567")); +} + +TEST_F(SQLPTRepresentationTest, Drop_DropExistedPT_ExpectZeroTables) { + // Check + utils::dbms::SQLQuery query(reps->db()); + const std::string query_select = + "SELECT COUNT(*) FROM `sqlite_master` WHERE `type` = 'table'"; + // In normally created PT there are more than 0 tables + + ASSERT_TRUE(query_wrapper_->Exec(query_select)); + query.Prepare(query_select); + query.Next(); + ASSERT_GT(query.GetInteger(0), 0); + query.Finalize(); + + // Destroy schema + ASSERT_TRUE(reps->Drop()); + + // Check PT structure destroyed and tables number is 0 + query.Prepare(query_select); + query.Next(); + ASSERT_EQ(0, query.GetInteger(0)); + query.Finalize(); + + // Restore schema + ASSERT_TRUE(reps->RefreshDB()); +} + +TEST_F(SQLPTRepresentationTest, + SetDefaultPolicy_SetDefaultPolicyThenCheck_ExpectDefaultPolicySet) { + // Arrange + const std::string query_insert_app_default = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, " + " `default_hmi`, `priority_value`, `is_revoked`, `is_default`, " + "`is_predata`, `memory_kb`, " + " `heart_beat_timeout_ms`) VALUES( 'default', 0, 0, 'NONE', 'NONE', 0, " + "0, " + "0, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_default)); + + const std::string query_insert_app_1234567 = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, `default_hmi`, `priority_value`, `is_revoked`, " + "`is_default`, `is_predata`, `memory_kb`, `heart_beat_timeout_ms`) " + "VALUES( '1234567', 0, 0, 'NONE', 'NONE', 0, 0, 1, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app_1234567)); + EXPECT_FALSE(reps->IsDefaultPolicy("1234567")); + // Act + ASSERT_TRUE(reps->SetDefaultPolicy("1234567")); + // Check + EXPECT_TRUE(reps->IsDefaultPolicy("1234567")); +} + +TEST_F(SQLPTRepresentationTest, + SetPreloaded_SetPreloaded_ExpectPTSetToPreloaded) { + // Arrange + const std::string query_insert = + "UPDATE `module_config` SET `preloaded_pt` = 0"; + ASSERT_TRUE(query_wrapper_->Exec(query_insert)); + // Check + ASSERT_FALSE(reps->IsPTPreloaded()); + // Act + reps->SetPreloaded(true); + // Check + ASSERT_TRUE(reps->IsPTPreloaded()); + // Act + reps->SetPreloaded(false); + // Check + ASSERT_FALSE(reps->IsPTPreloaded()); +} + +TEST_F(SQLPTRepresentationTest, + SetIsDefault_SetIsDefault_ExpectDefaultFlagSet) { + // Arrange + utils::dbms::SQLQuery query(reps->db()); + const std::string query_insert_app = + "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, " + "`steal_focus`, `default_hmi`, `priority_value`, `is_revoked`, " + "`is_default`, `is_predata`, `memory_kb`, `heart_beat_timeout_ms`) " + "VALUES( '1234567', 0, 0, 'NONE', 'NONE', 0, 0, 1, 64, 10) "; + ASSERT_TRUE(query_wrapper_->Exec(query_insert_app)); + const std::string query_select = + "SELECT `is_default` FROM `application`WHERE`id`= '1234567' "; + + query.Prepare(query_select); + query.Next(); + EXPECT_EQ(0, query.GetInteger(0)); + query.Finalize(); + // Act + EXPECT_TRUE(reps->SetIsDefault("1234567", true)); + + // Check + query.Prepare(query_select); + query.Next(); + EXPECT_EQ(1, query.GetInteger(0)); + query.Finalize(); + // Act + EXPECT_TRUE(reps->SetIsDefault("1234567", false)); + + // Check + query.Prepare(query_select); + query.Next(); + EXPECT_EQ(0, query.GetInteger(0)); +} + +TEST(SQLPTRepresentationTest3, RemoveDB_RemoveDB_ExpectFileDeleted) { + // Arrange + const bool in_memory_ = true; + policy_handler_test::MockPolicySettings policy_settings_; + SQLPTRepresentation reps(in_memory_); + EXPECT_EQ(::policy::SUCCESS, reps.Init(&policy_settings_)); + EXPECT_EQ(::policy::EXISTS, reps.Init(&policy_settings_)); + std::string path = (reps.db())->get_path(); + // Act + reps.RemoveDB(); + // Check + EXPECT_FALSE(file_system::FileExists(path)); +} + +TEST_F(SQLPTRepresentationTest, + DISABLED_GenerateSnapshot_SetPolicyTable_SnapshotIsPresent) { + // TODO(AKutsan):APPLINK-31526 Test requires initial preloaded pt for preloaded date reading + // Arrange + Json::Value table(Json::objectValue); + PolicyTableUpdatePrepare(table); + + policy_table::Table update(&table); + update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE); + + // Assert + ASSERT_TRUE(IsValid(update)); + ASSERT_TRUE(reps->Save(update)); + + // Act + utils::SharedPtr<policy_table::Table> snapshot = reps->GenerateSnapshot(); + snapshot->SetPolicyTableType(rpc::policy_table_interface_base::PT_SNAPSHOT); + // Remove fields which must be absent in snapshot + table["policy_table"]["consumer_friendly_messages"].removeMember("messages"); + table["policy_table"]["app_policies"]["1234"].removeMember("default_hmi"); + table["policy_table"]["app_policies"]["1234"].removeMember("keep_context"); + table["policy_table"]["app_policies"]["1234"].removeMember("steal_focus"); + table["policy_table"]["app_policies"]["default"].removeMember("default_hmi"); + table["policy_table"]["app_policies"]["default"].removeMember("keep_context"); + table["policy_table"]["app_policies"]["default"].removeMember("steal_focus"); + table["policy_table"]["app_policies"]["pre_DataConsent"].removeMember( + "default_hmi"); + table["policy_table"]["app_policies"]["pre_DataConsent"].removeMember( + "keep_context"); + table["policy_table"]["app_policies"]["pre_DataConsent"].removeMember( + "steal_focus"); + table["policy_table"]["app_policies"]["device"].removeMember("default_hmi"); + table["policy_table"]["app_policies"]["device"].removeMember("keep_context"); + table["policy_table"]["app_policies"]["device"].removeMember("steal_focus"); + table["policy_table"]["app_policies"]["device"].removeMember("groups"); + table["policy_table"]["device_data"] = Json::Value(Json::objectValue); + table["policy_table"]["module_meta"] = Json::Value(Json::objectValue); + table["policy_table"]["module_config"]["preloaded_pt"] = Json::Value(false); + policy_table::Table expected(&table); + Json::StyledWriter writer; + // Checks + EXPECT_EQ(writer.write(expected.ToJsonValue()), + writer.write(snapshot->ToJsonValue())); + std::cout << writer.write(snapshot->ToJsonValue()) << std::endl; + EXPECT_EQ(expected.ToJsonValue().toStyledString(), + snapshot->ToJsonValue().toStyledString()); +} + +TEST_F(SQLPTRepresentationTest, DISABLED_Save_SetPolicyTableThenSave_ExpectSavedToPT) { + // TODO(AKutsan): APPLINK-31526 Test requires initial preloaded pt for preloaded date reading + // Arrange + Json::Value table(Json::objectValue); + PolicyTableUpdatePrepare(table); + + policy_table::Table update(&table); + update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE); + // Checks PT before Save + policy_table::FunctionalGroupings func_groups; + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Check functional groupings section + EXPECT_EQ(0u, func_groups.size()); + + policy_table::ApplicationPoliciesSection policies; + GatherApplicationPoliciesSection(&policies); + // Check ApplicationPoliciesSection + EXPECT_EQ(0u, policies.apps.size()); + EXPECT_EQ(0u, (policies.device.preconsented_groups)->size()); + EXPECT_EQ(0u, policies.device.groups.size()); + EXPECT_EQ(policy_table::Priority::P_EMERGENCY, policies.device.priority); + EXPECT_EQ(policy_table::HmiLevel::HL_BACKGROUND, policies.device.default_hmi); + EXPECT_FALSE(policies.device.keep_context); + EXPECT_FALSE(policies.device.steal_focus); + + policy_table::ModuleConfig config; + GatherModuleConfig(&config); + // Check Module config section + EXPECT_TRUE(*config.preloaded_pt); + EXPECT_EQ(0, config.exchange_after_x_ignition_cycles); + EXPECT_EQ(0, config.exchange_after_x_kilometers); + EXPECT_EQ(0, config.exchange_after_x_days); + EXPECT_EQ(0, config.timeout_after_x_seconds); + EXPECT_EQ("", static_cast<std::string>(*config.vehicle_make)); + EXPECT_EQ("", static_cast<std::string>(*config.vehicle_model)); + EXPECT_EQ("", static_cast<std::string>(*config.vehicle_year)); + EXPECT_EQ("", static_cast<std::string>(*config.preloaded_date)); + EXPECT_EQ("", static_cast<std::string>(*config.certificate)); + EXPECT_EQ(0u, config.seconds_between_retries.size()); + EXPECT_EQ(0u, config.endpoints.size()); + EXPECT_EQ(0u, config.notifications_per_minute_by_priority.size()); + + policy_table::ConsumerFriendlyMessages messages; + GatherConsumerFriendlyMessages(&messages); + EXPECT_EQ("0", static_cast<std::string>(messages.version)); + policy_table::DeviceData devices; + GatherDeviceData(&devices); + EXPECT_EQ(0u, devices.size()); + policy_table::UsageAndErrorCounts counts; + GatherUsageAndErrorCounts(&counts); + EXPECT_EQ(0u, counts.app_level->size()); + ASSERT_TRUE(IsValid(update)); + // Act + ASSERT_TRUE(reps->Save(update)); + + // Check Functional Groupings + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Checks + EXPECT_EQ(1u, func_groups.size()); + policy_table::FunctionalGroupings::iterator func_groups_iter = + func_groups.find("default"); + ASSERT_TRUE(func_groups.end() != func_groups_iter); + policy_table::Rpcs& rpcs = func_groups_iter->second; + EXPECT_EQ("", static_cast<std::string>(*rpcs.user_consent_prompt)); + policy_table::Rpc& rpc = rpcs.rpcs; + EXPECT_EQ(1u, rpc.size()); + policy_table::Rpc::const_iterator rpc_iter = rpc.find("Update"); + EXPECT_TRUE(rpc.end() != rpc_iter); + const policy_table::HmiLevels& hmi_levels = rpc_iter->second.hmi_levels; + EXPECT_EQ(1u, hmi_levels.size()); + EXPECT_TRUE(hmi_levels.end() != std::find(hmi_levels.begin(), + hmi_levels.end(), + policy_table::HmiLevel::HL_FULL)); + + const ::policy_table::Parameters& parameters = *(rpc_iter->second.parameters); + EXPECT_EQ(1u, parameters.size()); + EXPECT_TRUE(parameters.end() != std::find(parameters.begin(), + parameters.end(), + policy_table::Parameter::P_SPEED)); + // Check Application Policies Section + GatherApplicationPoliciesSection(&policies); + const uint32_t apps_size = 3u; + + rpc::String<1ul, 255ul> str("default"); + policy_table::Strings groups; + groups.push_back(str); + CheckAppPoliciesSection(policies, + apps_size, + policy_table::Priority::P_EMERGENCY, + "1234", + 150u, + 200u, + groups); + CheckAppPoliciesSection(policies, + apps_size, + policy_table::Priority::P_EMERGENCY, + "default", + 50u, + 100u, + groups); + CheckAppPoliciesSection(policies, + apps_size, + policy_table::Priority::P_EMERGENCY, + "pre_DataConsent", + 40u, + 90u, + groups); + CheckAppPoliciesSection(policies, + apps_size, + policy_table::Priority::P_EMERGENCY, + "device", + 0u, + 0u, + groups); + EXPECT_EQ(0u, (policies.device.preconsented_groups)->size()); + EXPECT_EQ(0u, policies.device.groups.size()); + EXPECT_EQ(policy_table::HmiLevel::HL_BACKGROUND, policies.device.default_hmi); + EXPECT_FALSE(policies.device.keep_context); + EXPECT_FALSE(policies.device.steal_focus); + + CheckAppGroups("1234", groups); + CheckAppGroups("default", groups); + CheckAppGroups("pre_DataConsent", groups); + CheckAppGroups("device", groups); + + GatherModuleConfig(&config); + // Check Module Config section + ASSERT_FALSE(*config.preloaded_pt); + ASSERT_EQ("my_cert", static_cast<std::string>(*config.certificate)); + ASSERT_EQ("25-04-2015", static_cast<std::string>(*config.preloaded_date)); + ASSERT_EQ("2014", static_cast<std::string>(*config.vehicle_year)); + ASSERT_EQ("ModelT", static_cast<std::string>(*config.vehicle_model)); + ASSERT_EQ("MakeT", static_cast<std::string>(*config.vehicle_make)); + ASSERT_EQ(10, config.exchange_after_x_ignition_cycles); + ASSERT_EQ(100, config.exchange_after_x_kilometers); + ASSERT_EQ(5, config.exchange_after_x_days); + ASSERT_EQ(500, config.timeout_after_x_seconds); + ASSERT_EQ(3u, config.seconds_between_retries.size()); + ASSERT_EQ(10, config.seconds_between_retries[0]); + ASSERT_EQ(20, config.seconds_between_retries[1]); + ASSERT_EQ(30, config.seconds_between_retries[2]); + ASSERT_EQ(6u, config.notifications_per_minute_by_priority.size()); + ASSERT_EQ(1, config.notifications_per_minute_by_priority["emergency"]); + ASSERT_EQ(2, config.notifications_per_minute_by_priority["navigation"]); + ASSERT_EQ(3, config.notifications_per_minute_by_priority["VOICECOMM"]); + ASSERT_EQ(4, config.notifications_per_minute_by_priority["communication"]); + ASSERT_EQ(5, config.notifications_per_minute_by_priority["normal"]); + ASSERT_EQ(6, config.notifications_per_minute_by_priority["none"]); + EXPECT_EQ(1u, config.endpoints.size()); + policy_table::ServiceEndpoints& service_endpoints = config.endpoints; + EXPECT_EQ("0x00", service_endpoints.begin()->first); + policy_table::URLList& url_list = service_endpoints.begin()->second; + EXPECT_EQ("default", url_list.begin()->first); + policy_table::URL& url = url_list.begin()->second; + EXPECT_EQ("http://ford.com/cloud/default", static_cast<std::string>(url[0])); + GatherConsumerFriendlyMessages(&messages); + EXPECT_EQ("1.2", static_cast<std::string>(messages.version)); +} + +TEST_F(SQLPTRepresentationTest, + Save_SavePolicyTable_EmptyParameters_ParametersEMPTY) { + // Arrange + Json::Value table(Json::objectValue); + PolicyTableUpdatePrepareEmptyParameters(table); + + policy_table::Table update(&table); + update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE); + // Checks PT before Save + policy_table::FunctionalGroupings func_groups; + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Check functional groupings section + EXPECT_EQ(0u, func_groups.size()); + + // Act + ASSERT_TRUE(reps->Save(update)); + + // Check Functional Groupings + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Checks + EXPECT_EQ(1u, func_groups.size()); + policy_table::FunctionalGroupings::iterator func_groups_iter = + func_groups.find("default"); + ASSERT_TRUE(func_groups.end() != func_groups_iter); + policy_table::Rpcs& rpcs = func_groups_iter->second; + EXPECT_EQ("", static_cast<std::string>(*rpcs.user_consent_prompt)); + policy_table::Rpc& rpc = rpcs.rpcs; + EXPECT_EQ(1u, rpc.size()); + policy_table::Rpc::const_iterator rpc_iter = rpc.find("Update"); + EXPECT_TRUE(rpc.end() != rpc_iter); + // Check parameters + const ::policy_table::Parameters& parameters = *(rpc_iter->second.parameters); + // 'parameters' : [] - represented as initialized, but empty + // missing 'parameters' - represented as non-initialized and empty + EXPECT_TRUE(parameters.is_initialized()); + EXPECT_TRUE(parameters.empty()); +} + +TEST_F(SQLPTRepresentationTest, + Save_SavePolicyTable_NoParameters_NoParametersSaved) { + // Arrange + Json::Value table(Json::objectValue); + PolicyTableUpdatePrepareNoParameters(table); + + policy_table::Table update(&table); + update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE); + // Checks PT before Save + policy_table::FunctionalGroupings func_groups; + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Check functional groupings section + EXPECT_EQ(0u, func_groups.size()); + + // Act + ASSERT_TRUE(reps->Save(update)); + + // Check Functional Groupings + ASSERT_TRUE(reps->GetFunctionalGroupings(func_groups)); + // Checks + EXPECT_EQ(1u, func_groups.size()); + policy_table::FunctionalGroupings::iterator func_groups_iter = + func_groups.find("default"); + ASSERT_TRUE(func_groups.end() != func_groups_iter); + policy_table::Rpcs& rpcs = func_groups_iter->second; + EXPECT_EQ("", static_cast<std::string>(*rpcs.user_consent_prompt)); + policy_table::Rpc& rpc = rpcs.rpcs; + EXPECT_EQ(1u, rpc.size()); + policy_table::Rpc::const_iterator rpc_iter = rpc.find("Update"); + EXPECT_TRUE(rpc.end() != rpc_iter); + // Check parameters + const ::policy_table::Parameters& parameters = *(rpc_iter->second.parameters); + EXPECT_EQ(0u, parameters.size()); +} + +} // namespace policy_test +} // namespace components +} // namespace test |