Merge pull request #618 from Kozoriz/feature/Cover_resumption_with_unit_tests

Cover resumption with unit tests

40 files changed, 1126 insertions, 454 deletions

diff --git a/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h b/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
index 6c10b2e013..ab2a5725c4 100644
--- a/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
+++ b/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
@@ -75,6 +75,12 @@ class ResumptionDataDB : public ResumptionData {
       DbStorage db_storage,
       const application_manager::ApplicationManager& application_manager);
 
+#ifdef BUILD_TESTS
+  ResumptionDataDB(utils::dbms::SQLDatabase* db,
+                   const application_manager::ApplicationManager&
+                       application_manager_settings);
+#endif  // BUILD_TESTS
+
   /**
    * @brief allows to destroy ResumptionDataDB object
    */
@@ -85,7 +91,7 @@ class ResumptionDataDB : public ResumptionData {
    * @return false if DB doesn't initialize
    * otherwise returns true
    */
-  virtual bool Init();
+  bool Init() OVERRIDE;
 
   /**
    * @brief Save application persistent info for future resuming to db
@@ -97,7 +103,7 @@ class ResumptionDataDB : public ResumptionData {
    * @param hmi_app_id - hmi application id
    * @return true if exist, otherwise false
    */
-  virtual bool IsHMIApplicationIdExist(uint32_t hmi_app_id) const;
+  bool IsHMIApplicationIdExist(uint32_t hmi_app_id) const OVERRIDE;
   /**
    * @brief Retrieves HMI app ID for the given mobile app ID
    * and device ID from stored data.
@@ -105,14 +111,14 @@ class ResumptionDataDB : public ResumptionData {
    * @param device_id - contains id of device on which is running application
    * @return HMI app ID
    */
-  virtual uint32_t GetHMIApplicationID(const std::string& policy_app_id,
-                                       const std::string& device_id) const;
+  uint32_t GetHMIApplicationID(const std::string& policy_app_id,
+                               const std::string& device_id) const OVERRIDE;
 
   /**
    * @brief Increments ignition counter for all registered applications
    * and remember ign_off time stamp
    */
-  virtual void OnSuspend();
+  void OnSuspend() OVERRIDE;
 
   /**
    * @brief Retrieves hash ID for the given mobile app ID
@@ -124,15 +130,15 @@ class ResumptionDataDB : public ResumptionData {
    * @return TRUE if application will be found in saved data otherwise
    * returns FALSE
    */
-  virtual bool GetHashId(const std::string& policy_app_id,
-                         const std::string& device_id,
-                         std::string& hash_id) const;
+  bool GetHashId(const std::string& policy_app_id,
+                 const std::string& device_id,
+                 std::string& hash_id) const OVERRIDE;
 
   /**
    * @brief Decrements ignition counter for all registered applications
    * and remember ign_off time stamp
    */
-  virtual void OnAwake();
+  void OnAwake() OVERRIDE;
 
   /**
    * @brief Retrieves data of saved application for the given mobile app ID
@@ -143,9 +149,10 @@ class ResumptionDataDB : public ResumptionData {
    * @return TRUE if application will be found in saved data otherwise
    * returns FALSE
    */
-  virtual bool GetSavedApplication(const std::string& policy_app_id,
-                                   const std::string& device_id,
-                                   smart_objects::SmartObject& saved_app) const;
+  bool GetSavedApplication(
+      const std::string& policy_app_id,
+      const std::string& device_id,
+      smart_objects::SmartObject& saved_app) const OVERRIDE;
 
   /**
    * @brief Remove application from list of saved applications
@@ -153,14 +160,14 @@ class ResumptionDataDB : public ResumptionData {
    * @param device_id - contains id of device on which is running application
    * @return return true, if success, otherwise return false
    */
-  virtual bool RemoveApplicationFromSaved(const std::string& policy_app_id,
-                                          const std::string& device_id);
+  bool RemoveApplicationFromSaved(const std::string& policy_app_id,
+                                  const std::string& device_id) OVERRIDE;
 
   /**
    * @brief Get the last ignition off time from LastState
    * @return the last ignition off time from LastState
    */
-  virtual uint32_t GetIgnOffTime() const;
+  uint32_t GetIgnOffTime() const OVERRIDE;
 
   /**
    * @brief Checks if saved data have application
@@ -168,15 +175,15 @@ class ResumptionDataDB : public ResumptionData {
    * @param device_id - contains id of device on which is running application
    * @return 0 if saved data contains application otherwise returns -1
    */
-  virtual ssize_t IsApplicationSaved(const std::string& policy_app_id,
-                                     const std::string& device_id) const;
+  ssize_t IsApplicationSaved(const std::string& policy_app_id,
+                             const std::string& device_id) const OVERRIDE;
 
   /**
    * @brief Retrieves data from saved application
    * @param  will contain data for resume_ctrl
    */
-  virtual void GetDataForLoadResumeData(
-      smart_objects::SmartObject& saved_data) const;
+  void GetDataForLoadResumeData(
+      smart_objects::SmartObject& saved_data) const OVERRIDE;
 
   /**
    * @brief Updates HMI level of saved application
@@ -184,9 +191,9 @@ class ResumptionDataDB : public ResumptionData {
    * @param device_id - contains id of device on which is running application
    * @param hmi_level - contains hmi level for saved application
    */
-  virtual void UpdateHmiLevel(const std::string& policy_app_id,
-                              const std::string& device_id,
-                              mobile_apis::HMILevel::eType hmi_level);
+  void UpdateHmiLevel(const std::string& policy_app_id,
+                      const std::string& device_id,
+                      mobile_apis::HMILevel::eType hmi_level) OVERRIDE;
 
   /**
    * @brief Re-creates and re-init DB
@@ -241,17 +248,6 @@ class ResumptionDataDB : public ResumptionData {
   const int32_t GetDBVersion() const;
 
   /**
-   * @brief Retrieves hmi level from db
-   * @param policy_app_id - mobile application id
-   * @param device_id - contains id of device on which is running application
-   * @param hmi_level - will contains hmi level for saved application
-   * @return true if application with mobile id and device id has hmi level
-   * otherwise returns false
-   */
-  bool SelectHMILevel(const std::string& policy_app_id,
-                      const std::string& device_id,
-                      int& hmi_level) const;
-  /**
    * @brief Checks existence HMI id in DB
    * @param hmi_app_id - HMI id
    * return true if hmiID is same with saved hmiID otherwise returns false
diff --git a/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h b/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
index b521fe4fc8..a9e8ad7d08 100644
--- a/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
+++ b/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Ford Motor Company
+ * Copyright (c) 2016, Ford Motor Company
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -219,13 +219,6 @@ class ResumptionDataJson : public ResumptionData {
    */
   void SetLastIgnOffTime(time_t ign_off_time);
 
-  /*
-   * @brief Return true if application resumption data is valid,
-   * otherwise false
-   * @param index application index in the resumption list
-   */
-  bool IsResumptionDataValid(uint32_t index) const;
-
   LastState& last_state_;
   DISALLOW_COPY_AND_ASSIGN(ResumptionDataJson);
 };
diff --git a/src/components/application_manager/src/resumption/resumption_data.cc b/src/components/application_manager/src/resumption/resumption_data.cc
index 8e6282fc50..d148f856a6 100644
--- a/src/components/application_manager/src/resumption/resumption_data.cc
+++ b/src/components/application_manager/src/resumption/resumption_data.cc
@@ -191,7 +191,7 @@ smart_objects::SmartObject ResumptionData::GetApplicationFiles(
   int i = 0;
   for (AppFilesMap::const_iterator file_it = app_files.begin();
        file_it != app_files.end();
-       file_it++) {
+       ++file_it) {
     const AppFile& file = file_it->second;
     if (file.is_persistent) {
       smart_objects::SmartObject file_data =
diff --git a/src/components/application_manager/src/resumption/resumption_data_db.cc b/src/components/application_manager/src/resumption/resumption_data_db.cc
index 8c9fe7d57f..92e886f5e5 100644
--- a/src/components/application_manager/src/resumption/resumption_data_db.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_db.cc
@@ -61,21 +61,26 @@ ResumptionDataDB::ResumptionDataDB(
     : ResumptionData(application_manager) {
   if (db_storage == In_File_Storage) {
 #ifndef __QNX__
-    db_ = new utils::dbms::SQLDatabase(
-        file_system::ConcatPath(
-            application_manager_.get_settings().app_storage_folder(),
-            kDatabaseName),
-        "ResumptionDatabase");
+    db_ = new utils::dbms::SQLDatabaseImpl(file_system::ConcatPath(
+        application_manager_.get_settings().app_storage_folder(),
+        kDatabaseName));
 #else
-    db_ = new utils::dbms::SQLDatabase(kDatabaseName);
+    db_ = new utils::dbms::SQLDatabaseImpl(kDatabaseName);
 #endif
   } else if (db_storage == In_Memory_Storage) {
-    db_ = new utils::dbms::SQLDatabase();
+    db_ = new utils::dbms::SQLDatabaseImpl();
   } else {
     SDL_ERROR("Get not existed type of database storage");
   }
 }
 
+#ifdef BUILD_TESTS
+ResumptionDataDB::ResumptionDataDB(
+    utils::dbms::SQLDatabase* db,
+    const application_manager::ApplicationManager& application_manager)
+    : ResumptionData(application_manager), db_(db) {}
+#endif  // BUILD_TESTS
+
 ResumptionDataDB::~ResumptionDataDB() {
   db_->Close();
   delete db_;
@@ -361,15 +366,13 @@ bool ResumptionDataDB::GetSavedApplication(
 bool ResumptionDataDB::RemoveApplicationFromSaved(
     const std::string& policy_app_id, const std::string& device_id) {
   SDL_AUTO_TRACE();
+  bool result = false;
   bool application_exist = false;
   if (!CheckExistenceApplication(policy_app_id, device_id, application_exist) ||
       !application_exist) {
-    SDL_ERROR(
-        "Problem with access to DB or application does not"
-        " exist");
-    return false;
+    SDL_ERROR("Problem with access to DB or application does not exist");
+    return result;
   }
-  bool result = false;
   if (DeleteSavedApplication(policy_app_id, device_id)) {
     WriteDb();
     result = true;
@@ -401,32 +404,6 @@ void ResumptionDataDB::GetDataForLoadResumeData(
   SelectDataForLoadResumeData(saved_data);
 }
 
-bool ResumptionDataDB::SelectHMILevel(const std::string& policy_app_id,
-                                      const std::string& device_id,
-                                      int& hmi_level) const {
-  SDL_AUTO_TRACE();
-  utils::dbms::SQLQuery query_count(db());
-  utils::dbms::SQLQuery query_select(db());
-  if (query_count.Prepare(kSelectCountHMILevel) &&
-      query_select.Prepare(kSelectHMILevel)) {
-    /* Positions of binding data for "query_count" and "query_select" :
-       field "deviceID" from table "application" = 0
-       field "appID" from table "application" = 1 */
-    query_count.Bind(0, device_id);
-    query_count.Bind(1, policy_app_id);
-    query_select.Bind(0, device_id);
-    query_select.Bind(1, policy_app_id);
-    /* Position of data in "query_select" :
-       field "hmiLevel" from table "application" = 0 */
-    if (query_count.Exec() && query_count.GetInteger(0) &&
-        query_select.Exec()) {
-      hmi_level = query_select.GetInteger(0);
-      return true;
-    }
-  }
-  return false;
-}
-
 bool ResumptionDataDB::CheckExistenceHMIId(uint32_t hmi_app_id) const {
   SDL_AUTO_TRACE();
 
@@ -2721,13 +2698,14 @@ bool ResumptionDataDB::UpdateGrammarID(const std::string& policy_app_id,
 }
 
 utils::dbms::SQLDatabase* ResumptionDataDB::db() const {
-#if defined(__QNX__)
-  utils::dbms::SQLDatabase* db = new utils::dbms::SQLDatabase(kDatabaseName);
+#ifdef __QNX__
+  utils::dbms::SQLDatabase* db =
+      new utils::dbms::SQLDatabaseImpl(kDatabaseName);
   db->Open();
   return db;
 #else
   return db_;
-#endif
+#endif  // __QNX__
 }
 
 ApplicationParams::ApplicationParams(
diff --git a/src/components/application_manager/src/resumption/resumption_data_json.cc b/src/components/application_manager/src/resumption/resumption_data_json.cc
index bb2faa412c..40262ff114 100644
--- a/src/components/application_manager/src/resumption/resumption_data_json.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_json.cc
@@ -442,31 +442,6 @@ ssize_t ResumptionDataJson::GetObjectIndex(const std::string& policy_app_id,
   return -1;
 }
 
-bool ResumptionDataJson::IsResumptionDataValid(uint32_t index) const {
-  using namespace app_mngr;
-  using namespace utils::json;
-  SDL_AUTO_TRACE();
-  sync_primitives::AutoLock autolock(resumption_lock_);
-  const JsonValueRef json_app = GetSavedApplications()[index];
-  if (!json_app.HasMember(strings::app_id) ||
-      !json_app.HasMember(strings::ign_off_count) ||
-      !json_app.HasMember(strings::hmi_level) ||
-      !json_app.HasMember(strings::hmi_app_id) ||
-      !json_app.HasMember(strings::time_stamp) ||
-      !json_app.HasMember(strings::device_id)) {
-    SDL_ERROR("Wrong resumption data");
-    return false;
-  }
-
-  if (json_app.HasMember(strings::hmi_app_id) &&
-      0 >= json_app[strings::hmi_app_id].AsUInt()) {
-    SDL_ERROR("Wrong resumption hmi app ID");
-    return false;
-  }
-
-  return true;
-}
-
 void ResumptionDataJson::SetSavedApplication(
     utils::json::JsonValueRef apps_json) {
   SDL_AUTO_TRACE();
@@ -508,9 +483,7 @@ bool ResumptionDataJson::DropAppDataResumption(const std::string& device_id,
   application[strings::application_global_properties].Clear();
   application[strings::application_subscribtions].Clear();
   application[strings::application_files].Clear();
-  // Seems there is no interface for json wrapper - needs to be created
-  // application.removeMember(strings::grammar_id);
-  application[strings::grammar_id].Clear();
+  application.RemoveMember(strings::grammar_id);
   SDL_DEBUG("Resumption data for application " << app_id << " with device_id "
                                                << device_id
                                                << " has been dropped.");
diff --git a/src/components/application_manager/test/CMakeLists.txt b/src/components/application_manager/test/CMakeLists.txt
index 921d68f28b..947d246be2 100644
--- a/src/components/application_manager/test/CMakeLists.txt
+++ b/src/components/application_manager/test/CMakeLists.txt
@@ -178,10 +178,10 @@
 
     # TODO [AKozoriz] : Fix not buildable tests
     set(ResumptionData_SOURCES
-    #    ${AM_TEST_DIR}/resumption/resumption_data_test.cc
-    #    ${AM_TEST_DIR}/resumption/resumption_data_db_test.cc
-    #    ${AM_TEST_DIR}/resumption/resumption_data_json_test.cc
-    #    ${AM_TEST_DIR}/resumption/resume_ctrl_test.cc
+        ${AM_TEST_DIR}/resumption/resumption_data_test.cc
+        ${AM_TEST_DIR}/resumption/resumption_data_db_test.cc
+        ${AM_TEST_DIR}/resumption/resumption_data_json_test.cc
+        ${AM_TEST_DIR}/resumption/resume_ctrl_test.cc
         ${AM_TEST_DIR}/mock_message_helper.cc
       )
 
diff --git a/src/components/application_manager/test/include/application_manager/resumption_data_test.h b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
index b648b8ab82..c823299623 100644
--- a/src/components/application_manager/test/include/application_manager/resumption_data_test.h
+++ b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
@@ -62,7 +62,8 @@ using namespace mobile_apis;
 class ResumptionDataTest : public ::testing::Test {
  protected:
   ResumptionDataTest()
-      : kCountOfCommands_(5u)
+      : is_subscribed_for_way_points_(false)
+      , kCountOfCommands_(5u)
       , kCountOfChoice_(2u)
       , kCountOfChoiceSets_(4u)
       , kCountOfSubmenues_(3u)
@@ -83,6 +84,7 @@ class ResumptionDataTest : public ::testing::Test {
   std::string policy_app_id_;
   size_t ign_off_count_;
   const size_t tts_chunks_count = 4;
+  bool is_subscribed_for_way_points_;
 
   size_t grammar_id_;
   std::string hash_;
diff --git a/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h
index e10f60afac..b21a2a2b85 100644
--- a/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h
+++ b/src/components/application_manager/test/include/application_manager/test_resumption_data_db.h
@@ -33,7 +33,7 @@
 #ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_TEST_RESUMPTION_DATA_DB_H_
 #define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_TEST_RESUMPTION_DATA_DB_H_
 
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sql_database.h"
 #include "application_manager/resumption/resumption_data_db.h"
 #include "application_manager/mock_application_manager_settings.h"
 #include "application_manager/mock_application_manager.h"
diff --git a/src/components/application_manager/test/resumption/resume_ctrl_test.cc b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
index 9857072674..1b80131f22 100644
--- a/src/components/application_manager/test/resumption/resume_ctrl_test.cc
+++ b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
@@ -69,28 +69,29 @@ class ResumeCtrlTest : public ::testing::Test {
  protected:
   ResumeCtrlTest()
       : kTestAppId_(10u)
-      , kTestPolicyAppId_("test_policy_app_id")
+      , kTestPolicyAppId_("kTestPolicyAppId_")
       , kMacAddress_("12345")
       , kDefaultTestLevel_(eType::HMI_NONE)
       , kCorId_(7u)
       , kTestDevId_(5u)
       , kTestGrammarId_(10)
       , kHash_("saved_hash")
-      , kAppResumingTimeout_(30000000u) {}
+      , kAppResumingTimeout_(30000000u)
+      , kTestTimeStamp_(1452074434) {}
 
   virtual void SetUp() OVERRIDE {
-    ON_CALL(app_mngr_, event_dispatcher())
+    ON_CALL(mock_app_mngr_, event_dispatcher())
         .WillByDefault(ReturnRef(mock_event_dispatcher_));
     mock_storage =
         ::utils::MakeShared<NiceMock<resumption_test::MockResumptionData>>(
-            app_mngr_);
+            mock_app_mngr_);
     app_mock = utils::MakeShared<NiceMock<MockApplication>>();
-    res_ctrl = utils::MakeShared<ResumeCtrl>(app_mngr_);
+    res_ctrl = utils::MakeShared<ResumeCtrl>(mock_app_mngr_);
     res_ctrl->set_resumption_storage(mock_storage);
 
-    ON_CALL(app_mngr_, state_controller())
+    ON_CALL(mock_app_mngr_, state_controller())
         .WillByDefault(ReturnRef(state_controller_));
-    ON_CALL(app_mngr_, get_settings())
+    ON_CALL(mock_app_mngr_, get_settings())
         .WillByDefault(ReturnRef(mock_application_manager_settings_));
 
     ON_CALL(mock_application_manager_settings_, use_db_for_resumption())
@@ -109,7 +110,7 @@ class ResumeCtrlTest : public ::testing::Test {
   NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
   application_manager_test::MockApplicationManagerSettings
       mock_application_manager_settings_;
-  application_manager_test::MockApplicationManager app_mngr_;
+  application_manager_test::MockApplicationManager mock_app_mngr_;
   MockStateController state_controller_;
   utils::SharedPtr<ResumeCtrl> res_ctrl;
   utils::SharedPtr<NiceMock<resumption_test::MockResumptionData>> mock_storage;
@@ -125,6 +126,8 @@ class ResumeCtrlTest : public ::testing::Test {
   const uint32_t kTestGrammarId_;
   const std::string kHash_;
   const uint32_t kAppResumingTimeout_;
+  const uint32_t kTestTimeStamp_;
+  sync_primitives::Lock app_set_lock_;
 };
 
 /**
@@ -138,7 +141,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGrammarId) {
 
   // Check RestoreApplicationData
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   EXPECT_CALL(*mock_storage,
               GetSavedApplication(kTestPolicyAppId_, kMacAddress_, _))
@@ -146,7 +149,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGrammarId) {
   EXPECT_CALL(*app_mock, UpdateHash());
   EXPECT_CALL(*app_mock, set_grammar_id(kTestGrammarId_));
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -162,7 +165,7 @@ TEST_F(ResumeCtrlTest, StartResumption_WithoutGrammarId) {
   saved_app[application_manager::strings::hash_id] = kHash_;
 
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   // Check RestoreApplicationData
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -170,7 +173,7 @@ TEST_F(ResumeCtrlTest, StartResumption_WithoutGrammarId) {
   EXPECT_CALL(*app_mock, UpdateHash());
   EXPECT_CALL(*app_mock, set_grammar_id(kTestGrammarId_)).Times(0);
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_FALSE(res);
 }
 
@@ -209,7 +212,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) {
       test_application_files;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
       .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
@@ -224,7 +227,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) {
                     static_cast<mobile_apis::FileType::eType>(file_types[i]))));
   }
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -246,7 +249,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubmenues) {
       test_application_submenues;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
       .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
@@ -258,14 +261,14 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubmenues) {
   }
   smart_objects::SmartObjectList requests;
 
-  EXPECT_CALL(app_mngr_, GetNextHMICorrelationID())
+  EXPECT_CALL(mock_app_mngr_, GetNextHMICorrelationID())
       .WillRepeatedly(Return(kCorId_));
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
               CreateAddSubMenuRequestToHMI(_, kCorId_))
       .WillRepeatedly(Return(requests));
 
   EXPECT_CALL(*app_mock, UpdateHash());
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -286,7 +289,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) {
   saved_app[application_manager::strings::application_commands] =
       test_application_commands;
 
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   // Check RestoreApplicationData
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -303,7 +306,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) {
               CreateAddCommandRequestToHMI(_, _))
       .WillRepeatedly(Return(requests));
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -337,7 +340,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) {
       application_choice_sets;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -354,7 +357,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) {
               CreateAddVRCommandRequestFromChoiceToHMI(_))
       .WillRepeatedly(Return(requests));
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -368,7 +371,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGlobalProperties) {
       test_global_properties;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -382,7 +385,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGlobalProperties) {
   EXPECT_CALL(*app_mock, load_global_properties(test_global_properties));
 
   EXPECT_CALL(*app_mock, UpdateHash());
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -406,7 +409,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) {
       test_subscriptions;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -424,7 +427,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) {
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
               SendAllOnButtonSubscriptionNotificationsForApp(_, _)).Times(2);
 
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
@@ -450,7 +453,7 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) {
       test_subscriptions;
 
   // Check RestoreApplicationData
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
@@ -469,25 +472,44 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) {
               GetIVISubscriptionRequests(_)).WillRepeatedly(Return(requests));
 
   EXPECT_CALL(*app_mock, UpdateHash());
-  bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
+  EXPECT_TRUE(res);
+}
+
+TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToWayPoints) {
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::hash_id] = kHash_;
+  saved_app[application_manager::strings::grammar_id] = kTestGrammarId_;
+  saved_app[application_manager::strings::subscribed_for_way_points] = true;
+  saved_app[application_manager::strings::time_stamp] = kTestTimeStamp_;
+
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
+      .Times(2)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+  EXPECT_CALL(*app_mock, set_grammar_id(kTestGrammarId_));
+  EXPECT_CALL(mock_app_mngr_, SubscribeAppForWayPoints(_));
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_)).WillOnce(Return(HMI_FULL));
+
+  const bool res = res_ctrl->StartResumption(app_mock, kHash_);
   EXPECT_TRUE(res);
 }
 
 TEST_F(ResumeCtrlTest, StartResumptionOnlyHMILevel) {
   smart_objects::SmartObject saved_app;
 
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillOnce(Return(kDefaultTestLevel_));
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(kTestPolicyAppId_, _, _))
       .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
-  bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
+  const bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
   EXPECT_TRUE(res);
 }
 
 TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInFull) {
   mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL;
-  uint32_t ign_off_count = 0;
+  const uint32_t ign_off_count = 0;
   smart_objects::SmartObject saved_app;
   saved_app[application_manager::strings::ign_off_count] = ign_off_count;
   saved_app[application_manager::strings::hmi_level] = restored_test_type;
@@ -501,20 +523,20 @@ TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInFull) {
   EXPECT_CALL(*mock_storage, RemoveApplicationFromSaved(_, _))
       .WillOnce(Return(true));
 
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345"))
       .WillRepeatedly(Return(policy::kDeviceAllowed));
   res_ctrl->StartAppHmiStateResumption(app_mock);
 }
 
 TEST_F(ResumeCtrlTest, StartAppHmiStateResumption_AppInBackground) {
-  uint32_t ign_off_count = 0;
+  const uint32_t ign_off_count = 0;
   smart_objects::SmartObject saved_app;
 
   mobile_apis::HMILevel::eType restored_test_type = eType::HMI_BACKGROUND;
   saved_app[application_manager::strings::ign_off_count] = ign_off_count;
   saved_app[application_manager::strings::hmi_level] = restored_test_type;
 
-  EXPECT_CALL(app_mngr_, state_controller()).Times(0);
+  EXPECT_CALL(mock_app_mngr_, state_controller()).Times(0);
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(kTestPolicyAppId_, _, _))
       .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
@@ -540,11 +562,11 @@ TEST_F(ResumeCtrlTest, RestoreAppHMIState_RestoreHMILevelFull) {
   EXPECT_CALL(*mock_storage, GetSavedApplication(_, _, _))
       .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
 
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345"))
       .WillOnce(Return(policy::kDeviceAllowed));
   EXPECT_CALL(*app_mock, set_is_resuming(true));
 
-  bool res = res_ctrl->RestoreAppHMIState(app_mock);
+  const bool res = res_ctrl->RestoreAppHMIState(app_mock);
   EXPECT_TRUE(res);
 }
 
@@ -553,12 +575,12 @@ TEST_F(ResumeCtrlTest, SetupDefaultHMILevel) {
 
   saved_app[application_manager::strings::hmi_level] = kDefaultTestLevel_;
 
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillRepeatedly(Return(kDefaultTestLevel_));
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0);
 
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillOnce(Return(kDefaultTestLevel_));
 
   EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_))
@@ -567,6 +589,33 @@ TEST_F(ResumeCtrlTest, SetupDefaultHMILevel) {
   res_ctrl->SetupDefaultHMILevel(app_mock);
 }
 
+TEST_F(ResumeCtrlTest, ApplicationResumptiOnTimer_AppInFull) {
+  EXPECT_CALL(mock_app_mngr_, application(_)).WillRepeatedly(Return(app_mock));
+
+  mobile_apis::HMILevel::eType restored_test_type = eType::HMI_FULL;
+  const uint32_t ign_off_count = 0;
+  smart_objects::SmartObject saved_app;
+  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::hmi_level] = restored_test_type;
+
+  MockStateController state_controller_;
+  EXPECT_CALL(mock_app_mngr_, state_controller())
+      .WillOnce(ReturnRef(state_controller_));
+  EXPECT_CALL(state_controller_, SetRegularState(_, restored_test_type))
+      .Times(AtLeast(1));
+  GetInfoFromApp();
+  EXPECT_CALL(*mock_storage, GetSavedApplication(kTestPolicyAppId_, _, _))
+      .Times(2)
+      .WillRepeatedly(DoAll(SetArgReferee<2>(saved_app), Return(true)));
+
+  EXPECT_CALL(*mock_storage, RemoveApplicationFromSaved(_, _))
+      .WillOnce(Return(true));
+
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345"))
+      .WillRepeatedly(Return(policy::kDeviceAllowed));
+  res_ctrl->StartAppHmiStateResumption(app_mock);
+}
+
 /**
  * @brief group of tests which check correct SetAppHMIState
 */
@@ -574,24 +623,25 @@ TEST_F(ResumeCtrlTest, SetupDefaultHMILevel) {
 TEST_F(ResumeCtrlTest, SetAppHMIState_HMINone_WithoutCheckPolicy) {
   GetInfoFromApp();
 
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0);
 
   EXPECT_CALL(*app_mock, set_is_resuming(true));
   EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_))
       .Times(AtLeast(1));
-  bool res = res_ctrl->SetAppHMIState(app_mock, kDefaultTestLevel_, false);
+  const bool res =
+      res_ctrl->SetAppHMIState(app_mock, kDefaultTestLevel_, false);
   EXPECT_TRUE(res);
 }
 
 TEST_F(ResumeCtrlTest, SetAppHMIState_HMILimited_WithoutCheckPolicy) {
   mobile_apis::HMILevel::eType test_type = eType::HMI_LIMITED;
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0);
 
   EXPECT_CALL(*app_mock, set_is_resuming(true));
   EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
       .Times(AtLeast(1));
-  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
+  const bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
   EXPECT_TRUE(res);
 }
 
@@ -599,14 +649,14 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithoutCheckPolicy) {
   mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
   GetInfoFromApp();
   // GetDefaultHmiLevel should not be called
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_)).Times(0);
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345")).Times(0);
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_)).Times(0);
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345")).Times(0);
 
   EXPECT_CALL(*app_mock, set_is_resuming(true));
   EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
       .Times(AtLeast(1));
 
-  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
+  const bool res = res_ctrl->SetAppHMIState(app_mock, test_type, false);
   EXPECT_TRUE(res);
 }
 
@@ -614,14 +664,14 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevAllowed) {
   mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
 
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345"))
       .WillOnce(Return(policy::kDeviceAllowed));
 
   EXPECT_CALL(*app_mock, set_is_resuming(true));
   EXPECT_CALL(state_controller_, SetRegularState(_, test_type))
       .Times(AtLeast(1));
 
-  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
+  const bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
   EXPECT_TRUE(res);
 }
 
@@ -629,18 +679,47 @@ TEST_F(ResumeCtrlTest, SetAppHMIState_HMIFull_WithPolicy_DevDisallowed) {
   mobile_apis::HMILevel::eType test_type = eType::HMI_FULL;
 
   GetInfoFromApp();
-  EXPECT_CALL(app_mngr_, GetUserConsentForDevice("12345"))
+  EXPECT_CALL(mock_app_mngr_, GetUserConsentForDevice("12345"))
       .WillOnce(Return(policy::kDeviceDisallowed));
 
   EXPECT_CALL(*app_mock, set_is_resuming(true));
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillOnce(Return(kDefaultTestLevel_));
   EXPECT_CALL(state_controller_, SetRegularState(_, kDefaultTestLevel_))
       .Times(AtLeast(1));
-  bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
+  const bool res = res_ctrl->SetAppHMIState(app_mock, test_type, true);
   EXPECT_FALSE(res);
 }
 
+TEST_F(ResumeCtrlTest, SaveAllApplications) {
+  utils::SharedPtr<application_manager::Application> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  application_manager::ApplicationSet app_set;
+  app_set.insert(app_sh_mock);
+
+  DataAccessor<application_manager::ApplicationSet> accessor(app_set,
+                                                             app_set_lock_);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(accessor));
+  EXPECT_CALL(*mock_storage, SaveApplication(app_sh_mock)).Times(1);
+  res_ctrl->SaveAllApplications();
+}
+
+TEST_F(ResumeCtrlTest, SaveAllApplications_EmptyApplicationlist) {
+  utils::SharedPtr<application_manager::Application> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  application_manager::ApplicationSet app_set;
+
+  DataAccessor<application_manager::ApplicationSet> accessor(app_set,
+                                                             app_set_lock_);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(accessor));
+  EXPECT_CALL(*mock_storage, SaveApplication(app_sh_mock)).Times(0);
+  res_ctrl->SaveAllApplications();
+}
+
 TEST_F(ResumeCtrlTest, SaveApplication) {
   utils::SharedPtr<application_manager::Application> app_sh_mock =
       ::utils::MakeShared<application_manager_test::MockApplication>();
@@ -653,13 +732,13 @@ TEST_F(ResumeCtrlTest, OnAppActivated_ResumptionHasStarted) {
   smart_objects::SmartObject saved_app;
   GetInfoFromApp();
 
-  EXPECT_CALL(app_mngr_, GetDefaultHmiLevel(_))
+  EXPECT_CALL(mock_app_mngr_, GetDefaultHmiLevel(_))
       .WillOnce(Return(kDefaultTestLevel_));
   EXPECT_CALL(*mock_storage, GetSavedApplication(kTestPolicyAppId_, _, _))
       .WillOnce(DoAll(SetArgReferee<2>(saved_app), Return(true)));
   ON_CALL(*app_mock, app_id()).WillByDefault(Return(kTestAppId_));
 
-  bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
+  const bool res = res_ctrl->StartResumptionOnlyHMILevel(app_mock);
   EXPECT_TRUE(res);
 
   utils::SharedPtr<application_manager_test::MockApplication> app_sh_mock =
@@ -686,27 +765,44 @@ TEST_F(ResumeCtrlTest, IsHMIApplicationIdExist) {
 
 TEST_F(ResumeCtrlTest, GetHMIApplicationID) {
   uint32_t hmi_app_id = 10;
-  std::string device_id = "test_device_id";
+  const std::string kDeviceId = "test_device_id";
 
-  EXPECT_CALL(*mock_storage, GetHMIApplicationID(kTestPolicyAppId_, device_id))
+  EXPECT_CALL(*mock_storage, GetHMIApplicationID(kTestPolicyAppId_, kDeviceId))
       .WillOnce(Return(hmi_app_id));
   EXPECT_EQ(hmi_app_id,
-            res_ctrl->GetHMIApplicationID(kTestPolicyAppId_, device_id));
+            res_ctrl->GetHMIApplicationID(kTestPolicyAppId_, kDeviceId));
 }
 
 TEST_F(ResumeCtrlTest, IsApplicationSaved) {
-  std::string policy_app_id = "policy_app_id";
-  std::string device_id = "device_id";
+  const std::string kPolicyAppId = "policy_app_id";
+  const std::string kDeviceId = "device_id";
 
-  EXPECT_CALL(*mock_storage, IsApplicationSaved(policy_app_id, device_id))
-      .WillOnce(Return(true));
-  EXPECT_TRUE(res_ctrl->IsApplicationSaved(policy_app_id, device_id));
+  EXPECT_CALL(*mock_storage, IsApplicationSaved(kPolicyAppId, kDeviceId))
+      .WillOnce(Return(0));
+  EXPECT_TRUE(res_ctrl->IsApplicationSaved(kPolicyAppId, kDeviceId));
+}
+
+TEST_F(ResumeCtrlTest, OnAppRegistrationStart) {
+  const std::string kPolicyAppId = "policy_app_id";
+  const std::string kDeviceId = "device_id";
+
+  EXPECT_CALL(*mock_storage, IsApplicationSaved(kPolicyAppId, kDeviceId))
+      .WillOnce(Return(0));
+  res_ctrl->OnAppRegistrationStart(kPolicyAppId, kDeviceId);
+}
+
+TEST_F(ResumeCtrlTest, OnAppRegistrationEnd) {
+  uint32_t timeout = 10u;
+  EXPECT_CALL(mock_application_manager_settings_,
+              app_resumption_save_persistent_data_timeout())
+      .WillOnce(ReturnRef(timeout));
+  res_ctrl->OnAppRegistrationEnd();
 }
 
 TEST_F(ResumeCtrlTest, CheckPersistenceFiles_WithoutCommandAndChoiceSets) {
-  uint32_t ign_off_count = 0;
+  const uint32_t kIggnOffCount = 0;
   smart_objects::SmartObject saved_app;
-  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::ign_off_count] = kIggnOffCount;
   saved_app[application_manager::strings::hmi_level] = HMI_FULL;
 
   GetInfoFromApp();
@@ -718,9 +814,9 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFiles_WithoutCommandAndChoiceSets) {
 
 TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithCommands) {
   smart_objects::SmartObject test_application_commands;
-  uint32_t ign_off_count = 0;
+  const uint32_t kIggnOffCount = 0;
   smart_objects::SmartObject saved_app;
-  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::ign_off_count] = kIggnOffCount;
   saved_app[application_manager::strings::hmi_level] = HMI_FULL;
   saved_app[application_manager::strings::application_commands] =
       test_application_commands;
@@ -738,9 +834,9 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithCommands) {
 
 TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithChoiceSet) {
   smart_objects::SmartObject test_choice_sets;
-  uint32_t ign_off_count = 0;
+  const uint32_t kIggnOffCount = 0;
   smart_objects::SmartObject saved_app;
-  saved_app[application_manager::strings::ign_off_count] = ign_off_count;
+  saved_app[application_manager::strings::ign_off_count] = kIggnOffCount;
   saved_app[application_manager::strings::hmi_level] = HMI_FULL;
   saved_app[application_manager::strings::application_choice_sets] =
       test_choice_sets;
@@ -752,9 +848,38 @@ TEST_F(ResumeCtrlTest, CheckPersistenceFilesForResumption_WithChoiceSet) {
   EXPECT_TRUE(res_ctrl->CheckPersistenceFilesForResumption(app_mock));
 }
 
-// TODO (VVeremjova) APPLINK-16718
-TEST_F(ResumeCtrlTest, DISABLED_OnSuspend) {
+TEST_F(ResumeCtrlTest, OnSuspend) {
+  utils::SharedPtr<application_manager::Application> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  application_manager::ApplicationSet app_set;
+  app_set.insert(app_sh_mock);
+
+  DataAccessor<application_manager::ApplicationSet> accessor(app_set,
+                                                             app_set_lock_);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(accessor));
+  EXPECT_CALL(*mock_storage, SaveApplication(app_sh_mock)).Times(1);
+
   EXPECT_CALL(*mock_storage, OnSuspend());
+  EXPECT_CALL(*mock_storage, Persist());
+  res_ctrl->OnSuspend();
+}
+
+TEST_F(ResumeCtrlTest, OnSuspend_EmptyApplicationlist) {
+  utils::SharedPtr<application_manager::Application> app_sh_mock =
+      ::utils::MakeShared<application_manager_test::MockApplication>();
+
+  application_manager::ApplicationSet app_set;
+
+  DataAccessor<application_manager::ApplicationSet> accessor(app_set,
+                                                             app_set_lock_);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(accessor));
+  EXPECT_CALL(*mock_storage, SaveApplication(app_sh_mock)).Times(0);
+
+  EXPECT_CALL(*mock_storage, OnSuspend());
+  EXPECT_CALL(*mock_storage, Persist());
   res_ctrl->OnSuspend();
 }
 
@@ -774,9 +899,11 @@ TEST_F(ResumeCtrlTest, RemoveApplicationFromSaved) {
   EXPECT_TRUE(res_ctrl->RemoveApplicationFromSaved(app_mock));
 }
 
-TEST_F(ResumeCtrlTest, CheckApplicationkHash_) {
+TEST_F(ResumeCtrlTest, CheckApplicationHash) {
   smart_objects::SmartObject saved_app;
-  saved_app[application_manager::strings::hash_id] = kHash_;
+
+  const std::string test_hash = "saved_hash";
+  saved_app[application_manager::strings::hash_id] = test_hash;
 
   GetInfoFromApp();
   EXPECT_CALL(*mock_storage, GetSavedApplication(kTestPolicyAppId_, _, _))
diff --git a/src/components/application_manager/test/resumption/resumption_data_db_test.cc b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
index 9e04c869c5..0eddcb5a08 100644
--- a/src/components/application_manager/test/resumption/resumption_data_db_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
@@ -36,7 +36,7 @@
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_application_manager_settings.h"
 #include "interfaces/MOBILE_API.h"
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sql_database.h"
 #include "utils/sqlite_wrapper/sql_query.h"
 #include "utils/make_shared.h"
 #include "utils/file_system.h"
@@ -46,15 +46,25 @@
 #include "application_manager/resumption/resumption_sql_queries.h"
 #include "application_manager/resumption/resumption_data_db.h"
 
+#include "utils/sqlite_wrapper/sql_database_impl.h"
+#include "utils/mock_sql_database.h"
+#include "application_manager/mock_application_manager_settings.h"
+
 namespace test {
 namespace components {
 namespace resumption_test {
 
 using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::ReturnNull;
 using ::testing::ReturnRef;
+using ::testing::_;
 using application_manager_test::MockApplication;
 
+using ::test::components::utils::dbms::MockSQLDatabase;
+
 namespace am = application_manager;
+namespace smart_objects = ::NsSmartDeviceLink::NsSmartObjects;
 using namespace file_system;
 
 using namespace resumption;
@@ -67,7 +77,8 @@ const std::string kPath =
 class ResumptionDataDBTest : public ResumptionDataTest {
  protected:
   void SetUp() OVERRIDE {
-    app_mock = utils::MakeShared<NiceMock<MockApplication> >();
+    app_mock = ::utils::MakeShared<
+        NiceMock<application_manager_test::MockApplication> >();
     policy_app_id_ = "test_policy_app_id";
     app_id_ = 10;
     is_audio_ = true;
@@ -78,19 +89,17 @@ class ResumptionDataDBTest : public ResumptionDataTest {
     grammar_id_ = 16;
   }
   void TearDown() OVERRIDE {
-    utils::dbms::SQLQuery query(test_db());
+    ::utils::dbms::SQLQuery query(test_db());
     EXPECT_TRUE(query.Prepare(remove_all_tables));
     EXPECT_TRUE(query.Exec());
   }
 
   static void SetUpTestCase() {
-    kDatabaseName = "resumption";
     if (is_in_file) {
       path_ = "test_storage";
-      CreateDirectory(file_system::CurrentWorkingDirectory() + "/" + path_);
-      CreateDirectory(kPath);
-      test_db_ = new utils::dbms::SQLDatabase(kDatabaseName);
-      test_db_->set_path(kPath + "/");
+      CreateDirectory("./" + path_);
+      test_db_ = new ::utils::dbms::SQLDatabaseImpl(kDatabaseName);
+      test_db_->set_path(path_ + "/");
       res_db_ = new TestResumptionDataDB(In_File_Storage);
     } else {
       res_db_ = new TestResumptionDataDB(In_Memory_Storage);
@@ -101,7 +110,7 @@ class ResumptionDataDBTest : public ResumptionDataTest {
     EXPECT_TRUE(test_db_->IsReadWrite());
   }
 
-  static utils::dbms::SQLDatabase* test_db_;
+  static ::utils::dbms::SQLDatabase* test_db_;
   static std::string kDatabaseName;
   static std::string path_;
 
@@ -113,7 +122,7 @@ class ResumptionDataDBTest : public ResumptionDataTest {
     delete res_db_;
   }
 
-  utils::dbms::SQLDatabase* test_db() {
+  ::utils::dbms::SQLDatabase* test_db() {
     return test_db_;
   }
   std::string path() {
@@ -121,8 +130,8 @@ class ResumptionDataDBTest : public ResumptionDataTest {
   }
 
   void SetZeroIgnOffTime() {
-    utils::dbms::SQLQuery query(test_db());
-    EXPECT_TRUE(query.Prepare(KUpdateLastIgnOffTime));
+    ::utils::dbms::SQLQuery query(test_db());
+    EXPECT_TRUE(query.Prepare(resumption::KUpdateLastIgnOffTime));
     query.Bind(0, 0);
     EXPECT_TRUE(query.Exec());
   }
@@ -180,16 +189,16 @@ class ResumptionDataDBTest : public ResumptionDataTest {
   void CheckCharacters(int64_t global_properties_key);
   void CheckVRHelpItem(int64_t global_properties_key);
 
-  void BindId(utils::dbms::SQLQuery& query);
+  void BindId(::utils::dbms::SQLQuery& query);
 };
 
-utils::dbms::SQLDatabase* ResumptionDataDBTest::test_db_ = NULL;
+::utils::dbms::SQLDatabase* ResumptionDataDBTest::test_db_ = NULL;
 TestResumptionDataDB* ResumptionDataDBTest::res_db_ = NULL;
 std::string ResumptionDataDBTest::kDatabaseName = "";
 std::string ResumptionDataDBTest::path_ = "";
 
 void ResumptionDataDBTest::CheckSavedDB() {
-  utils::dbms::SQLQuery query_checks(test_db());
+  ::utils::dbms::SQLQuery query_checks(test_db());
   EXPECT_TRUE(query_checks.Prepare(kChecksResumptionData));
   EXPECT_TRUE(query_checks.Exec());
   EXPECT_EQ(1, query_checks.GetInteger(0));
@@ -206,7 +215,7 @@ void ResumptionDataDBTest::CheckSavedDB() {
 }
 
 void ResumptionDataDBTest::CheckExistenceApplication() {
-  utils::dbms::SQLQuery query(test_db());
+  ::utils::dbms::SQLQuery query(test_db());
   EXPECT_TRUE(query.Prepare(kCheckApplication));
   query.Bind(0, kMacAddress_);
   query.Bind(1, policy_app_id_);
@@ -215,7 +224,7 @@ void ResumptionDataDBTest::CheckExistenceApplication() {
 }
 
 void ResumptionDataDBTest::CheckAppData() {
-  utils::dbms::SQLQuery query(test_db());
+  ::utils::dbms::SQLQuery query(test_db());
   EXPECT_TRUE(query.Prepare(kSelectAppTable));
   BindId(query);
   EXPECT_TRUE(query.Exec());
@@ -233,7 +242,7 @@ void ResumptionDataDBTest::CheckAppData() {
 }
 
 void ResumptionDataDBTest::CheckGlobalProportiesData() {
-  utils::dbms::SQLQuery select_globalproperties(test_db());
+  ::utils::dbms::SQLQuery select_globalproperties(test_db());
 
   EXPECT_TRUE(select_globalproperties.Prepare(kSelectCountGlobalProperties));
   BindId(select_globalproperties);
@@ -263,7 +272,7 @@ void ResumptionDataDBTest::CheckGlobalProportiesData() {
                 select_globalproperties.GetString(7));
 
       EXPECT_FALSE(select_globalproperties.IsNull(3));
-      utils::dbms::SQLQuery select_image(test_db());
+      ::utils::dbms::SQLQuery select_image(test_db());
       EXPECT_TRUE(select_image.Prepare(kSelectImage));
       select_image.Bind(0, select_globalproperties.GetLongInt(3));
       EXPECT_TRUE(select_image.Exec());
@@ -273,7 +282,7 @@ void ResumptionDataDBTest::CheckGlobalProportiesData() {
                 select_image.GetString(1));
     }
     if (!select_globalproperties.IsNull(8)) {
-      utils::dbms::SQLQuery select_tts_chunk(test_db());
+      ::utils::dbms::SQLQuery select_tts_chunk(test_db());
       EXPECT_TRUE(select_tts_chunk.Prepare(kSelectTTSChunk));
       select_tts_chunk.Bind(0, select_globalproperties.GetLongInt(8));
       EXPECT_TRUE(select_tts_chunk.Exec());
@@ -286,7 +295,7 @@ void ResumptionDataDBTest::CheckGlobalProportiesData() {
       help_prompt_idx++;
     }
     if (!select_globalproperties.IsNull(9)) {
-      utils::dbms::SQLQuery select_tts_chunk(test_db());
+      ::utils::dbms::SQLQuery select_tts_chunk(test_db());
       EXPECT_TRUE(select_tts_chunk.Prepare(kSelectTTSChunk));
       select_tts_chunk.Bind(0, select_globalproperties.GetLongInt(9));
       EXPECT_TRUE(select_tts_chunk.Exec());
@@ -304,13 +313,13 @@ void ResumptionDataDBTest::CheckGlobalProportiesData() {
   }
 }
 void ResumptionDataDBTest::CheckVRHelpItem(int64_t global_properties_key) {
-  utils::dbms::SQLQuery checks_vrhelp_item(test_db());
+  ::utils::dbms::SQLQuery checks_vrhelp_item(test_db());
   EXPECT_TRUE(checks_vrhelp_item.Prepare(kChecksVrHelpItem));
   checks_vrhelp_item.Bind(0, global_properties_key);
   EXPECT_TRUE(checks_vrhelp_item.Exec());
   EXPECT_NE(0, checks_vrhelp_item.GetInteger(0));
   if (!checks_vrhelp_item.GetInteger(0)) {
-    utils::dbms::SQLQuery select_vrhelp_item(test_db());
+    ::utils::dbms::SQLQuery select_vrhelp_item(test_db());
     EXPECT_TRUE(select_vrhelp_item.Prepare(kSelectVrHelpItem));
     select_vrhelp_item.Bind(0, global_properties_key);
     size_t vr_help_item_idx = 0;
@@ -326,13 +335,13 @@ void ResumptionDataDBTest::CheckVRHelpItem(int64_t global_properties_key) {
 }
 
 void ResumptionDataDBTest::CheckCharacters(int64_t global_properties_key) {
-  utils::dbms::SQLQuery checks_characters(test_db());
+  ::utils::dbms::SQLQuery checks_characters(test_db());
   EXPECT_TRUE(checks_characters.Prepare(kChecksCharacter));
   checks_characters.Bind(0, global_properties_key);
   EXPECT_TRUE(checks_characters.Exec());
   EXPECT_NE(0, checks_characters.GetInteger(0));
   if (!checks_characters.GetInteger(0)) {
-    utils::dbms::SQLQuery select_characters(test_db());
+    ::utils::dbms::SQLQuery select_characters(test_db());
     EXPECT_TRUE(select_characters.Prepare(kSelectCharacter));
     select_characters.Bind(0, global_properties_key);
     size_t characters_idx = 0;
@@ -346,7 +355,7 @@ void ResumptionDataDBTest::CheckCharacters(int64_t global_properties_key) {
 }
 
 void ResumptionDataDBTest::CheckSubmenuData() {
-  utils::dbms::SQLQuery select_submenu(test_db());
+  ::utils::dbms::SQLQuery select_submenu(test_db());
 
   EXPECT_TRUE(select_submenu.Prepare(kSelectCountSubMenu));
   BindId(select_submenu);
@@ -369,7 +378,7 @@ void ResumptionDataDBTest::CheckSubmenuData() {
 }
 
 void ResumptionDataDBTest::CheckCommandsData() {
-  utils::dbms::SQLQuery select_commands(test_db());
+  ::utils::dbms::SQLQuery select_commands(test_db());
 
   EXPECT_TRUE(select_commands.Prepare(kSelectCountCommands));
   BindId(select_commands);
@@ -418,7 +427,7 @@ void ResumptionDataDBTest::CheckCommandsData() {
 }
 
 void ResumptionDataDBTest::CheckChoiceSetData() {
-  utils::dbms::SQLQuery select_choice_set(test_db());
+  ::utils::dbms::SQLQuery select_choice_set(test_db());
   EXPECT_TRUE(select_choice_set.Prepare(kSelectCountChoiceSet));
   BindId(select_choice_set);
   EXPECT_TRUE(select_choice_set.Exec());
@@ -469,7 +478,7 @@ void ResumptionDataDBTest::CheckChoiceSetData() {
       EXPECT_EQ(tertiary_text, select_choice_set.GetString(7));
 
       EXPECT_FALSE(select_choice_set.IsNull(8));
-      utils::dbms::SQLQuery select_image(test_db());
+      ::utils::dbms::SQLQuery select_image(test_db());
       EXPECT_TRUE(select_image.Prepare(kSelectImage));
       select_image.Bind(0, select_choice_set.GetLongInt(8));
       EXPECT_TRUE(select_image.Exec());
@@ -506,7 +515,7 @@ void ResumptionDataDBTest::CheckChoiceSetData() {
 }
 
 void ResumptionDataDBTest::CheckAppFilesData() {
-  utils::dbms::SQLQuery query(test_db());
+  ::utils::dbms::SQLQuery query(test_db());
   EXPECT_TRUE(query.Prepare(kSelectCountFiles));
   BindId(query);
   EXPECT_TRUE(query.Exec());
@@ -529,13 +538,414 @@ void ResumptionDataDBTest::CheckAppFilesData() {
   }
 }
 
-void ResumptionDataDBTest::BindId(utils::dbms::SQLQuery& query) {
+void ResumptionDataDBTest::BindId(::utils::dbms::SQLQuery& query) {
   query.Bind(0, policy_app_id_);
   query.Bind(1, kMacAddress_);
 }
 
+class ResumptionDBTest_WithMockStorage : public ::testing::Test {
+ public:
+  ResumptionDBTest_WithMockStorage()
+      // Mock database will be destroyed by resumption_data_db in ~Destr.
+      : mock_database_(new MockSQLDatabase()),
+        resumption_data_db_(mock_database_, mock_am_) {}
+
+  void SetUp() OVERRIDE {
+    ON_CALL(mock_am_settings_, attempts_to_open_resumption_db())
+        .WillByDefault(Return(1));
+    ON_CALL(mock_am_settings_, open_attempt_timeout_ms_resumption_db())
+        .WillByDefault(Return(1));
+    ON_CALL(mock_am_, get_settings())
+        .WillByDefault(ReturnRef(mock_am_settings_));
+  }
+  void TearDown() OVERRIDE {
+    EXPECT_CALL(*mock_database_, Close());
+  }
+
+  void InitRealDB() {
+    real_db_.Open();
+
+    EXPECT_CALL(*mock_database_, Open()).WillOnce(Return(true));
+    EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(true));
+    EXPECT_CALL(*mock_database_, conn())
+        .WillRepeatedly(Return(real_db_.conn()));
+
+    EXPECT_TRUE(resumption_data_db_.Init());
+  }
+
+  void ApplicationParamsCreateCalls(MockApplication* mock_app) {
+    EXPECT_CALL(*mock_app, curHash()).WillOnce(ReturnRef(kEmptyString_));
+    EXPECT_CALL(*mock_app, get_grammar_id()).WillOnce(Return(1u));
+    EXPECT_CALL(*mock_app, app_id()).WillRepeatedly(Return(1u));
+    EXPECT_CALL(*mock_app, hmi_app_id()).WillOnce(Return(1u));
+    EXPECT_CALL(*mock_app, IsAudioApplication()).WillOnce(Return(true));
+    EXPECT_CALL(mock_am_, IsAppSubscribedForWayPoints(_))
+        .WillOnce(Return(false));
+  }
+
+  void PrepareApplicationSO(smart_objects::SmartObject& app_data) {
+    app_data[ ::application_manager::strings::app_id] = "1";
+    app_data[ ::application_manager::strings::hash_id] = "1";
+    app_data[ ::application_manager::strings::grammar_id] = 1;
+    app_data[ ::application_manager::strings::connection_key] = 1;
+    app_data[ ::application_manager::strings::hmi_app_id] = 1;
+    app_data[ ::application_manager::strings::hmi_level] = HMILevel::HMI_FULL;
+    app_data[ ::application_manager::strings::is_media_application] = true;
+    app_data[ ::application_manager::strings::subscribed_for_way_points] =
+        false;
+    app_data[ ::application_manager::strings::ign_off_count] = 0;
+    app_data[ ::application_manager::strings::device_id] = "0";
+  }
+
+  void GetCorrectAppData(smart_objects::SmartObject& data) {
+    data =
+        smart_objects::SmartObject(smart_objects::SmartType::SmartType_Array);
+    data[0] = smart_objects::SmartObject(smart_objects::SmartType_Map);
+
+    smart_objects::SmartObject& application_data = data[0];
+
+    application_data["globalProperties"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    application_data["applicationFiles"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Array);
+    application_data["applicationSubMenus"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Array);
+    application_data["applicationCommands"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Array);
+    application_data["subscribtions"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    application_data["applicationChoiceSets"] =
+        smart_objects::SmartObject(smart_objects::SmartType_Array);
+
+    // Filling app_data with correct application values
+    PrepareApplicationSO(application_data);
+  }
+
+  void TestIncorrectAdditionalAppDataForWriting(const std::string& data_key) {
+    // Processing of Application_data needed real DB frow write
+    InitRealDB();
+    // Correct data smart object
+    smart_objects::SmartObject data;
+    GetCorrectAppData(data);
+    smart_objects::SmartObject& application_data = data[0];
+
+    application_data[data_key][0] = kEmptyString_;
+
+    EXPECT_CALL(*mock_database_, BeginTransaction()).Times(1);
+    EXPECT_CALL(*mock_database_, conn())
+        // Two times return reall db  connection to correct writing
+        // of app_data to DB
+        .WillOnce(Return(real_db_.conn()))
+        .WillOnce(Return(real_db_.conn()))
+        // Null connection for unsuccessful processing of FilesData
+        .WillOnce(ReturnNull());
+    EXPECT_CALL(*mock_database_, RollbackTransaction()).Times(1);
+    EXPECT_FALSE(resumption_data_db_.SaveAllData(data));
+  }
+
+  void AddApplicationsToDB(smart_objects::SmartObject& apps) {
+    EXPECT_CALL(*mock_database_, BeginTransaction()).Times(1);
+    EXPECT_CALL(*mock_database_, conn())
+        .WillRepeatedly(Return(real_db_.conn()));
+    EXPECT_CALL(*mock_database_, RollbackTransaction()).Times(0);
+    EXPECT_CALL(*mock_database_, CommitTransaction()).Times(1);
+
+    EXPECT_TRUE(resumption_data_db_.SaveAllData(apps));
+  }
+
+  MockSQLDatabase* mock_database_;
+  NiceMock<application_manager_test::MockApplicationManager> mock_am_;
+  NiceMock<application_manager_test::MockApplicationManagerSettings>
+      mock_am_settings_;
+  ResumptionDataDB resumption_data_db_;
+  ::utils::dbms::SQLDatabaseImpl real_db_;
+  const std::string kEmptyString_ = "";
+};
+
+TEST_F(ResumptionDBTest_WithMockStorage, Init_DBNotOpened_AttemptsOpened) {
+  EXPECT_CALL(*mock_database_, Open())
+      .WillOnce(Return(false))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(false));
+
+  EXPECT_FALSE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       Init_DBNotOpened_AttemptsNotOpenedToo) {
+  EXPECT_CALL(*mock_database_, Open()).WillRepeatedly(Return(false));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).Times(0);
+
+  EXPECT_FALSE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, Init_CannotCreateSchema) {
+  EXPECT_CALL(*mock_database_, Open()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, Init_CannotChecksResumptionData) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, Open()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, conn())
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, Init_CannotInsertInitData) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, Open()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, conn())
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, Init_Positive) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, Open()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, IsReadWrite()).WillOnce(Return(true));
+  EXPECT_CALL(*mock_database_, conn()).WillRepeatedly(Return(real_db.conn()));
+
+  EXPECT_TRUE(resumption_data_db_.Init());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, RefreshDB_CannotDropSchema) {
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.RefreshDB());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, RefreshDB_CannotCreateSchema) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, conn())
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.RefreshDB());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, RefreshDB_CannotInsertInitData) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, conn())
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(Return(real_db.conn()))
+      .WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.RefreshDB());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, RefreshDB_Positive) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, conn()).WillRepeatedly(Return(real_db.conn()));
+
+  EXPECT_TRUE(resumption_data_db_.RefreshDB());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       IsDBVersionActual_CannotSelectDBVersion) {
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.IsDBVersionActual());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, IsDBVersionActual_Positive) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(Return(real_db.conn()));
+
+  EXPECT_FALSE(resumption_data_db_.IsDBVersionActual());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, UpdateDBVersion_CannotPrepare) {
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.UpdateDBVersion());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, UpdateDBVersion_Positive) {
+  ::utils::dbms::SQLDatabaseImpl real_db;
+  real_db.Open();
+
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(Return(real_db.conn()));
+
+  EXPECT_FALSE(resumption_data_db_.UpdateDBVersion());
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       SaveApplication_AppNotChanged_AppExist) {
+  InitRealDB();
+  MockApplication* app_ptr = new MockApplication();
+  application_manager::ApplicationSharedPtr app_sptr(app_ptr);
+
+  const std::string kPolicyAppId = "1";
+  const std::string kMacAdress = "xx";
+
+  ApplicationParamsCreateCalls(app_ptr);
+
+  EXPECT_CALL(*app_ptr, policy_app_id()).WillRepeatedly(Return(kPolicyAppId));
+  EXPECT_CALL(*app_ptr, mac_address()).WillRepeatedly(ReturnRef(kMacAdress));
+  EXPECT_CALL(*app_ptr, is_application_data_changed())
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*app_ptr, hmi_level()).WillRepeatedly(Return(HMILevel::HMI_FULL));
+  EXPECT_CALL(*mock_database_, conn()).WillRepeatedly(Return(real_db_.conn()));
+  EXPECT_CALL(*mock_database_, Backup()).Times(2);
+
+  // App_not exists -> adding it to db
+  resumption_data_db_.SaveApplication(app_sptr);
+  // App exists update it in DB
+  resumption_data_db_.SaveApplication(app_sptr);
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       SaveApplication_AppNotChanged_AppExist_DBProblem) {
+  InitRealDB();
+  MockApplication* app_ptr = new MockApplication();
+  application_manager::ApplicationSharedPtr app_sptr(app_ptr);
+
+  const std::string kPolicyAppId = "1";
+  const std::string kMacAdress = "xx";
+
+  ApplicationParamsCreateCalls(app_ptr);
+
+  EXPECT_CALL(*app_ptr, policy_app_id()).WillRepeatedly(Return(kPolicyAppId));
+  EXPECT_CALL(*app_ptr, mac_address()).WillRepeatedly(ReturnRef(kMacAdress));
+  EXPECT_CALL(*app_ptr, is_application_data_changed())
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(*app_ptr, hmi_level()).WillRepeatedly(Return(HMILevel::HMI_FULL));
+  EXPECT_CALL(*mock_database_, conn())
+      .WillOnce(Return(real_db_.conn()))
+      .WillOnce(Return(real_db_.conn()))
+      .WillOnce(Return(real_db_.conn()))
+      .WillOnce(ReturnNull());
+  EXPECT_CALL(*mock_database_, Backup()).Times(1);
+
+  // App_not exists -> adding it to db
+  resumption_data_db_.SaveApplication(app_sptr);
+  // App exists update it in DB
+  resumption_data_db_.SaveApplication(app_sptr);
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_DataNotArray) {
+  smart_objects::SmartObject data(smart_objects::SmartType::SmartType_Map);
+
+  EXPECT_CALL(*mock_database_, BeginTransaction()).Times(0);
+
+  EXPECT_FALSE(resumption_data_db_.SaveAllData(data));
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       SaveAllData_IncorrectGlobalProperties) {
+  // Correct smart type
+  smart_objects::SmartObject data(smart_objects::SmartType::SmartType_Array);
+  data[0] = smart_objects::SmartObject(smart_objects::SmartType_Map);
+  smart_objects::SmartObject& application_data = data[0];
+
+  application_data["globalProperties"]["property_1"] = 1u;
+
+  EXPECT_CALL(*mock_database_, BeginTransaction()).Times(1);
+  EXPECT_CALL(*mock_database_, RollbackTransaction()).Times(1);
+  // Will create error while processing globalProperties
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  EXPECT_FALSE(resumption_data_db_.SaveAllData(data));
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_IncorrectApplicationData) {
+  // Correct smart type
+  smart_objects::SmartObject data(smart_objects::SmartType::SmartType_Array);
+  data[0] = smart_objects::SmartObject(smart_objects::SmartType_Map);
+  smart_objects::SmartObject& application_data = data[0];
+  // When global properties empty processing returns true
+  application_data["globalProperties"] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+
+  // App data havent any fields for application (app_id, hmi_level)
+
+  EXPECT_CALL(*mock_database_, BeginTransaction()).Times(1);
+  EXPECT_CALL(*mock_database_, RollbackTransaction()).Times(1);
+
+  EXPECT_FALSE(resumption_data_db_.SaveAllData(data));
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_IncorrectFilesData) {
+  TestIncorrectAdditionalAppDataForWriting("applicationFiles");
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_IncorrectSubMenu) {
+  TestIncorrectAdditionalAppDataForWriting("applicationSubMenus");
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_IncorrectCommandsData) {
+  TestIncorrectAdditionalAppDataForWriting("applicationCommands");
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage,
+       SaveAllData_IncorrectSubscriptionsData) {
+  TestIncorrectAdditionalAppDataForWriting("subscribtions");
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_IncorrectChoiceSetData) {
+  TestIncorrectAdditionalAppDataForWriting("applicationChoiceSets");
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, SaveAllData_Positive) {
+  // Processing of Application_data needed real DB frow write
+  InitRealDB();
+  // Correct smart type
+  smart_objects::SmartObject data;
+  GetCorrectAppData(data);
+
+  AddApplicationsToDB(data);
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, GetAllData_DBProblem) {
+  InitRealDB();
+  EXPECT_CALL(*mock_database_, conn()).WillOnce(ReturnNull());
+
+  smart_objects::SmartObject data;
+  resumption_data_db_.GetAllData(data);
+}
+
+TEST_F(ResumptionDBTest_WithMockStorage, GetAllData_Positive) {
+  InitRealDB();
+  smart_objects::SmartObject input_data;
+  GetCorrectAppData(input_data);
+  AddApplicationsToDB(input_data);
+
+  smart_objects::SmartObject output_data;
+  EXPECT_TRUE(resumption_data_db_.GetAllData(output_data));
+
+  // Timestamp added with writing to DB
+  output_data[0].erase("timeStamp");
+
+  EXPECT_TRUE(input_data == output_data);
+}
+
 TEST_F(ResumptionDataDBTest, Init) {
-  utils::dbms::SQLQuery query_checks(test_db());
+  ::utils::dbms::SQLQuery query_checks(test_db());
 
   EXPECT_TRUE(res_db()->Init());
 
diff --git a/src/components/application_manager/test/resumption/resumption_data_json_test.cc b/src/components/application_manager/test/resumption/resumption_data_json_test.cc
index 2bbb146bed..8a2b5a7f24 100644
--- a/src/components/application_manager/test/resumption/resumption_data_json_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_json_test.cc
@@ -39,6 +39,7 @@
 #include "application_manager/mock_resumption_data.h"
 #include "interfaces/MOBILE_API.h"
 #include "resumption/last_state.h"
+#include "utils/json_utils.h"
 
 #include "application_manager/resumption_data_test.h"
 #include "formatters/CFormatterJsonBase.h"
@@ -78,18 +79,20 @@ class ResumptionDataJsonTest : public ResumptionDataTest {
     hmi_level_ = HMILevel::eType::HMI_FULL;
     hmi_app_id_ = 8;
     ign_off_count_ = 0;
+    is_subscribed_for_way_points_ = true;
   }
 
   void CheckSavedJson() {
-    Value& dictionary = last_state_.dictionary;
-    ASSERT_TRUE(dictionary[am::strings::resumption].isObject());
+    utils::json::JsonValue& dictionary = last_state_.dictionary();
+    //    std::cout << dictionary.ToJson() << std::endl;
+    ASSERT_TRUE(dictionary[am::strings::resumption].IsObject());
     ASSERT_TRUE(
         dictionary[am::strings::resumption][am::strings::resume_app_list]
-            .isArray());
-    Value& resume_app_list =
+            .IsArray());
+    utils::json::JsonValueRef resume_app_list =
         dictionary[am::strings::resumption][am::strings::resume_app_list];
     sm::SmartObject res_app_list;
-    for (uint32_t i = 0; i < resume_app_list.size(); i++) {
+    for (uint32_t i = 0; i < resume_app_list.Size(); i++) {
       Formatters::CFormatterJsonBase::jsonValueToObj(resume_app_list[i],
                                                      res_app_list);
       CheckSavedApp(res_app_list);
@@ -97,18 +100,14 @@ class ResumptionDataJsonTest : public ResumptionDataTest {
   }
 
   void SetZeroIgnOff() {
-    Value& dictionary = last_state_.dictionary;
-    Value& res = dictionary[am::strings::resumption];
-    res[am::strings::last_ign_off_time] = 0;
+    utils::json::JsonValue& dictionary = last_state_.dictionary();
+    utils::json::JsonValueRef res = dictionary[am::strings::resumption];
+    res[am::strings::last_ign_off_time] = 0ll;
     last_state_.SaveToFileSystem();
   }
 
   resumption::LastState last_state_;
   ResumptionDataJson res_json;
-
-  application_manager_test::MockApplicationManagerSettings
-      mock_application_manager_settings_;
-  std::string policy_app_id_;
 };
 
 TEST_F(ResumptionDataJsonTest, SaveApplication) {
@@ -224,6 +223,10 @@ TEST_F(ResumptionDataJsonTest, UpdateHmiLevel) {
   CheckSavedJson();
 }
 
+TEST_F(ResumptionDataJsonTest, Init) {
+  EXPECT_TRUE(res_json.Init());
+}
+
 TEST_F(ResumptionDataJsonTest, IsHMIApplicationIdExist_AppIsSaved) {
   PrepareData();
   res_json.SaveApplication(app_mock);
@@ -283,6 +286,10 @@ TEST_F(ResumptionDataJsonTest, OnSuspendFourTimes) {
   EXPECT_TRUE(-1 != res_json.IsApplicationSaved(policy_app_id_, kMacAddress_));
 }
 
+TEST_F(ResumptionDataJsonTest, Persist) {
+  res_json.Persist();
+}
+
 TEST_F(ResumptionDataJsonTest, OnSuspendOnAwake) {
   PrepareData();
   SetZeroIgnOff();
diff --git a/src/components/application_manager/test/resumption_sql_queries_test.cc b/src/components/application_manager/test/resumption_sql_queries_test.cc
index d02b073099..10c3199d54 100644
--- a/src/components/application_manager/test/resumption_sql_queries_test.cc
+++ b/src/components/application_manager/test/resumption_sql_queries_test.cc
@@ -37,7 +37,8 @@
 #include <utility>
 #include "gtest/gtest.h"
 
-#include "utils/sql_wrapper.h"
+#include "utils/sqlite_wrapper/sql_database_impl.h"
+#include "utils/sqlite_wrapper/sql_query.h"
 #include "utils/file_system.h"
 #include "application_manager/resumption/resumption_sql_queries.h"
 #include "policy/sql_pt_queries.h"
@@ -50,6 +51,7 @@ using namespace ::resumption;
 
 using std::string;
 using std::pair;
+using utils::dbms::SQLDatabaseImpl;
 using utils::dbms::SQLDatabase;
 using utils::dbms::SQLQuery;
 
@@ -114,7 +116,7 @@ class ResumptionSqlQueriesTest : public ::testing::Test {
   static const int timeStamp2;
 
   static void SetUpTestCase() {
-    db_ = new SQLDatabase(db_path, connection_name);
+    db_ = new SQLDatabaseImpl();
     ASSERT_TRUE(db_->Open());
     ASSERT_TRUE(db_->IsReadWrite());
     SQLQuery query(db_);
diff --git a/src/components/include/test/utils/mock_sql_database.h b/src/components/include/test/utils/mock_sql_database.h
new file mode 100644
index 0000000000..ca121b4828
--- /dev/null
+++ b/src/components/include/test/utils/mock_sql_database.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_INCLUDE_TEST_UTILS_MOCK_SQL_DATABASE_H_
+#define SRC_COMPONENTS_INCLUDE_TEST_UTILS_MOCK_SQL_DATABASE_H_
+
+#include <string>
+
+#include "utils/sql_database.h"
+
+struct sqlite3;
+
+namespace test {
+namespace components {
+namespace utils {
+namespace dbms {
+
+class MockSQLDatabase : public ::utils::dbms::SQLDatabase {
+ public:
+  MOCK_METHOD0(Open, bool());
+  MOCK_METHOD0(Close, void());
+  MOCK_METHOD0(BeginTransaction, bool());
+  MOCK_METHOD0(CommitTransaction, bool());
+  MOCK_METHOD0(RollbackTransaction, bool());
+  MOCK_CONST_METHOD0(LastError, ::utils::dbms::SQLError());
+  MOCK_METHOD1(set_path, void(const std::string& path));
+  MOCK_CONST_METHOD0(get_path, std::string());
+  MOCK_METHOD0(IsReadWrite, bool());
+  MOCK_METHOD0(Backup, bool());
+  MOCK_CONST_METHOD0(conn, sqlite3*());
+  MOCK_CONST_METHOD0(HasErrors, bool());
+};
+
+}  // namespace dbms
+}  // namespace utils
+}  // namespace components
+}  // namespace test
+
+#endif  // SRC_COMPONENTS_INCLUDE_TEST_UTILS_MOCK_SQL_DATABASE_H_
diff --git a/src/components/include/utils/sql_database.h b/src/components/include/utils/sql_database.h
new file mode 100644
index 0000000000..3b87a07f9c
--- /dev/null
+++ b/src/components/include/utils/sql_database.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2016, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_INCLUDE_UTILS_SQL_DATABASE_H_
+#define SRC_COMPONENTS_INCLUDE_UTILS_SQL_DATABASE_H_
+
+#include <string>
+
+struct sqlite3;
+
+namespace utils {
+namespace dbms {
+
+class SQLQuery;
+class SQLError;
+
+/**
+ * Represents a connection to a database.
+ */
+class SQLDatabase {
+ public:
+  virtual ~SQLDatabase() {}
+  /**
+   * Opens connection to the temporary in-memory database
+   * @return true if successfully
+   */
+  virtual bool Open() = 0;
+
+  /**
+   * Closes connection to the database
+   */
+  virtual void Close() = 0;
+
+  /**
+   * Begins a transaction on the database
+   * @return true if successfully
+   */
+  virtual bool BeginTransaction() = 0;
+
+  /**
+   * Commits a transaction to the database
+   * @return true if successfully
+   */
+  virtual bool CommitTransaction() = 0;
+
+  /**
+   * Rolls back a transaction on the database
+   * @return true if successfully
+   */
+  virtual bool RollbackTransaction() = 0;
+
+  /**
+   * Gets information about the last error that occurred on the database
+   * @return last error
+   */
+  virtual SQLError LastError() const = 0;
+
+  /**
+   * @brief HasErrors Indicate the status of the last executed operation.
+   *
+   * @return true in case last operation has any errors, false otherwise.
+   */
+  virtual bool HasErrors() const = 0;
+
+  /**
+   * Sets path to database
+   * If the database is already opened then need reopen it
+   */
+  virtual void set_path(const std::string& path) = 0;
+
+  /**
+   * @brief get_path databse location path.
+   *
+   * @return the path to the database location
+   */
+  virtual std::string get_path() const = 0;
+
+  /**
+   * Checks if database is read/write
+   * @return true if database is read/write
+   */
+  virtual bool IsReadWrite() = 0;
+
+  /**
+   * Call backup for opened DB
+   */
+  virtual bool Backup() = 0;
+
+  /**
+   * Gets connection to the SQLite database
+   * @return pointer to connection
+   */
+  virtual sqlite3* conn() const = 0;
+};
+
+}  // namespace dbms
+}  // namespace utils
+
+#endif  // SRC_COMPONENTS_INCLUDE_UTILS_SQL_DATABASE_H_
diff --git a/src/components/policy/include/policy/sql_pt_representation.h b/src/components/policy/include/policy/sql_pt_representation.h
index 2710a7d4a5..59529b0b57 100644
--- a/src/components/policy/include/policy/sql_pt_representation.h
+++ b/src/components/policy/include/policy/sql_pt_representation.h
@@ -67,9 +67,12 @@ class Query : public utils::dbms::SQLQuery {
 };
 class SQLPTRepresentation : public virtual PTRepresentation {
  public:
+  SQLPTRepresentation();
+  SQLPTRepresentation(bool in_memory);
   SQLPTRepresentation(const std::string& app_storage_folder,
                       uint16_t attempts_to_open_policy_db,
                       uint16_t open_attempt_timeout_ms);
+
   ~SQLPTRepresentation();
   virtual void CheckPermissions(const PTString& app_id,
                                 const PTString& hmi_level,
diff --git a/src/components/policy/include/policy/sql_wrapper.h b/src/components/policy/include/policy/sql_wrapper.h
deleted file mode 100644
index ccdaf537b0..0000000000
--- a/src/components/policy/include/policy/sql_wrapper.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- Copyright (c) 2013, 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.
- */
-
-#ifndef SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
-#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
-
-#if __QNX__
-#include "utils/qdb_wrapper/sql_database.h"
-#include "utils/qdb_wrapper/sql_query.h"
-#else  // __QNX__
-#include "utils/sqlite_wrapper/sql_database.h"
-#include "utils/sqlite_wrapper/sql_query.h"
-#endif  // __QNX__
-
-#endif  // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
diff --git a/src/components/policy/src/sql_pt_ext_representation.cc b/src/components/policy/src/sql_pt_ext_representation.cc
index fb763fd6ee..f32a129797 100644
--- a/src/components/policy/src/sql_pt_ext_representation.cc
+++ b/src/components/policy/src/sql_pt_ext_representation.cc
@@ -33,7 +33,7 @@
 #include <utility>
 #include "utils/logger.h"
 #include "policy/sql_pt_ext_representation.h"
-#include "policy/sql_wrapper.h"
+#include "utils/sql_wrapper.h"
 #include "policy/sql_pt_queries.h"
 #include "policy/sql_pt_ext_queries.h"
 #include "policy/policy_helper.h"
diff --git a/src/components/policy/src/sql_pt_representation.cc b/src/components/policy/src/sql_pt_representation.cc
index 1cbcd6ccf5..afd804c722 100644
--- a/src/components/policy/src/sql_pt_representation.cc
+++ b/src/components/policy/src/sql_pt_representation.cc
@@ -45,7 +45,7 @@
 #include "utils/file_system.h"
 #include "utils/gen_hash.h"
 #include "policy/sql_pt_representation.h"
-#include "policy/sql_wrapper.h"
+#include "utils/sql_wrapper.h"
 #include "policy/sql_pt_queries.h"
 #include "policy/policy_helper.h"
 #include "policy/cache_manager.h"
@@ -69,15 +69,32 @@ void InsertUnique(K value, T* array) {
 const char* kDatabaseName = "policy";
 }  //  namespace
 
+SQLPTRepresentation::SQLPTRepresentation()
+    : db_(new utils::dbms::SQLDatabaseImpl(kDatabaseName)) {
+  is_in_memory = false;
+}
+
+SQLPTRepresentation::SQLPTRepresentation(bool in_memory) {
+  is_in_memory = in_memory;
+#ifdef __QNX__
+  db_ = new utils::dbms::SQLDatabaseImpl(kDatabaseName);
+#else   // __QNX__
+  if (in_memory) {
+    db_ = new utils::dbms::SQLDatabaseImpl();
+  } else {
+    db_ = new utils::dbms::SQLDatabaseImpl(kDatabaseName);
+  }
+#endif  // __QNX__
+}
+
 SQLPTRepresentation::SQLPTRepresentation(const std::string& app_storage_folder,
                                          uint16_t attempts_to_open_policy_db,
                                          uint16_t open_attempt_timeout_ms)
 #if defined(__QNX__)
-    : db_(new utils::dbms::SQLDatabase(kDatabaseName)
+    : db_(new utils::dbms::SQLDatabaseImpl(kDatabaseName)
 #else
-    : db_(new utils::dbms::SQLDatabase(
-          file_system::ConcatPath(app_storage_folder, kDatabaseName),
-          "PolicyDatabase"))
+    : db_(new utils::dbms::SQLDatabaseImpl(
+          file_system::ConcatPath(app_storage_folder, kDatabaseName)))
 #endif
 {}
 
@@ -1624,14 +1641,15 @@ const int32_t SQLPTRepresentation::GetDBVersion() const {
 }
 
 utils::dbms::SQLDatabase* SQLPTRepresentation::db() const {
-#if defined(__QNX__)
-  utils::dbms::SQLDatabase* db = new utils::dbms::SQLDatabase(kDatabaseName);
+#ifdef __QNX__
+  utils::dbms::SQLDatabase* db =
+      new utils::dbms::SQLDatabaseImpl(kDatabaseName);
   const bool result = db->Open();
   DCHECK(result);
   return db;
 #else
   return db_;
-#endif
+#endif  // __QNX__
 }
 
 bool SQLPTRepresentation::CopyApplication(const std::string& source,
diff --git a/src/components/policy/test/policy_manager_impl_test.cc b/src/components/policy/test/policy_manager_impl_test.cc
index b5fbdba7bc..c1ff36a61d 100644
--- a/src/components/policy/test/policy_manager_impl_test.cc
+++ b/src/components/policy/test/policy_manager_impl_test.cc
@@ -51,7 +51,9 @@
 #include "policy/mock_policy_listener.h"
 #include "policy/mock_cache_manager.h"
 #include "policy/mock_update_status_manager.h"
+#include "utils/sql_wrapper.h"
 
+#include "utils/sql_wrapper.h"
 #include "utils/macro.h"
 #include "utils/file_system.h"
 #include "utils/date_time.h"
diff --git a/src/components/utils/include/utils/json_utils.h b/src/components/utils/include/utils/json_utils.h
index f437049a82..2f7d398592 100644
--- a/src/components/utils/include/utils/json_utils.h
+++ b/src/components/utils/include/utils/json_utils.h
@@ -256,6 +256,8 @@ class JsonValueRef {
 
   JsonValueRef Append(const JsonValue& value);
 
+  void RemoveMember(const char* key);
+
   void Clear();
 
   bool IsValid() const;
diff --git a/src/components/utils/include/utils/qdb_wrapper/sql_database.h b/src/components/utils/include/utils/qdb_wrapper/sql_database_impl.h
index 0130e6cf53..bdcc0929f1 100644
--- a/src/components/utils/include/utils/qdb_wrapper/sql_database.h
+++ b/src/components/utils/include/utils/qdb_wrapper/sql_database_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Ford Motor Company
+ * Copyright (c) 2016, Ford Motor Company
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,11 +30,12 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_H_
-#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_H_
+#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_IMPL_H_
+#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_IMPL_H_
 
 #include <qdb/qdb.h>
 #include <string>
+#include "utils/sql_database.h"
 #include "qdb_wrapper/sql_error.h"
 #include "utils/lock.h"
 
@@ -46,45 +47,45 @@ class SQLQuery;
 /**
  * Represents a connection to a database.
  */
-class SQLDatabase {
+class SQLDatabaseImpl : public SQLDatabase {
  public:
-  explicit SQLDatabase(const std::string& db_name);
-  ~SQLDatabase();
+  explicit SQLDatabaseImpl(const std::string& db_name);
+  ~SQLDatabaseImpl();
 
   /**
    * Opens connection to the temporary in-memory database
    * @return true if successfully
    */
-  bool Open();
+  bool Open() OVERRIDE;
 
   /**
    * Closes connection to the database
    */
-  void Close();
+  void Close() OVERRIDE;
 
   /**
    * Begins a transaction on the database
    * @return true if successfully
    */
-  bool BeginTransaction();
+  bool BeginTransaction() OVERRIDE;
 
   /**
    * Commits a transaction to the database
    * @return true if successfully
    */
-  bool CommitTransaction();
+  bool CommitTransaction() OVERRIDE;
 
   /**
    * Rolls back a transaction on the database
    * @return true if successfully
    */
-  bool RollbackTransaction();
+  bool RollbackTransaction() OVERRIDE;
 
   /**
    * Gets information about the last error that occurred on the database
    * @return last error
    */
-  SQLError LastError() const;
+  SQLError LastError() const OVERRIDE;
 
   /**
    * @brief HasErrors Indicate the status of the last executed operation.
@@ -98,12 +99,13 @@ class SQLDatabase {
    */
   bool Backup();
 
- protected:
+  std::string get_path() const OVERRIDE;
+
   /**
    * Gets connection to the SQLite database
    * @return pointer to connection
    */
-  qdb_hdl_t* conn() const;
+  qdb_hdl_t* conn() const OVERRIDE;
 
  private:
   /**
@@ -139,4 +141,4 @@ class SQLDatabase {
 }  // namespace dbms
 }  // namespace utils
 
-#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_H_
+#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_QDB_WRAPPER_SQL_DATABASE_IMPL_H_
diff --git a/src/components/utils/include/utils/sql_qt_wrapper/sql_database.h b/src/components/utils/include/utils/sql_qt_wrapper/sql_database_impl.h
index d12c4381d4..92d8bc5425 100644
--- a/src/components/utils/include/utils/sql_qt_wrapper/sql_database.h
+++ b/src/components/utils/include/utils/sql_qt_wrapper/sql_database_impl.h
@@ -1,5 +1,5 @@
-#ifndef SRC_COMPONENTS_POLICY_SQLITE_WRAPPER_INCLUDE_SQL_QT_WRAPPER_SQL_DATABASE
-#define SRC_COMPONENTS_POLICY_SQLITE_WRAPPER_INCLUDE_SQL_QT_WRAPPER_SQL_DATABASE
+#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_QT_WRAPPER_SQL_DATABASE_IMPL_H_
+#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_QT_WRAPPER_SQL_DATABASE_IMPL_H_
 
 #include <string>
 
@@ -7,6 +7,7 @@
 
 #include "utils/lock.h"
 #include "utils/sql_qt_wrapper/sql_error.h"
+#include "utils/sql_database.h"
 
 namespace utils {
 namespace dbms {
@@ -14,12 +15,12 @@ namespace dbms {
 /**
  * Represents a connection to a database.
  */
-class SQLDatabase {
+class SQLDatabaseImpl : public SQLDatabase {
  public:
-  SQLDatabase();
-  SQLDatabase(const std::string& database_path,
-              const std::string& connection_name);
-  ~SQLDatabase();
+  SQLDatabaseImpl();
+  SQLDatabaseImpl(const std::string& database_path,
+                  const std::string& connection_name);
+  ~SQLDatabaseImpl();
 
   /**
    * Opens connection to the temporary in-memory database
@@ -105,4 +106,4 @@ class SQLDatabase {
 }  // namespace dbms
 }  // namespace utils
 
-#endif  // SRC_COMPONENTS_POLICY_SQLITE_WRAPPER_INCLUDE_SQL_QT_WRAPPER_SQL_DATABASE
+#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_QT_WRAPPER_SQL_DATABASE_IMPL_H_
diff --git a/src/components/utils/include/utils/sql_wrapper.h b/src/components/utils/include/utils/sql_wrapper.h
index 4ed7b4e3f3..41e8ad381c 100644
--- a/src/components/utils/include/utils/sql_wrapper.h
+++ b/src/components/utils/include/utils/sql_wrapper.h
@@ -30,18 +30,18 @@
  POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
-#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
+#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_WRAPPER_H_
+#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_WRAPPER_H_
 
 #if __QNX__
-#include "qdb_wrapper/sql_database.h"
-#include "qdb_wrapper/sql_query.h"
+#include "utils/qdb_wrapper/sql_database_impl.h"
+#include "utils/qdb_wrapper/sql_query.h"
 #elif defined QT_PORT
-#include "sql_qt_wrapper/sql_database.h"
-#include "sql_qt_wrapper/sql_query.h"
+#include "utils/sql_qt_wrapper/sql_database_impl.h"
+#include "utils/sql_qt_wrapper/sql_query.h"
 #else  // __QNX__
-#include "sqlite_wrapper/sql_database.h"
-#include "sqlite_wrapper/sql_query.h"
+#include "utils/sqlite_wrapper/sql_database_impl.h"
+#include "utils/sqlite_wrapper/sql_query.h"
 #endif  // __QNX__
 
-#endif  // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SQL_WRAPPER_H_
+#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQL_WRAPPER_H_
diff --git a/src/components/utils/include/utils/sqlite_wrapper/sql_database.h b/src/components/utils/include/utils/sqlite_wrapper/sql_database_impl.h
index 5fd3de5fa1..d9984604a9 100644
--- a/src/components/utils/include/utils/sqlite_wrapper/sql_database.h
+++ b/src/components/utils/include/utils/sqlite_wrapper/sql_database_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Ford Motor Company
+ * Copyright (c) 2016, Ford Motor Company
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,97 +30,94 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_H_
-#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_H_
+#ifndef SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_IMPL_H_
+#define SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_IMPL_H_
 
 #include <string>
+
+#include "utils/sql_database.h"
 #include "utils/sqlite_wrapper/sql_error.h"
 #include "utils/lock.h"
 
-struct sqlite3;
-
 namespace utils {
 namespace dbms {
-
-class SQLQuery;
-
 /**
  * Represents a connection to a database.
  */
-class SQLDatabase {
+class SQLDatabaseImpl : public SQLDatabase {
  public:
-  SQLDatabase();
-  SQLDatabase(const std::string& database_path,
-              const std::string& connection_name);
-  ~SQLDatabase();
+  SQLDatabaseImpl();
+  explicit SQLDatabaseImpl(const std::string& filename);
+  ~SQLDatabaseImpl();
 
   /**
    * Opens connection to the temporary in-memory database
    * @return true if successfully
    */
-  bool Open();
+  bool Open() OVERRIDE;
 
   /**
    * Closes connection to the database
    */
-  void Close();
+  void Close() OVERRIDE;
 
   /**
    * Begins a transaction on the database
    * @return true if successfully
    */
-  bool BeginTransaction();
+  bool BeginTransaction() OVERRIDE;
 
   /**
    * Commits a transaction to the database
    * @return true if successfully
    */
-  bool CommitTransaction();
+  bool CommitTransaction() OVERRIDE;
 
   /**
    * Rolls back a transaction on the database
    * @return true if successfully
    */
-  bool RollbackTransaction();
+  bool RollbackTransaction() OVERRIDE;
 
   /**
    * Gets information about the last error that occurred on the database
    * @return last error
    */
-  SQLError LastError() const;
+  SQLError LastError() const OVERRIDE;
 
   /**
    * @brief HasErrors Indicate the status of the last executed operation.
    *
    * @return true in case last operation has any errors, false otherwise.
    */
-  bool HasErrors() const;
+  bool HasErrors() const OVERRIDE;
+
+  void set_path(const std::string& path) OVERRIDE;
 
   /**
    * @brief get_path databse location path.
    *
    * @return the path to the database location
    */
-  std::string get_path() const;
+  std::string get_path() const OVERRIDE;
 
   /**
    * Checks if database is read/write
    * @return true if database is read/write
    */
-  bool IsReadWrite();
+  bool IsReadWrite() OVERRIDE;
 
   /**
    * Call backup for opened DB
    */
-  bool Backup();
+  bool Backup() OVERRIDE;
 
- protected:
 #ifndef QT_PORT
   /**
     * Gets connection to the SQLite database
     * @return pointer to connection
     */
-  sqlite3* conn() const;
+  sqlite3* conn() const OVERRIDE;
 #endif  // QT_PORT
 
  private:
@@ -139,12 +136,7 @@ class SQLDatabase {
   /**
    * The filename of database
    */
-  const std::string database_path_;
-
-  /**
-   * The database connection name
-   */
-  const std::string connection_name_;
+  std::string database_name_;
 
   int error_;
 
@@ -161,4 +153,4 @@ class SQLDatabase {
 }  // namespace dbms
 }  // namespace utils
 
-#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_H_
+#endif  // SRC_COMPONENTS_UTILS_INCLUDE_UTILS_SQLITE_WRAPPER_SQL_DATABASE_IMPL_H_
diff --git a/src/components/utils/src/json_utils.cc b/src/components/utils/src/json_utils.cc
index 5c36f5e660..ddb1c7d578 100644
--- a/src/components/utils/src/json_utils.cc
+++ b/src/components/utils/src/json_utils.cc
@@ -140,6 +140,10 @@ utils::json::JsonValueRef::JsonValueRef(JsonValue::Storage& storage,
   }
 }
 
+void utils::json::JsonValueRef::RemoveMember(const char* key) {
+  storage_->removeMember(key);
+}
+
 void utils::json::JsonValueRef::Clear() {
   DCHECK(IsValid());
   storage_->clear();
diff --git a/src/components/utils/src/qdb_wrapper/CMakeLists.txt b/src/components/utils/src/qdb_wrapper/CMakeLists.txt
index 6a10c3aa10..abf3ba6516 100644
--- a/src/components/utils/src/qdb_wrapper/CMakeLists.txt
+++ b/src/components/utils/src/qdb_wrapper/CMakeLists.txt
@@ -34,7 +34,7 @@ set(QDB_SRC_DIR ${COMPONENTS_DIR}/utils/src/qdb_wrapper)
 include_directories(${COMPONENTS_DIR}/utils/include/)
 
 set(SOURCES
-  ${QDB_SRC_DIR}/sql_database.cc
+  ${QDB_SRC_DIR}/sql_database_impl.cc
   ${QDB_SRC_DIR}/sql_query.cc
   ${QDB_SRC_DIR}/sql_error.cc
 )
diff --git a/src/components/utils/src/qdb_wrapper/sql_database.cc b/src/components/utils/src/qdb_wrapper/sql_database_impl.cc
index 32db4e4469..194d164b47 100644
--- a/src/components/utils/src/qdb_wrapper/sql_database.cc
+++ b/src/components/utils/src/qdb_wrapper/sql_database_impl.cc
@@ -31,7 +31,7 @@
  */
 
 #include <cstring>
-#include "qdb_wrapper/sql_database.h"
+#include "qdb_wrapper/sql_database_impl.h"
 #include "utils/logger.h"
 
 namespace utils {
@@ -39,14 +39,14 @@ namespace dbms {
 
 SDL_CREATE_LOGGER("SQLDatabase")
 
-SQLDatabase::SQLDatabase(const std::string& db_name)
+SQLDatabaseImpl::SQLDatabaseImpl(const std::string& db_name)
     : conn_(NULL), db_name_(db_name), error_(Error::OK) {}
 
-SQLDatabase::~SQLDatabase() {
+SQLDatabaseImpl::~SQLDatabaseImpl() {
   Close();
 }
 
-bool SQLDatabase::Open() {
+bool SQLDatabaseImpl::Open() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   if (conn_)
     return true;
@@ -58,7 +58,7 @@ bool SQLDatabase::Open() {
   return true;
 }
 
-void SQLDatabase::Close() {
+void SQLDatabaseImpl::Close() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   if (conn_) {
     if (qdb_disconnect(conn_) != -1) {
@@ -69,19 +69,19 @@ void SQLDatabase::Close() {
   }
 }
 
-bool SQLDatabase::BeginTransaction() {
+bool SQLDatabaseImpl::BeginTransaction() {
   return Exec("BEGIN TRANSACTION");
 }
 
-bool SQLDatabase::CommitTransaction() {
+bool SQLDatabaseImpl::CommitTransaction() {
   return Exec("COMMIT TRANSACTION");
 }
 
-bool SQLDatabase::RollbackTransaction() {
+bool SQLDatabaseImpl::RollbackTransaction() {
   return Exec("ROLLBACK TRANSACTION");
 }
 
-bool SQLDatabase::Exec(const std::string& query) {
+bool SQLDatabaseImpl::Exec(const std::string& query) {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   if (qdb_statement(conn_, query.c_str()) == -1) {
     error_ = Error::ERROR;
@@ -90,7 +90,7 @@ bool SQLDatabase::Exec(const std::string& query) {
   return true;
 }
 
-SQLError SQLDatabase::LastError() const {
+SQLError SQLDatabaseImpl::LastError() const {
   return SQLError(error_, qdb_geterrmsg(conn_));
 }
 
@@ -98,11 +98,15 @@ bool SQLDatabase::HasErrors() const {
   return Error(error_) != OK;
 }
 
-qdb_hdl_t* SQLDatabase::conn() const {
+qdb_hdl_t* SQLDatabaseImpl::conn() const {
   return conn_;
 }
 
-bool SQLDatabase::Backup() {
+std::string SQLDatabaseImpl::get_path() const {
+  return db_name_;
+}
+
+bool SQLDatabaseImpl::Backup() {
   if (qdb_backup(conn_, QDB_ATTACH_DEFAULT) == -1) {
     error_ = Error::ERROR;
     SDL_ERROR("Backup returned error: " << std::strerror(errno));
diff --git a/src/components/utils/src/qdb_wrapper/sql_query.cc b/src/components/utils/src/qdb_wrapper/sql_query.cc
index 3ce193c756..4cafae8c3b 100644
--- a/src/components/utils/src/qdb_wrapper/sql_query.cc
+++ b/src/components/utils/src/qdb_wrapper/sql_query.cc
@@ -34,7 +34,7 @@
 #include <string.h>
 #include <cassert>
 #include <algorithm>
-#include "qdb_wrapper/sql_database.h"
+#include "utils/sql_database.h"
 #include "utils/logger.h"
 #include <errno.h>
 
diff --git a/src/components/utils/src/sql_qt_wrapper/CMakeLists.txt b/src/components/utils/src/sql_qt_wrapper/CMakeLists.txt
index 4ef122e4de..bb38b97751 100644
--- a/src/components/utils/src/sql_qt_wrapper/CMakeLists.txt
+++ b/src/components/utils/src/sql_qt_wrapper/CMakeLists.txt
@@ -36,7 +36,7 @@ include_directories(
 )
 
 set(SOURCES
-  ./sql_database.cc
+  ./sql_database_impl.cc
   ./sql_error.cc
   ./sql_query.cc
 )
diff --git a/src/components/utils/src/sql_qt_wrapper/sql_database.cc b/src/components/utils/src/sql_qt_wrapper/sql_database_impl.cc
index 203cfdaa16..c32859bc31 100644
--- a/src/components/utils/src/sql_qt_wrapper/sql_database.cc
+++ b/src/components/utils/src/sql_qt_wrapper/sql_database_impl.cc
@@ -1,4 +1,4 @@
-#include "sql_qt_wrapper/sql_database.h"
+#include "sql_qt_wrapper/sql_database_impl.h"
 
 #include <QSqlError>
 
@@ -9,16 +9,16 @@ const QString kDatabaseExtension = ".sqlite";
 namespace utils {
 namespace dbms {
 
-SQLDatabase::SQLDatabase() : database_path_() {}
+SQLDatabaseImpl::SQLDatabaseImpl() : database_path_() {}
 
-SQLDatabase::SQLDatabase(const std::string& database_path,
-                         const std::string& connection_name)
+SQLDatabaseImpl::SQLDatabaseImpl(const std::string& database_path,
+                                 const std::string& connection_name)
     : database_path_((database_path + kDatabaseExtension.toStdString()).c_str())
     , connection_name_(connection_name.c_str()) {
   db_ = QSqlDatabase::addDatabase("QSQLITE", connection_name_);
 }
 
-SQLDatabase::~SQLDatabase() {
+SQLDatabaseImpl::~SQLDatabaseImpl() {
   Close();
   sync_primitives::AutoLock auto_lock(conn_lock_);
   /*
@@ -30,57 +30,57 @@ SQLDatabase::~SQLDatabase() {
   QSqlDatabase::removeDatabase(connection_name_);
 }
 
-bool SQLDatabase::Open() {
+bool SQLDatabaseImpl::Open() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   db_.setDatabaseName(database_path_);
   return db_.open();
 }
 
-void SQLDatabase::Close() {
+void SQLDatabaseImpl::Close() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   if (db_.isOpen()) {
     db_.close();
   }
 }
 
-bool SQLDatabase::BeginTransaction() {
+bool SQLDatabaseImpl::BeginTransaction() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   return db_.transaction();
 }
 
-bool SQLDatabase::CommitTransaction() {
+bool SQLDatabaseImpl::CommitTransaction() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   return db_.commit();
 }
 
-bool SQLDatabase::RollbackTransaction() {
+bool SQLDatabaseImpl::RollbackTransaction() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   return db_.rollback();
 }
 
-SQLError SQLDatabase::LastError() const {
+SQLError SQLDatabaseImpl::LastError() const {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   return SQLError(db_.lastError());
 }
 
-bool SQLDatabase::HasErrors() const {
+bool SQLDatabaseImpl::HasErrors() const {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   return db_.lastError().type() != QSqlError::NoError;
 }
 
-std::string SQLDatabase::get_path() const {
+std::string SQLDatabaseImpl::get_path() const {
   return database_path_.toStdString();
 }
 
-bool SQLDatabase::IsReadWrite() {
+bool SQLDatabaseImpl::IsReadWrite() {
   return true;
 }
 
-SQLDatabase::operator QSqlDatabase() const {
+SQLDatabaseImpl::operator QSqlDatabase() const {
   return db_;
 }
 
-bool SQLDatabase::Backup() {
+bool SQLDatabaseImpl::Backup() {
   return true;
 }
 
diff --git a/src/components/utils/src/sql_qt_wrapper/sql_query.cc b/src/components/utils/src/sql_qt_wrapper/sql_query.cc
index 4aa5b33c43..6cbbe5fe07 100644
--- a/src/components/utils/src/sql_qt_wrapper/sql_query.cc
+++ b/src/components/utils/src/sql_qt_wrapper/sql_query.cc
@@ -41,7 +41,7 @@
 #include <cassert>
 #include <limits>
 
-#include "sql_qt_wrapper/sql_database.h"
+#include "utils/sql_database.h"
 #include "utils/macro.h"
 
 namespace utils {
diff --git a/src/components/utils/src/sqlite_wrapper/CMakeLists.txt b/src/components/utils/src/sqlite_wrapper/CMakeLists.txt
index 4224376548..dd64d210d6 100644
--- a/src/components/utils/src/sqlite_wrapper/CMakeLists.txt
+++ b/src/components/utils/src/sqlite_wrapper/CMakeLists.txt
@@ -43,7 +43,7 @@ include_directories(
 )
 
 set(SOURCES
-  ${SQLITE_SRC_DIR}/sql_database.cc
+  ${SQLITE_SRC_DIR}/sql_database_impl.cc
   ${SQLITE_SRC_DIR}/sql_query.cc
   ${SQLITE_SRC_DIR}/sql_error.cc
 )
diff --git a/src/components/utils/src/sqlite_wrapper/sql_database.cc b/src/components/utils/src/sqlite_wrapper/sql_database_impl.cc
index 4763ddc776..1aacc05c0e 100644
--- a/src/components/utils/src/sqlite_wrapper/sql_database.cc
+++ b/src/components/utils/src/sqlite_wrapper/sql_database_impl.cc
@@ -30,7 +30,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "sqlite_wrapper/sql_database_impl.h"
 #include <sqlite3.h>
 
 namespace utils {
@@ -41,36 +41,33 @@ const char* kInMemory = ":memory:";
 const char* kExtension = ".sqlite";
 }  // namespace
 
-SQLDatabase::SQLDatabase()
-    : conn_(NULL), database_path_(kInMemory), error_(SQLITE_OK) {}
+SQLDatabaseImpl::SQLDatabaseImpl()
+    : conn_(NULL), database_name_(kInMemory), error_(SQLITE_OK) {}
 
-SQLDatabase::SQLDatabase(const std::string& database_path,
-                         const std::string& connection_name)
-    : conn_(NULL)
-    , database_path_(database_path + kExtension)
-    , connection_name_(connection_name)
-    , error_(SQLITE_OK) {}
+SQLDatabaseImpl::SQLDatabaseImpl(const std::string& db_name)
+    : conn_(NULL), database_name_(db_name + kExtension), error_(SQLITE_OK) {}
 
-SQLDatabase::~SQLDatabase() {
+SQLDatabaseImpl::~SQLDatabaseImpl() {
   Close();
 }
 
-bool SQLDatabase::Open() {
+bool SQLDatabaseImpl::Open() {
   sync_primitives::AutoLock auto_lock(conn_lock_);
-  if (conn_)
+  if (conn_) {
     return true;
-  error_ = sqlite3_open(database_path_.c_str(), &conn_);
+  }
+  error_ = sqlite3_open(database_name_.c_str(), &conn_);
   return error_ == SQLITE_OK;
   return true;
 }
 
-bool SQLDatabase::IsReadWrite() {
+bool SQLDatabaseImpl::IsReadWrite() {
   const char* schema = "main";
   return sqlite3_db_readonly(conn_, schema) == 0;
   return true;
 }
 
-void SQLDatabase::Close() {
+void SQLDatabaseImpl::Close() {
   if (!conn_) {
     return;
   }
@@ -82,40 +79,45 @@ void SQLDatabase::Close() {
   }
 }
 
-bool SQLDatabase::BeginTransaction() {
+bool SQLDatabaseImpl::BeginTransaction() {
   return Exec("BEGIN TRANSACTION");
 }
 
-bool SQLDatabase::CommitTransaction() {
+bool SQLDatabaseImpl::CommitTransaction() {
   return Exec("COMMIT TRANSACTION");
 }
 
-bool SQLDatabase::RollbackTransaction() {
+bool SQLDatabaseImpl::RollbackTransaction() {
   return Exec("ROLLBACK TRANSACTION");
 }
 
-bool SQLDatabase::Exec(const std::string& query) {
+bool SQLDatabaseImpl::Exec(const std::string& query) {
   sync_primitives::AutoLock auto_lock(conn_lock_);
   error_ = sqlite3_exec(conn_, query.c_str(), NULL, NULL, NULL);
   return error_ == SQLITE_OK;
 }
 
-SQLError SQLDatabase::LastError() const {
+SQLError SQLDatabaseImpl::LastError() const {
   return SQLError(Error(error_));
 }
 
-bool SQLDatabase::HasErrors() const {
+bool SQLDatabaseImpl::HasErrors() const {
   return Error(error_) != OK;
 }
-sqlite3* SQLDatabase::conn() const {
+
+sqlite3* SQLDatabaseImpl::conn() const {
   return conn_;
 }
 
-std::string SQLDatabase::get_path() const {
-  return database_path_;
+void SQLDatabaseImpl::set_path(const std::string& path) {
+  database_name_ = path + database_name_;
+}
+
+std::string SQLDatabaseImpl::get_path() const {
+  return database_name_;
 }
 
-bool SQLDatabase::Backup() {
+bool SQLDatabaseImpl::Backup() {
   return true;
 }
 }  // namespace dbms
diff --git a/src/components/utils/src/sqlite_wrapper/sql_query.cc b/src/components/utils/src/sqlite_wrapper/sql_query.cc
index 14fa0a5313..2369363bb4 100644
--- a/src/components/utils/src/sqlite_wrapper/sql_query.cc
+++ b/src/components/utils/src/sqlite_wrapper/sql_query.cc
@@ -33,7 +33,7 @@
 #include "utils/sqlite_wrapper/sql_query.h"
 #include <sqlite3.h>
 #include <cassert>
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sql_database.h"
 
 namespace utils {
 namespace dbms {
diff --git a/src/components/utils/test/generated_code_with_sqlite_test.cc b/src/components/utils/test/generated_code_with_sqlite_test.cc
index 19a8d1823a..bd46e10b56 100644
--- a/src/components/utils/test/generated_code_with_sqlite_test.cc
+++ b/src/components/utils/test/generated_code_with_sqlite_test.cc
@@ -90,7 +90,7 @@ const std::string GeneratedCodeTest::kGroupsCreation =
 TEST_F(GeneratedCodeTest,
        FindSectionEndpoints_OpenDBSetDefaultUrl_ExpectDefaultUrl) {
   // arrange
-  dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName, "test");
+  utils::dbms::SQLDatabaseImpl db(GeneratedCodeTest::kDatabaseName);
 
   // assert
   EXPECT_TRUE(db.Open());
@@ -110,7 +110,7 @@ TEST_F(GeneratedCodeTest,
 TEST_F(GeneratedCodeTest,
        RemoveSectionEndpoints_RemoveSectionEndpoints_Expect0EndPoints) {
   // arrange
-  dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName, "test");
+  utils::dbms::SQLDatabaseImpl db(GeneratedCodeTest::kDatabaseName);
 
   // assert
   EXPECT_TRUE(db.Open());
@@ -135,7 +135,7 @@ TEST_F(GeneratedCodeTest,
 TEST_F(GeneratedCodeTest,
        UpdateSectionEndpoints_SetUrlPoint_ExpectPointEqualsUrl) {
   // arrange
-  dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName, "test");
+  utils::dbms::SQLDatabaseImpl db(GeneratedCodeTest::kDatabaseName);
 
   // assert
   EXPECT_TRUE(db.Open());
@@ -178,7 +178,7 @@ TEST_F(GeneratedCodeTest,
 TEST_F(GeneratedCodeTest,
        UpdateSectionAppPolicies_SetAppParams_ExpectDBHasThem) {
   // arrange
-  dbms::SQLDatabase db(GeneratedCodeTest::kDatabaseName, "test");
+  utils::dbms::SQLDatabaseImpl db(GeneratedCodeTest::kDatabaseName);
 
   // assert
   EXPECT_TRUE(db.Open());
diff --git a/src/components/utils/test/include/utils/generated_code_with_sqlite_test.h b/src/components/utils/test/include/utils/generated_code_with_sqlite_test.h
index e21fd75f87..f1888e3f68 100644
--- a/src/components/utils/test/include/utils/generated_code_with_sqlite_test.h
+++ b/src/components/utils/test/include/utils/generated_code_with_sqlite_test.h
@@ -36,7 +36,7 @@
 #include "policy/policy_table/types.h"
 #include "rpc_base/rpc_base.h"
 #include "utils/sqlite_wrapper/sql_query.h"
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sqlite_wrapper/sql_database_impl.h"
 
 namespace test {
 namespace components {
diff --git a/src/components/utils/test/qdb_wrapper/sql_database_test.cc b/src/components/utils/test/qdb_wrapper/sql_database_test.cc
index 4e1a822b57..fd07ffcb67 100644
--- a/src/components/utils/test/qdb_wrapper/sql_database_test.cc
+++ b/src/components/utils/test/qdb_wrapper/sql_database_test.cc
@@ -33,8 +33,8 @@
 
 #include "gtest/gtest.h"
 
-#include "qdb_wrapper/sql_error.h"
-#include "qdb_wrapper/sql_database.h"
+#include "utils/qdb_wrapper/sql_error.h"
+#include "utils/qdb_wrapper/sql_database_impl.h"
 
 using ::utils::dbms::SQLError;
 using ::utils::dbms::SQLDatabase;
diff --git a/src/components/utils/test/qdb_wrapper/sql_query_test.cc b/src/components/utils/test/qdb_wrapper/sql_query_test.cc
index e575e4f575..6109560e68 100644
--- a/src/components/utils/test/qdb_wrapper/sql_query_test.cc
+++ b/src/components/utils/test/qdb_wrapper/sql_query_test.cc
@@ -34,9 +34,9 @@
 
 #include "gtest/gtest.h"
 
-#include "qdb_wrapper/sql_error.h"
-#include "qdb_wrapper/sql_database.h"
-#include "qdb_wrapper/sql_query.h"
+#include "utils/qdb_wrapper/sql_error.h"
+#include "utils/qdb_wrapper/sql_database_impl.h"
+#include "utils/qdb_wrapper/sql_query.h"
 
 using ::utils::dbms::SQLError;
 using ::utils::dbms::SQLDatabase;
diff --git a/src/components/utils/test/sqlite_wrapper/sql_database_test.cc b/src/components/utils/test/sqlite_wrapper/sql_database_test.cc
index 78689aa236..bda887c6d1 100644
--- a/src/components/utils/test/sqlite_wrapper/sql_database_test.cc
+++ b/src/components/utils/test/sqlite_wrapper/sql_database_test.cc
@@ -31,10 +31,10 @@
 
 #include "gtest/gtest.h"
 #include "utils/sqlite_wrapper/sql_error.h"
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sqlite_wrapper/sql_database_impl.h"
 
 using ::utils::dbms::SQLError;
-using ::utils::dbms::SQLDatabase;
+using ::utils::dbms::SQLDatabaseImpl;
 
 namespace test {
 namespace components {
@@ -49,9 +49,9 @@ namespace dbms_test {
   }
 }
 
-TEST(SQLDatabaseTest, OpenCloseMemory_OpenAndCloseDB_ActsWithoutError) {
+TEST(SQLDatabaseImplTest, OpenCloseMemory_OpenAndCloseDB_ActsWithoutError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
   bool ret = db.Open();
 
   // assert
@@ -65,9 +65,10 @@ TEST(SQLDatabaseTest, OpenCloseMemory_OpenAndCloseDB_ActsWithoutError) {
   EXPECT_FALSE(IsError(db.LastError()));
 }
 
-TEST(SQLDatabaseTest, OpenCloseFile_OpenAndCloseSpecifiedDB_ActsWithoutError) {
+TEST(SQLDatabaseImplTest,
+     OpenCloseFile_OpenAndCloseSpecifiedDB_ActsWithoutError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db("test-database");
   bool ret = db.Open();
 
   // assert
@@ -83,9 +84,9 @@ TEST(SQLDatabaseTest, OpenCloseFile_OpenAndCloseSpecifiedDB_ActsWithoutError) {
   remove("test-database.sqlite");
 }
 
-TEST(SQLDatabaseTest, OpenDBTwice_NoError) {
+TEST(SQLDatabaseImplTest, OpenDBTwice_NoError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
   bool ret = db.Open();
 
   // assert
@@ -102,9 +103,9 @@ TEST(SQLDatabaseTest, OpenDBTwice_NoError) {
   db.Close();
 }
 
-TEST(SQLDatabaseTest, CloseDBTwice_NoError) {
+TEST(SQLDatabaseImplTest, CloseDBTwice_NoError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
   bool ret = db.Open();
 
   // assert
@@ -124,19 +125,19 @@ TEST(SQLDatabaseTest, CloseDBTwice_NoError) {
   EXPECT_FALSE(IsError(db.LastError()));
 }
 
-TEST(SQLDatabaseTest, Close_DBWasNotOpened_NoError) {
+TEST(SQLDatabaseImplTest, Close_DBWasNotOpened_NoError) {
   // act
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
   db.Close();
 
   // assert
   EXPECT_FALSE(IsError(db.LastError()));
 }
 
-TEST(SQLDatabaseTest,
+TEST(SQLDatabaseImplTest,
      CommitTransaction_StartAndCommitTransaction_ExpectActsWithoutError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -148,10 +149,10 @@ TEST(SQLDatabaseTest,
   db.Close();
 }
 
-TEST(SQLDatabaseTest,
+TEST(SQLDatabaseImplTest,
      RollbackTransaction_StartAndRollbackTransaction_ExpectActsWithoutError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -163,10 +164,10 @@ TEST(SQLDatabaseTest,
   db.Close();
 }
 
-TEST(SQLDatabaseTest,
+TEST(SQLDatabaseImplTest,
      FailedCommitTransaction_CommitTransactionWithoutBeginning_ExpectError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -177,10 +178,10 @@ TEST(SQLDatabaseTest,
 }
 
 TEST(
-    SQLDatabaseTest,
+    SQLDatabaseImplTest,
     FailedRollbackTransaction_RollbackTransactionWithoutBeginning_ExpectError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -190,18 +191,19 @@ TEST(
   db.Close();
 }
 
-TEST(SQLDatabaseTest, BadTransaction_BeginTransitionWithoutOpenDB_ExpectError) {
+TEST(SQLDatabaseImplTest,
+     BadTransaction_BeginTransitionWithoutOpenDB_ExpectError) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db;
 
   // assert
   EXPECT_FALSE(db.BeginTransaction());
   EXPECT_TRUE(IsError(db.LastError()));
 }
 
-TEST(SQLDatabaseTest, IsReadWrite_FirstOpenDBIsRWSecondIsNot) {
+TEST(SQLDatabaseImplTest, IsReadWrite_FirstOpenDBIsRWSecondIsNot) {
   // arrange
-  SQLDatabase db("test-database", "test");
+  SQLDatabaseImpl db("test-database");
 
   // assert
   ASSERT_TRUE(db.Open());
diff --git a/src/components/utils/test/sqlite_wrapper/sql_query_test.cc b/src/components/utils/test/sqlite_wrapper/sql_query_test.cc
index 074b4689bc..245b55116c 100644
--- a/src/components/utils/test/sqlite_wrapper/sql_query_test.cc
+++ b/src/components/utils/test/sqlite_wrapper/sql_query_test.cc
@@ -35,11 +35,11 @@
 #include "gtest/gtest.h"
 
 #include "utils/sqlite_wrapper/sql_error.h"
-#include "utils/sqlite_wrapper/sql_database.h"
+#include "utils/sqlite_wrapper/sql_database_impl.h"
 #include "utils/sqlite_wrapper/sql_query.h"
 
 using ::utils::dbms::SQLError;
-using ::utils::dbms::SQLDatabase;
+using ::utils::dbms::SQLDatabaseImpl;
 using ::utils::dbms::SQLQuery;
 
 namespace test {
@@ -102,7 +102,7 @@ const std::string SQLQueryTest::kDatabaseName = "test-query";
 TEST_F(SQLQueryTest, Query_CreateQuery_QueryInDBEqualCreated) {
   // arrange
   const std::string kSelect("SELECT * FROM testTable WHERE integerValue = ?");
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -121,7 +121,7 @@ TEST_F(SQLQueryTest, ExecString_ExecuteQuery_ActWithoutError) {
       "INSERT INTO testTable"
       " (integerValue, doubleValue, stringValue)"
       " VALUES(2, 3.4, 'five-пять')");
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
   // assert
   ASSERT_TRUE(db.Open());
 
@@ -146,7 +146,7 @@ TEST_F(SQLQueryTest,
   const double kDoubleValue = 2.3;
   const std::string kStringValue = "four";
 
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -217,7 +217,7 @@ TEST_F(SQLQueryTest, SetValue_InsertValues_ExpectDBHasInsertedValues) {
   const double kDoubleValue = 2.3;
   const std::string kStringValue = "four";
 
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -242,7 +242,7 @@ TEST_F(SQLQueryTest, EmptySelect_SelectValuesEqual0_ExecWithoutErrors) {
   const std::string kSelect(
       "SELECT integerValue, doubleValue, stringValue"
       " FROM testTable WHERE 0");
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -278,7 +278,7 @@ TEST_F(
   const double kDoubleValue = 2.3;
   const std::string kStringValue = "four";
 
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
   ASSERT_TRUE(db.Open());
 
   SQLQuery query(&db);
@@ -314,7 +314,7 @@ TEST_F(SQLQueryTest, LastInsertId_InsertValuesAndBindQuery_GetExpectedId) {
   const std::string kInsert("INSERT INTO idTable (value) VALUES(?)");
 
   // act
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
 
   // assert
   ASSERT_TRUE(db.Open());
@@ -343,7 +343,7 @@ TEST_F(SQLQueryTest, BindNull_BindWithoutValue_ActWithoutErrors) {
   const std::string kInsert(
       "INSERT INTO testTable (`integerValue`)"
       " VALUES (?)");
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
   // assert
   ASSERT_TRUE(db.Open());
 
@@ -362,7 +362,7 @@ TEST_F(SQLQueryTest, BindNull_BindWithoutValue_ActWithoutErrors) {
 
 TEST_F(SQLQueryTest, DoublePrepare_TwicePrepareQuery_ActWithoutErrors) {
   // arrange
-  SQLDatabase db(kDatabaseName, "test");
+  SQLDatabaseImpl db(kDatabaseName);
   // assert
   ASSERT_TRUE(db.Open());
   // act