Add new external UCS-related params in PTU, PreloadedPT, SnapshotPT

  - added perstistence for external user consent status
  - fixed failed UTs

36 files changed, 1789 insertions, 463 deletions

diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h
index c4f45cc1ee..f4b86ede7b 100644
--- a/src/components/application_manager/include/application_manager/policies/policy_handler.h
+++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h
@@ -536,6 +536,14 @@ class PolicyHandler : public PolicyHandlerInterface,
   void OnEmptyCertificateArrived() const;
 #endif  // EXTERNAL_PROPRIETARY_MODE
   bool SaveSnapshot(const BinaryMessage& pt_string, std::string& snap_path);
+
+  /**
+ * @brief Collects currently registered applications ids linked to their
+ * device id
+ * @param out_links Collection of device_id-to-app_id links
+ */
+  void GetRegisteredLinks(std::map<std::string, std::string>& out_links) const;
+
   static const std::string kLibrary;
   mutable sync_primitives::RWLock policy_manager_lock_;
   utils::SharedPtr<PolicyManager> policy_manager_;
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 1a720d9bc0..a36df1f296 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -237,6 +237,43 @@ struct LinkAppToDevice {
   const ApplicationManager& application_manager_;
 };
 
+/**
+ * @brief Gets from system list of currently registered applications and
+ * create collection of links device-to-application
+ */
+struct LinksCollector {
+  LinksCollector(const ApplicationManager& application_manager,
+                 std::map<std::string, std::string>& out_app_to_device_link)
+      : application_manager_(application_manager)
+      , out_app_to_device_link_(out_app_to_device_link) {
+    out_app_to_device_link_.clear();
+  }
+
+  void operator()(const ApplicationSharedPtr& app) {
+    if (!app.valid()) {
+      LOG4CXX_WARN(logger_,
+                   "Invalid pointer to application was passed."
+                   "Skip current application.");
+      return;
+    }
+    DeviceParams device_params = GetDeviceParams(
+        app->device(),
+        application_manager_.connection_handler().get_session_observer());
+    const std::string app_id = app->policy_app_id();
+    if (device_params.device_mac_address.empty()) {
+      LOG4CXX_WARN(logger_,
+                   "Couldn't find device, which hosts application " << app_id);
+      return;
+    }
+    out_app_to_device_link_.insert(
+        std::make_pair(device_params.device_mac_address, app_id));
+  }
+
+ private:
+  const ApplicationManager& application_manager_;
+  std::map<std::string, std::string>& out_app_to_device_link_;
+};
+
 struct PermissionsConsolidator {
   void Consolidate(
       const std::vector<policy::FunctionalGroupPermission>& permissions) {
@@ -614,6 +651,16 @@ void PolicyHandler::OnGetUserFriendlyMessage(
       result, correlation_id, application_manager_);
 }
 
+void PolicyHandler::GetRegisteredLinks(
+    std::map<std::string, std::string>& out_links) const {
+  DataAccessor<ApplicationSet> accessor = application_manager_.applications();
+  ApplicationSetConstIt it_app = accessor.GetData().begin();
+  ApplicationSetConstIt it_app_end = accessor.GetData().end();
+
+  LinksCollector linker(application_manager_, out_links);
+  std::for_each(it_app, it_app_end, linker);
+}
+
 void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
                                            const uint32_t correlation_id) {
   LOG4CXX_AUTO_TRACE(logger_);
diff --git a/src/components/include/policy/policy_external/policy/policy_listener.h b/src/components/include/policy/policy_external/policy/policy_listener.h
index a5c5338265..de9d6eb8ef 100644
--- a/src/components/include/policy/policy_external/policy/policy_listener.h
+++ b/src/components/include/policy/policy_external/policy/policy_listener.h
@@ -113,6 +113,14 @@ class PolicyListener {
    * @param certificate_data the value of the updated field.
    */
   virtual void OnCertificateUpdated(const std::string& certificate_data) = 0;
+
+  /**
+ * @brief Collects currently registered applications ids linked to their
+ * device id
+ * @return Collection of device_id-to-app_id links
+ */
+  virtual void GetRegisteredLinks(
+      std::map<std::string, std::string>& out_links) const = 0;
 };
 }  //  namespace policy
 #endif  // SRC_COMPONENTS_INCLUDE_POLICY_POLICY_LISTENER_H_
diff --git a/src/components/include/policy/policy_external/policy/policy_manager.h b/src/components/include/policy/policy_external/policy/policy_manager.h
index 74a3d36c4f..86f3124ca7 100644
--- a/src/components/include/policy/policy_external/policy/policy_manager.h
+++ b/src/components/include/policy/policy_external/policy/policy_manager.h
@@ -485,6 +485,19 @@ class PolicyManager : public usage_statistics::StatisticsManager {
   virtual void SetDecryptedCertificate(const std::string& certificate) = 0;
 
   virtual const PolicySettings& get_settings() const = 0;
+  /**
+   * @brief Saves customer connectivity settings status
+   * @param status ExternalConsent status
+   * @return true if succeeded, otherwise - false
+   */
+  virtual bool SetExternalConsentStatus(
+      const ExternalConsentStatus& status) = 0;
+
+  /**
+   * @brief Gets customer connectivity settings status
+   * @return external consent status
+   */
+  virtual ExternalConsentStatus GetExternalConsentStatus() = 0;
 
   /**
    * @brief Finds the next URL that must be sent on OnSystemRequest retry
diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
index 6186711715..4bd9dc90ae 100644
--- a/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
+++ b/src/components/include/test/policy/policy_external/policy/mock_policy_listener.h
@@ -83,6 +83,8 @@ class MockPolicyListener : public ::policy::PolicyListener {
   MOCK_METHOD1(OnCertificateUpdated, void(const std::string&));
   MOCK_CONST_METHOD2(SendOnAppPermissionsChanged,
                      void(const policy::AppPermissions&, const std::string&));
+  MOCK_CONST_METHOD1(GetRegisteredLinks,
+                     void(std::map<std::string, std::string>&));
 };
 
 }  // namespace policy_test
diff --git a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h
index ac51c47a75..a40ab8e1e3 100644
--- a/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h
+++ b/src/components/include/test/policy/policy_external/policy/mock_policy_manager.h
@@ -187,6 +187,8 @@ class MockPolicyManager : public PolicyManager {
   MOCK_CONST_METHOD2(RetrySequenceUrl,
                      AppIdURL(const struct RetrySequenceURL&,
                               const EndpointUrls& urls));
+  MOCK_METHOD1(SetExternalConsentStatus, bool(const ExternalConsentStatus&));
+  MOCK_METHOD0(GetExternalConsentStatus, ExternalConsentStatus());
 };
 }  // namespace policy_manager_test
 }  // namespace components
diff --git a/src/components/policy/policy_external/include/policy/cache_manager.h b/src/components/policy/policy_external/include/policy/cache_manager.h
index 13b7dd88bb..1d01cd86ca 100644
--- a/src/components/policy/policy_external/include/policy/cache_manager.h
+++ b/src/components/policy/policy_external/include/policy/cache_manager.h
@@ -433,9 +433,12 @@ class CacheManager : public CacheManagerInterface {
   /**
    * @brief Set user consent on functional groups
    * @param permissions User consent on functional group
+   * @param out_app_permissions_changed Indicates whether the permissions were
+   * changed
    * @return true, if operation succedeed, otherwise - false
    */
-  bool SetUserPermissionsForApp(const PermissionConsent& permissions);
+  bool SetUserPermissionsForApp(const PermissionConsent& permissions,
+                                bool* out_app_permissions_changed);
 
   /**
    * @brief Records information about head unit system to PT
@@ -626,6 +629,41 @@ class CacheManager : public CacheManagerInterface {
 
   virtual void SetDecryptedCertificate(const std::string& certificate) OVERRIDE;
 
+  bool SetExternalConsentStatus(const ExternalConsentStatus& status) OVERRIDE;
+  ExternalConsentStatus GetExternalConsentStatus() OVERRIDE;
+
+  /**
+ * @brief Creates collection of ExternalConsent items known by current
+ * functional
+ * groupings and appropiate section
+ * (disallowed_by_external_consent_entities_on/off) where
+ * is item is being holded. If item is not found it's not included into
+ * collection
+ * @param status Current status containing collection of ExternalConsent items
+ * @return Collection of ExternalConsent items mapped to list of groups with
+ * section
+ * marker where the item is found
+ */
+  GroupsByExternalConsentStatus GetGroupsWithSameEntities(
+      const ExternalConsentStatus& status) OVERRIDE;
+
+  /**
+  * @brief Gets collection of links device-to-application from device_data
+  * section of policy table if there any application records present, i.e. if
+  * any specific user consent is present
+  * @return Collection of device-to-application links
+  */
+  std::map<std::string, std::string> GetKnownLinksFromPT() OVERRIDE;
+
+  /**
+ * @brief Sets groups permissions affected by customer connectivity settings
+ * entities status, i.e. groups assigned to particular application on
+ * particular device which have same entities as current ExternalConsent status
+ * @param permissions Groups permissions which result current ExternalConsent
+ * status
+ */
+  void SetExternalConsentForApp(const PermissionConsent& permissions) OVERRIDE;
+
 #ifdef BUILD_TESTS
   utils::SharedPtr<policy_table::Table> GetPT() const {
     return pt_;
@@ -699,8 +737,9 @@ class CacheManager : public CacheManagerInterface {
    * JSON date is different than current database.
    *
    * @param file_name the preloaded policy table JSON file.
+   * @return false in case of invalid preloaded_pt
    */
-  void MergePreloadPT(const std::string& file_name);
+  bool MergePreloadPT(const std::string& file_name);
 
   bool GetPermissionsList(StringArray& perm_list) const;
 
diff --git a/src/components/policy/policy_external/include/policy/cache_manager_interface.h b/src/components/policy/policy_external/include/policy/cache_manager_interface.h
index fa31290987..877b8fe50e 100644
--- a/src/components/policy/policy_external/include/policy/cache_manager_interface.h
+++ b/src/components/policy/policy_external/include/policy/cache_manager_interface.h
@@ -444,10 +444,12 @@ class CacheManagerInterface {
   /**
    * @brief Set user consent on functional groups
    * @param permissions User consent on functional group
+   * @param out_app_permissions_changed Indicates whether the permissions were
+   * changed
    * @return true, if operation succedeed, otherwise - false
    */
-  virtual bool SetUserPermissionsForApp(
-      const PermissionConsent& permissions) = 0;
+  virtual bool SetUserPermissionsForApp(const PermissionConsent& permissions,
+                                        bool* out_app_permissions_changed) = 0;
 
   /**
    * @brief Records information about head unit system to PT
@@ -699,6 +701,52 @@ class CacheManagerInterface {
     */
   virtual void SetDecryptedCertificate(const std::string& certificate) = 0;
 
+  /**
+   * @brief Saves customer connectivity settings status
+   * @param status external consent status
+   * @return true if succeeded, otherwise - false
+   */
+  virtual bool SetExternalConsentStatus(
+      const ExternalConsentStatus& status) = 0;
+
+  /**
+   * @brief Gets customer connectivity settings status
+   * @return external consent status
+   */
+  virtual ExternalConsentStatus GetExternalConsentStatus() = 0;
+
+  /**
+ * @brief Creates collection of ExternalConsent items known by current
+ * functional
+ * groupings and appropiate section
+ * (disallowed_by_external_consent_entities_on/off) where
+ * is item is being holded
+ * @param status Current status containing collection of ExternalConsent items
+ * @return Collection of ExternalConsent items mapped to list of groups with
+ * section
+ * marker where the item is found
+ */
+  virtual GroupsByExternalConsentStatus GetGroupsWithSameEntities(
+      const ExternalConsentStatus& status) = 0;
+
+  /**
+ * @brief Gets collection of links device-to-application from device_data
+ * section of policy table if there any application records present, i.e. if
+ * any specific user consent is present
+ * @return Collection of device-to-application links
+ */
+  virtual std::map<std::string, std::string> GetKnownLinksFromPT() = 0;
+
+  /**
+ * @brief Sets groups permissions affected by customer connectivity settings
+ * entities status, i.e. groups assigned to particular application on
+ * particular device which have same entities as current ExternalConsent status
+ * @param permissions Groups permissions which result current ExternalConsent
+ * status
+ */
+  virtual void SetExternalConsentForApp(
+      const PermissionConsent& permissions) = 0;
+
 #ifdef BUILD_TESTS
   /**
    * @brief GetPT allows to obtain SharedPtr to PT.
diff --git a/src/components/policy/policy_external/include/policy/policy_manager_impl.h b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
index 7f8322ee05..dcca92cf07 100644
--- a/src/components/policy/policy_external/include/policy/policy_manager_impl.h
+++ b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
@@ -303,6 +303,100 @@ class PolicyManagerImpl : public PolicyManager {
   bool IsPTValid(utils::SharedPtr<policy_table::Table> policy_table,
                  policy_table::PolicyTableType type) const;
 
+  /**
+   * @brief Notify application about its permissions changes by preparing and
+   * sending OnPermissionsChanged notification
+   * @param policy_app_id Application id to send notification to
+   * @param app_group_permissons Current permissions for groups assigned to
+   * application
+   */
+  void NotifyPermissionsChanges(
+      const std::string& policy_app_id,
+      const std::vector<FunctionalGroupPermission>& app_group_permissions);
+
+  /**
+   * @brief Processes updated ExternalConsent status received via
+   * OnAppPermissionConsent
+   * notification by updating user consents and ExternalConsent consents for
+   * registered and
+   * known before by policy table (must have any user consent records)
+   * @param groups_by_status Collection of ExternalConsent entities with their
+   * statuses
+   */
+  void ProcessExternalConsentStatusUpdate(
+      const GroupsByExternalConsentStatus& groups_by_status);
+
+  /**
+   * @brief Processes ExternalConsent status for application registered
+   * afterward, so its
+   * user consents (if any) and ExternalConsent consents (if any) will be
+   * updated
+   * appropiately to current ExternalConsent status stored by policy table
+   * @param application_id Application id
+   */
+  void ProcessExternalConsentStatusForApp(const std::string& application_id);
+  /**
+   * @brief Directly updates user consent and ExternalConsent consents (if any)
+   * for
+   * application if it has assigned any of group from allowed or disallowed
+   * lists
+   * @param device_id Device id which is linked to application id
+   * @param application_id Application id
+   * @param allowed_groups List of group names allowed by current
+   * ExternalConsent status
+   * @param disallowed_groups List of group names disallwed by current
+   * ExternalConsent
+   * status
+   */
+  void UpdateAppConsentWithExternalConsent(
+      const std::string& device_id,
+      const std::string& application_id,
+      const GroupsNames& allowed_groups,
+      const GroupsNames& disallowed_groups);
+
+  typedef policy_table::ApplicationPolicies::value_type AppPoliciesValueType;
+
+  /**
+   * @brief Notifies system by sending OnAppPermissionChanged notification
+   * @param app_policy Reference to application policy
+   */
+  void NotifySystem(const AppPoliciesValueType& app_policy) const;
+
+  /**
+   * @brief Sends OnPermissionChange notification to application if its
+   * currently registered
+   * @param app_policy Reference to application policy
+   */
+  void SendPermissionsToApp(const AppPoliciesValueType& app_policy);
+
+  /**
+   * @brief Gets groups names from collection of groups permissions
+   * @param app_group_permissions Collection of groups permissions
+   * @return Collection of group names
+   */
+  policy_table::Strings GetGroupsNames(
+      const std::vector<FunctionalGroupPermission>& app_group_permissions)
+      const;
+
+  /**
+   * @brief Calculates consents for groups based on mapped ExternalConsent
+   * entities statuses
+   * and groups containers where entities have been found
+   * @param groups_by_external_consent ExternalConsent entities mapped to
+   * functional groups names and
+   * their containters where this entity has been found
+   * @param out_allowed_groups List of groups allowed by ExternalConsent status
+   * @param out_disallowed_groups List of groups disallowed by ExternalConsent
+   * status
+   */
+  void CalculateGroupsConsentFromExternalConsent(
+      const GroupsByExternalConsentStatus& groups_by_external_consent,
+      GroupsNames& out_allowed_groups,
+      GroupsNames& out_disallowed_groups) const;
+
+  bool SetExternalConsentStatus(const ExternalConsentStatus& status) OVERRIDE;
+  ExternalConsentStatus GetExternalConsentStatus() OVERRIDE;
+
   PolicyListener* listener_;
 
   UpdateStatusManager update_status_manager_;
diff --git a/src/components/policy/policy_external/include/policy/policy_table/types.h b/src/components/policy/policy_external/include/policy/policy_table/types.h
index 8ca91c310a..b0a0e3a5f5 100644
--- a/src/components/policy/policy_external/include/policy/policy_table/types.h
+++ b/src/components/policy/policy_external/include/policy/policy_table/types.h
@@ -229,10 +229,35 @@ struct RpcParameters : CompositeType {
   bool Validate() const;
 };
 
+struct ExternalConsentEntity : CompositeType {
+ public:
+  typedef Integer<int32_t, 0, 128> EntityInt;
+  EntityInt entity_type;
+  EntityInt entity_id;
+
+ public:
+  ExternalConsentEntity();
+  explicit ExternalConsentEntity(const Json::Value* value__);
+  ExternalConsentEntity(const int32_t type, const int32_t id);
+  Json::Value ToJsonValue() const;
+  bool operator==(const ExternalConsentEntity& rhs) const;
+  bool is_valid() const;
+  bool is_initialized() const;
+  void ReportErrors(rpc::ValidationReport* report__) const;
+  void SetPolicyTableType(PolicyTableType pt_type) OVERRIDE;
+};
+
+typedef Array<ExternalConsentEntity, 0, 100>
+    DisallowedByExternalConsentEntities;
+
 struct Rpcs : CompositeType {
  public:
   Optional<String<1, 255> > user_consent_prompt;
   Nullable<Rpc> rpcs;
+  Optional<DisallowedByExternalConsentEntities>
+      disallowed_by_external_consent_entities_on;
+  Optional<DisallowedByExternalConsentEntities>
+      disallowed_by_external_consent_entities_off;
 
  public:
   Rpcs();
@@ -453,6 +478,7 @@ struct UsageAndErrorCounts : CompositeType {
 struct ConsentRecords : CompositeType {
  public:
   Optional<ConsentGroups> consent_groups;
+  Optional<ConsentGroups> external_consent_status_groups;
   Optional<Enum<Input> > input;
   Optional<String<1, 255> > time_stamp;
 
diff --git a/src/components/policy/policy_external/include/policy/policy_types.h b/src/components/policy/policy_external/include/policy/policy_types.h
index a0eefda555..ad8ebc4c9c 100644
--- a/src/components/policy/policy_external/include/policy/policy_types.h
+++ b/src/components/policy/policy_external/include/policy/policy_types.h
@@ -384,6 +384,100 @@ struct RetrySequenceURL {
  */
 typedef std::pair<uint32_t, uint32_t> AppIdURL;
 
+enum EntityStatus { kStatusOn, kStatusOff };
+
+enum ReturnValue { kZero, kNonZero };
+
+/**
+ * @brief The ExternalConsentStatusItem struct represents customer connectivity
+ * settings
+ * item
+ */
+struct ExternalConsentStatusItem {
+  ExternalConsentStatusItem(const uint32_t type,
+                            const uint32_t id,
+                            const EntityStatus status)
+      : entity_type_(type), entity_id_(id), status_(status) {}
+
+  bool operator==(const ExternalConsentStatusItem& rhs) const {
+    return (entity_type_ == rhs.entity_type_) && (entity_id_ == rhs.entity_id_);
+  }
+
+  bool operator<(const ExternalConsentStatusItem& rhs) const {
+    return (entity_type_ < rhs.entity_type_) || (entity_id_ < rhs.entity_id_);
+  }
+
+  const uint32_t entity_type_;
+  const uint32_t entity_id_;
+  const EntityStatus status_;
+};
+
+struct ExternalConsentStatusItemSorter {
+  bool operator()(const ExternalConsentStatusItem& lhs,
+                  const ExternalConsentStatusItem& rhs) const {
+    return (lhs.entity_type_ < rhs.entity_type_) ||
+           (lhs.entity_id_ < rhs.entity_id_);
+  }
+};
+
+/**
+ * @brief Customer connectivity settings status
+ */
+typedef std::set<ExternalConsentStatusItem, ExternalConsentStatusItemSorter>
+    ExternalConsentStatus;
+
+/**
+ * @brief GroupsByExternalConsentStatus represents list of group names, which
+ * has mapped ExternalConsent item (entity type + entity id) in their
+ * disallowed_by_external_consent_ containers. Boolean value represents
+ * whether ExternalConsent item has been found in
+ * disallowed_by_external_consent_ON or in disallowed_by_external_consent_OFF
+ * container
+ */
+typedef std::map<ExternalConsentStatusItem,
+                 std::vector<std::pair<std::string, bool> > >
+    GroupsByExternalConsentStatus;
+
+/**
+ * @brief GroupsNames represents groups names from policy table -> functional
+ * groupings groups container
+ */
+typedef std::set<std::string> GroupsNames;
+
+typedef std::string ApplicationId;
+typedef std::string DeviceId;
+
+/**
+ * @brief Link of device to application
+ */
+typedef std::pair<policy::DeviceId, policy::ApplicationId> Link;
+
+/**
+ * @brief Collection of links
+ */
+typedef std::set<Link> ApplicationsLinks;
+
+/**
+ * @brief Represents possible result codes for policy table update check
+ */
+enum PermissionsCheckResult {
+  RESULT_NO_CHANGES,
+  RESULT_APP_REVOKED,
+  RESULT_NICKNAME_MISMATCH,
+  RESULT_PERMISSIONS_REVOKED,
+  RESULT_CONSENT_NEEDED,
+  RESULT_CONSENT_NOT_REQIURED,
+  RESULT_PERMISSIONS_REVOKED_AND_CONSENT_NEEDED,
+  RESULT_REQUEST_TYPE_CHANGED
+};
+
+/**
+ * @brief Per application collection of results done by checking policy table
+ * update
+ */
+typedef std::set<std::pair<std::string, PermissionsCheckResult> >
+    CheckAppPolicyResults;
+
 }  //  namespace policy
 
 #endif  // SRC_COMPONENTS_POLICY_POLICY_EXTERNAL_INCLUDE_POLICY_POLICY_TYPES_H_
diff --git a/src/components/policy/policy_external/include/policy/pt_ext_representation.h b/src/components/policy/policy_external/include/policy/pt_ext_representation.h
index ca3d45e946..c70cbec812 100644
--- a/src/components/policy/policy_external/include/policy/pt_ext_representation.h
+++ b/src/components/policy/policy_external/include/policy/pt_ext_representation.h
@@ -327,6 +327,20 @@ class PTExtRepresentation : public virtual PTRepresentation {
   virtual bool RemoveAppConsentForGroup(
       const std::string& policy_app_id,
       const std::string& functional_group_name) const = 0;
+
+  /**
+ * @brief Saves eternal user consent settings status
+ * @param status external consent status
+ * @return true if succeeded, otherwise - false
+ */
+  virtual bool SaveExternalConsentStatus(
+      const ExternalConsentStatus& status) const = 0;
+
+  /**
+   * @brief Gets customer connectivity settings status
+   * @return external consent status
+   */
+  virtual ExternalConsentStatus GetExternalConsentStatus() const = 0;
 };
 }  //  namespace policy
 
diff --git a/src/components/policy/policy_external/include/policy/sql_pt_ext_queries.h b/src/components/policy/policy_external/include/policy/sql_pt_ext_queries.h
index 96406feaf1..b8f85ec7b1 100644
--- a/src/components/policy/policy_external/include/policy/sql_pt_ext_queries.h
+++ b/src/components/policy/policy_external/include/policy/sql_pt_ext_queries.h
@@ -51,6 +51,7 @@ extern const std::string kInsertDeviceConsentedGroup;
 extern const std::string kInsertDevice;
 extern const std::string kSelectDeviceData;
 extern const std::string kSelectConsentGroup;
+extern const std::string kSelectExternalConsentStatusGroup;
 extern const std::string kInsertPreconsentedGroups;
 extern const std::string kSelectPreconsentedGroups;
 extern const std::string kDeletePreconsentedGroups;
@@ -60,6 +61,7 @@ extern const std::string kUpdateGlobalCounters;
 extern const std::string kInsertDeviceData;
 extern const std::string kDeleteDeviceData;
 extern const std::string kInsertConsentGroups;
+extern const std::string kInsertExternalConsentStatusGroups;
 extern const std::string kCountUnconsentedGroups;
 extern const std::string kSelectModuleMeta;
 extern const std::string kUpdateMetaParams;
@@ -90,6 +92,11 @@ extern const std::string kSelectUnpairedDevices;
 extern const std::string kHasMsgLanguageCode;
 extern const std::string kDeletePreconsentedGroupsByApplicationId;
 extern const std::string kDeleteAppConsent;
+extern const std::string kSelectExternalConsentStatus;
+extern const std::string kInsertExternalConsentStatus;
+extern const std::string kDeleteExternalConsentEntities;
+extern const std::string kInsertExternalConsentEntity;
+extern const std::string kSelectExternalConsentEntity;
 
 }  // namespace sql_pt_ext
 }  // namespace policy
diff --git a/src/components/policy/policy_external/include/policy/sql_pt_ext_representation.h b/src/components/policy/policy_external/include/policy/sql_pt_ext_representation.h
index 99fe099a59..8e38309db5 100644
--- a/src/components/policy/policy_external/include/policy/sql_pt_ext_representation.h
+++ b/src/components/policy/policy_external/include/policy/sql_pt_ext_representation.h
@@ -131,6 +131,8 @@ class SQLPTExtRepresentation : public SQLPTRepresentation,
                                 const std::string& functional_group_name) const;
 
   virtual bool SetVINValue(const std::string& value);
+  bool SaveExternalConsentStatus(const ExternalConsentStatus& status) const;
+  ExternalConsentStatus GetExternalConsentStatus() const;
 
  private:
   void GatherModuleMeta(policy_table::ModuleMeta* meta) const;
diff --git a/src/components/policy/policy_external/include/policy/sql_pt_queries.h b/src/components/policy/policy_external/include/policy/sql_pt_queries.h
index a0ff71ba13..d515624b32 100644
--- a/src/components/policy/policy_external/include/policy/sql_pt_queries.h
+++ b/src/components/policy/policy_external/include/policy/sql_pt_queries.h
@@ -58,6 +58,7 @@ extern const std::string kSelectAppLevels;
 extern const std::string kSelectDeviceData;
 extern const std::string kSelectFunctionalGroups;
 extern const std::string kSelectAllRpcs;
+extern const std::string kSelectExternalConsentEntities;
 extern const std::string kSelectUserMsgsVersion;
 extern const std::string kSelectAppPolicies;
 extern const std::string kSelectAppGroups;
@@ -71,6 +72,7 @@ extern const std::string kSelectDays;
 extern const std::string kSelectTimeoutResponse;
 extern const std::string kInsertFunctionalGroup;
 extern const std::string kInsertRpc;
+extern const std::string kInsertExternalConsentEntity;
 extern const std::string kInsertRpcWithParameter;
 extern const std::string kInsertApplication;
 extern const std::string kInsertAppGroup;
@@ -93,6 +95,7 @@ extern const std::string kDeleteAppLevel;
 extern const std::string kDeleteMessageString;
 extern const std::string kDeleteFunctionalGroup;
 extern const std::string kDeleteRpc;
+extern const std::string kDeleteExternalConsentEntities;
 extern const std::string kDeleteAppGroup;
 extern const std::string kDeleteApplication;
 extern const std::string kDeleteRequestType;
diff --git a/src/components/policy/policy_external/include/policy/sql_pt_representation.h b/src/components/policy/policy_external/include/policy/sql_pt_representation.h
index a2999b4bf5..0a2aab78e7 100644
--- a/src/components/policy/policy_external/include/policy/sql_pt_representation.h
+++ b/src/components/policy/policy_external/include/policy/sql_pt_representation.h
@@ -183,12 +183,21 @@ class SQLPTRepresentation : public virtual PTRepresentation {
   uint32_t open_counter_;
 #endif  // BUILD_TESTS
 
+  enum ExternalConsentEntitiesType {
+    kExternalConsentEntitiesTypeOn,
+    kExternalConsentEntitiesTypeOff
+  };
+
   /**
    * @brief Calculates DB version from current schema
    * @return version
    */
   const int32_t GetDBVersion() const;
   bool SaveRpcs(int64_t group_id, const policy_table::Rpc& rpcs);
+  bool SaveExternalConsentEntities(
+      const int64_t group_id,
+      const policy_table::DisallowedByExternalConsentEntities& entities,
+      ExternalConsentEntitiesType type) const;
   bool SaveServiceEndpoints(const policy_table::ServiceEndpoints& endpoints);
   bool SaveSecondsBetweenRetries(
       const policy_table::SecondsBetweenRetries& seconds);
diff --git a/src/components/policy/policy_external/src/cache_manager.cc b/src/components/policy/policy_external/src/cache_manager.cc
index 7eb74c2a53..ba71e5dc6f 100644
--- a/src/components/policy/policy_external/src/cache_manager.cc
+++ b/src/components/policy/policy_external/src/cache_manager.cc
@@ -53,6 +53,157 @@
 
 namespace policy_table = rpc::policy_table_interface_base;
 
+namespace {
+
+/**
+ * @brief Looks for ExternalConsent entity in the list of entities
+ * @param entities ExternalConsent entities list
+ * @param entity Entity to look for
+ * @return True if found in the list, otherwise - false
+ */
+bool IsEntityExists(
+    const policy_table::DisallowedByExternalConsentEntities& entities,
+    const policy_table::ExternalConsentEntity& entity) {
+  const policy_table::DisallowedByExternalConsentEntities::const_iterator
+      it_entity = std::find(entities.begin(), entities.end(), entity);
+
+  return entities.end() != it_entity;
+}
+
+/**
+ * @brief Returns group consent record constructed from input group permissions
+ */
+struct ExternalConsentConsentGroupAppender
+    : public std::unary_function<policy_table::ConsentGroups,
+                                 const policy::FunctionalGroupPermission&> {
+  policy_table::ConsentGroups::value_type operator()(
+      const policy::FunctionalGroupPermission& value) const {
+    return std::make_pair(value.group_name,
+                          rpc::Boolean(value.state == policy::kGroupAllowed));
+  }
+};
+
+/**
+ * @brief Looks for ExternalConsent entity in
+ * disallowed_by_external_consent_entities_on/off sections
+ * of each functional group
+ */
+struct GroupByEntityFinder
+    : public std::unary_function<
+          void,
+          const policy_table::FunctionalGroupings::value_type&> {
+  GroupByEntityFinder(
+      const policy::ExternalConsentStatusItem& external_consent_item,
+      policy::GroupsByExternalConsentStatus& out_groups_by_external_consent)
+      : external_consent_item_(external_consent_item)
+      , out_groups_by_external_consent_(out_groups_by_external_consent) {}
+
+  void operator()(
+      const policy_table::FunctionalGroupings::value_type& group) const {
+    if (!group.second.user_consent_prompt.is_initialized()) {
+      return;
+    }
+
+    policy_table::ExternalConsentEntity entity(
+        external_consent_item_.entity_type_, external_consent_item_.entity_id_);
+    const std::string group_name = group.first;
+
+    if (IsEntityExists(*group.second.disallowed_by_external_consent_entities_on,
+                       entity)) {
+      const bool disallowed_by_external_consent_entities_on_marker = true;
+      out_groups_by_external_consent_[external_consent_item_].push_back(
+          std::make_pair(group_name,
+                         disallowed_by_external_consent_entities_on_marker));
+    }
+
+    if (IsEntityExists(
+            *group.second.disallowed_by_external_consent_entities_off,
+            entity)) {
+      const bool disallowed_by_external_consent_entities_off_marker = false;
+      out_groups_by_external_consent_[external_consent_item_].push_back(
+          std::make_pair(group_name,
+                         disallowed_by_external_consent_entities_off_marker));
+    }
+  }
+
+ private:
+  const policy::ExternalConsentStatusItem& external_consent_item_;
+  policy::GroupsByExternalConsentStatus& out_groups_by_external_consent_;
+};
+
+/**
+ * @brief Maps ExternalConsent status item to the list of functional groups
+ * names specifying
+ * container where item is found. If item is not found it won't be added.
+ */
+struct GroupByExternalConsentItemFinder
+    : public std::unary_function<
+          void,
+          const policy::ExternalConsentStatus::value_type&> {
+  GroupByExternalConsentItemFinder(
+      const policy_table::FunctionalGroupings& groups,
+      policy::GroupsByExternalConsentStatus& out_groups_by_external_consent)
+      : groups_(groups), out_groups_by_css_(out_groups_by_external_consent) {}
+
+  void operator()(const policy::ExternalConsentStatus::value_type&
+                      external_consent_item) const {
+    GroupByEntityFinder group_finder(external_consent_item, out_groups_by_css_);
+    std::for_each(groups_.begin(), groups_.end(), group_finder);
+  }
+
+ private:
+  const policy_table::FunctionalGroupings& groups_;
+  policy::GroupsByExternalConsentStatus& out_groups_by_css_;
+};
+
+/**
+ * @brief Template for getting 'first' of std::pair to use with standard
+ * algorithm below
+ */
+template <typename T1, typename T2>
+const T1& pair_first(const std::pair<T1, T2>& item) {
+  return item.first;
+}
+
+/**
+ * @brief Collects known links device-to-application form
+ * device_data/user_consent_records is any record is present
+ */
+struct LinkCollector
+    : public std::unary_function<void,
+                                 const policy_table::DeviceData::value_type&> {
+  typedef std::vector<policy_table::UserConsentRecords::key_type>
+      ApplicationsIds;
+
+  LinkCollector(std::map<std::string, std::string>& links) : links_(links) {}
+
+  void operator()(const policy_table::DeviceData::value_type& value) {
+    using namespace policy_table;
+
+    device_id_ = value.first;
+
+    ApplicationsIds applications_ids;
+    std::transform(value.second.user_consent_records->begin(),
+                   value.second.user_consent_records->end(),
+                   std::back_inserter(applications_ids),
+                   &pair_first<UserConsentRecords::key_type,
+                               UserConsentRecords::mapped_type>);
+
+    std::for_each(applications_ids.begin(),
+                  applications_ids.end(),
+                  std::bind1st(std::mem_fun(&LinkCollector::FillLinks), this));
+  }
+
+ private:
+  void FillLinks(const ApplicationsIds::value_type app_id) const {
+    links_.insert(std::make_pair(device_id_, app_id));
+  }
+
+  std::string device_id_;
+  std::map<std::string, std::string>& links_;
+};
+}  // namespace
+
 namespace policy {
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Policy")
@@ -857,7 +1008,7 @@ void CacheManager::GetGroupNameByHashID(const int32_t group_id,
 }
 
 bool CacheManager::SetUserPermissionsForApp(
-    const PermissionConsent& permissions) {
+    const PermissionConsent& permissions, bool* out_app_permissions_changed) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock auto_lock(cache_lock_);
   CACHE_MANAGER_CHECK(false);
@@ -866,6 +1017,10 @@ bool CacheManager::SetUserPermissionsForApp(
   std::vector<FunctionalGroupPermission>::const_iterator iter_end =
       permissions.group_permissions.end();
 
+  if (out_app_permissions_changed) {
+    *out_app_permissions_changed = false;
+  }
+
   std::string group_name;
   for (; iter != iter_end; ++iter) {
     if (policy::kGroupUndefined != (*iter).state) {
@@ -876,8 +1031,20 @@ bool CacheManager::SetUserPermissionsForApp(
 
       GetGroupNameByHashID((*iter).group_id, group_name);
 
-      (*ucr.consent_groups)[group_name] =
-          ((*iter).state == policy::kGroupAllowed);
+      const bool set_group_to_allowed =
+          (policy::kGroupAllowed == (*iter).state);
+      if (out_app_permissions_changed) {
+        policy_table::ConsentGroups::const_iterator found_consent_group_it =
+            ucr.consent_groups->find(group_name);
+        // Permission change occurs if there is no group that has ever been
+        // consented or consent status of the existing one differs from the
+        // requested
+        *out_app_permissions_changed =
+            (ucr.consent_groups->end() == found_consent_group_it ||
+             set_group_to_allowed != found_consent_group_it->second);
+      }
+
+      (*ucr.consent_groups)[group_name] = set_group_to_allowed;
       *ucr.input = policy_table::Input::I_GUI;
       *ucr.time_stamp = currentDateTime();
     }
@@ -1978,7 +2145,9 @@ bool CacheManager::Init(const std::string& file_name,
           backup_->UpdateDBVersion();
           Backup();
         }
-        MergePreloadPT(file_name);
+        if (!MergePreloadPT(file_name)) {
+          result = false;
+        }
       }
     } break;
     case InitResult::SUCCESS: {
@@ -2144,12 +2313,81 @@ void CacheManager::SetDecryptedCertificate(const std::string& certificate) {
   Backup();
 }
 
-void CacheManager::MergePreloadPT(const std::string& file_name) {
+bool CacheManager::SetExternalConsentStatus(
+    const ExternalConsentStatus& status) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  if (status.empty()) {
+    LOG4CXX_INFO(logger_, "No ExternalConsent status update.");
+    return false;
+  }
+
+  return ex_backup_->SaveExternalConsentStatus(status);
+}
+
+ExternalConsentStatus CacheManager::GetExternalConsentStatus() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  return ex_backup_->GetExternalConsentStatus();
+}
+
+GroupsByExternalConsentStatus CacheManager::GetGroupsWithSameEntities(
+    const ExternalConsentStatus& status) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  CACHE_MANAGER_CHECK(policy::GroupsByExternalConsentStatus());
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  GroupsByExternalConsentStatus groups_by_external_consent;
+
+  GroupByExternalConsentItemFinder groups_by_external_consent_finder(
+      pt_->policy_table.functional_groupings, groups_by_external_consent);
+  std::for_each(
+      status.begin(), status.end(), groups_by_external_consent_finder);
+
+  return groups_by_external_consent;
+}
+
+std::map<std::string, std::string> CacheManager::GetKnownLinksFromPT() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  CACHE_MANAGER_CHECK((std::map<std::string, std::string>()));
+  std::map<std::string, std::string> links;
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+
+  LinkCollector collector(links);
+  std::for_each(pt_->policy_table.device_data->begin(),
+                pt_->policy_table.device_data->end(),
+                collector);
+
+  return links;
+}
+
+void CacheManager::SetExternalConsentForApp(
+    const PermissionConsent& permissions) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  CACHE_MANAGER_CHECK_VOID();
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  policy_table::ConsentGroups& external_consent_groups =
+      *(*(*pt_->policy_table.device_data)[permissions.device_id]
+             .user_consent_records)[permissions.policy_app_id]
+           .external_consent_status_groups;
+
+  external_consent_groups.clear();
+
+  ExternalConsentConsentGroupAppender appender;
+  std::transform(
+      permissions.group_permissions.begin(),
+      permissions.group_permissions.end(),
+      std::inserter(external_consent_groups, external_consent_groups.begin()),
+      appender);
+
+  Backup();
+}
+
+bool CacheManager::MergePreloadPT(const std::string& file_name) {
   LOG4CXX_AUTO_TRACE(logger_);
   policy_table::Table table;
   if (!LoadFromFile(file_name, table)) {
     LOG4CXX_DEBUG(logger_, "Unable to load preloaded PT.");
-    return;
+    return false;
   }
 
   sync_primitives::AutoLock lock(cache_lock_);
@@ -2164,6 +2402,7 @@ void CacheManager::MergePreloadPT(const std::string& file_name) {
     MergeCFM(new_table, current);
     Backup();
   }
+  return true;
 }
 
 void CacheManager::MergeMC(const policy_table::PolicyTable& new_pt,
diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc
index 419cb2e4ef..4ce18d3c79 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -56,6 +56,129 @@ void DeleteManager(policy::PolicyManager* pm) {
   delete pm;
 }
 
+namespace {
+
+/**
+ * @brief Extracts group name from group permission structure
+ */
+struct GroupNamesAppender
+    : public std::unary_function<void,
+                                 const policy::FunctionalGroupPermission&> {
+  GroupNamesAppender(policy_table::Strings& names) : names_(names) {}
+
+  void operator()(const policy::FunctionalGroupPermission& value) {
+    names_.push_back(value.group_name);
+  }
+
+ private:
+  policy_table::Strings& names_;
+};
+
+/**
+ * @brief Updates permission state of input group permission value in case
+ * group name is found within allowed or disallowed groups lists
+ * Also collects matched groups names to separate collection for futher
+ * processing
+ */
+struct ConsentsUpdater
+    : public std::unary_function<void, policy::FunctionalGroupPermission&> {
+  ConsentsUpdater(const policy::GroupsNames& allowed,
+                  const policy::GroupsNames& disallowed,
+                  std::vector<policy::FunctionalGroupPermission>&
+                      out_external_consent_matches)
+      : allowed_(allowed)
+      , disallowed_(disallowed)
+      , out_external_consent_matches_(out_external_consent_matches) {}
+
+  void operator()(policy::FunctionalGroupPermission& value) {
+    if (helpers::in_range(disallowed_, value.group_name)) {
+      value.state = policy::kGroupDisallowed;
+      out_external_consent_matches_.push_back(value);
+      return;
+    }
+
+    if (helpers::in_range(allowed_, value.group_name)) {
+      value.state = policy::kGroupAllowed;
+      out_external_consent_matches_.push_back(value);
+    }
+  }
+
+ private:
+  const policy::GroupsNames& allowed_;
+  const policy::GroupsNames& disallowed_;
+  std::vector<policy::FunctionalGroupPermission>& out_external_consent_matches_;
+};
+
+/**
+ * @brief Checks whether ExternalConsent entity status is the same as name of
+ * group
+ * container where entity has been found in. In case of match group is added to
+ * 'disallowed' list, otherwise - to 'allowed' one.
+ * E.g. if entity has "ON" status and is found in
+ * 'disallowed_by_external_consent_entities_on' it will be added to
+ * 'disallowed'. If it has
+ * been found in 'disallowed_by_external_consent_entities_off' than group is
+ * added to
+ * 'allowed' list.
+ */
+struct GroupChecker
+    : std::unary_function<
+          void,
+          policy::GroupsByExternalConsentStatus::mapped_type::value_type> {
+  GroupChecker(const policy::EntityStatus entity_status,
+               policy::GroupsNames& out_allowed,
+               policy::GroupsNames& out_disallowed)
+      : entity_status_(entity_status)
+      , out_allowed_(out_allowed)
+      , out_disallowed_(out_disallowed) {}
+
+  void operator()(
+      const policy::GroupsByExternalConsentStatus::mapped_type::value_type
+          value) {
+    using namespace policy;
+
+    const std::string group_name = value.first;
+
+    if ((value.second && (kStatusOn == entity_status_)) ||
+        (!value.second && (kStatusOff == entity_status_))) {
+      out_disallowed_.insert(group_name);
+    } else {
+      out_allowed_.insert(group_name);
+    }
+  }
+
+ private:
+  const policy::EntityStatus entity_status_;
+  policy::GroupsNames& out_allowed_;
+  policy::GroupsNames& out_disallowed_;
+};
+
+/**
+ * @brief Sorts groups for 'allowed' and 'disallowed' by ExternalConsent
+ * entities statuses.
+ * Wraps GroupChecker logic.
+ */
+struct GroupSorter
+    : std::unary_function<
+          void,
+          const policy::GroupsByExternalConsentStatus::value_type&> {
+  GroupSorter(policy::GroupsNames& out_allowed,
+              policy::GroupsNames& out_disallowed)
+      : out_allowed_(out_allowed), out_disallowed_(out_disallowed) {}
+
+  void operator()(
+      const policy::GroupsByExternalConsentStatus::value_type& value) {
+    GroupChecker checker(value.first.status_, out_allowed_, out_disallowed_);
+    std::for_each(value.second.begin(), value.second.end(), checker);
+  }
+
+ private:
+  policy::GroupsNames& out_allowed_;
+  policy::GroupsNames& out_disallowed_;
+};
+
+}  // namespace
+
 namespace policy {
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Policy")
@@ -706,24 +829,38 @@ void PolicyManagerImpl::CheckPendingPermissionsChanges(
 void PolicyManagerImpl::SetUserConsentForApp(
     const PermissionConsent& permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
+
+  if (permissions.group_permissions.empty()) {
+    LOG4CXX_DEBUG(logger_, "Permissions list is empty, skipping update.");
+    return;
+  }
+
   cache_->ResetCalculatedPermissions();
   PermissionConsent verified_permissions =
       EnsureCorrectPermissionConsent(permissions);
 
-  if (!cache_->SetUserPermissionsForApp(verified_permissions)) {
+  bool app_permissions_changed = false;
+  if (!cache_->SetUserPermissionsForApp(verified_permissions,
+                                        &app_permissions_changed)) {
     LOG4CXX_WARN(logger_, "Can't set user permissions for application.");
   }
 
-  // Send OnPermissionChange notification, since consents were changed
-  std::vector<FunctionalGroupPermission> app_group_permissons;
+  if (!app_permissions_changed) {
+    LOG4CXX_WARN(logger_,
+                 "Application permissions were not changed, skipping "
+                 "permission change notification");
+    return;
+  }
+
+  std::vector<FunctionalGroupPermission> updated_app_group_permissons;
   GetPermissionsForApp(verified_permissions.device_id,
                        verified_permissions.policy_app_id,
-                       app_group_permissons);
+                       updated_app_group_permissons);
 
   // Change pending permissions isConsentNeeded state, if no unconsented
   // groups left
   CheckPendingPermissionsChanges(permissions.policy_app_id,
-                                 app_group_permissons);
+                                 updated_app_group_permissons);
 
   // Get current functional groups from DB with RPC permissions
   policy_table::FunctionalGroupings functional_groups;
@@ -732,17 +869,19 @@ void PolicyManagerImpl::SetUserConsentForApp(
   // Get list of groups assigned to application
   policy_table::Strings app_groups;
   std::vector<FunctionalGroupPermission>::const_iterator it =
-      app_group_permissons.begin();
+      updated_app_group_permissons.begin();
   std::vector<FunctionalGroupPermission>::const_iterator it_end =
-      app_group_permissons.end();
+      updated_app_group_permissons.end();
   for (; it != it_end; ++it) {
     app_groups.push_back((*it).group_name);
   }
 
   // Fill notification data according to group permissions
   Permissions notification_data;
-  PrepareNotificationData(
-      functional_groups, app_groups, app_group_permissons, notification_data);
+  PrepareNotificationData(functional_groups,
+                          app_groups,
+                          updated_app_group_permissons,
+                          notification_data);
 
   listener()->OnPermissionsUpdated(verified_permissions.policy_app_id,
                                    notification_data);
@@ -997,6 +1136,162 @@ const PolicySettings& PolicyManagerImpl::get_settings() const {
   return *settings_;
 }
 
+void PolicyManagerImpl::UpdateAppConsentWithExternalConsent(
+    const std::string& device_id,
+    const std::string& application_id,
+    const GroupsNames& allowed_groups,
+    const GroupsNames& disallowed_groups) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (allowed_groups.empty() && disallowed_groups.empty()) {
+    LOG4CXX_DEBUG(logger_,
+                  "Allowed and disallowed groups are empty, skipping update by "
+                  "external user consent.");
+    return;
+  }
+
+  std::vector<FunctionalGroupPermission> current_permissions;
+  GetUserConsentForApp(device_id, application_id, current_permissions);
+
+  std::vector<FunctionalGroupPermission> external_consent_groups_matches;
+  ConsentsUpdater updater(
+      allowed_groups, disallowed_groups, external_consent_groups_matches);
+  std::for_each(
+      current_permissions.begin(), current_permissions.end(), updater);
+
+  const std::string source = "GUI";
+
+  PermissionConsent updated_user_permissions;
+  updated_user_permissions.group_permissions = current_permissions;
+  updated_user_permissions.device_id = device_id;
+  updated_user_permissions.policy_app_id = application_id;
+  updated_user_permissions.consent_source = source;
+
+  // Need to check to which app to send notification since maybe app registered
+  // from different device
+  SetUserConsentForApp(updated_user_permissions);
+
+  PermissionConsent updated_external_consent_permissions;
+  updated_external_consent_permissions.group_permissions =
+      external_consent_groups_matches;
+  updated_external_consent_permissions.device_id = device_id;
+  updated_external_consent_permissions.policy_app_id = application_id;
+  updated_user_permissions.consent_source = source;
+
+  cache_->SetExternalConsentForApp(updated_external_consent_permissions);
+}
+
+void PolicyManagerImpl::NotifySystem(
+    const PolicyManagerImpl::AppPoliciesValueType& app_policy) const {
+  listener()->OnPendingPermissionChange(app_policy.first);
+}
+
+void PolicyManagerImpl::SendPermissionsToApp(
+    const PolicyManagerImpl::AppPoliciesValueType& app_policy) {
+  const std::string app_id = app_policy.first;
+
+  const std::string device_id = GetCurrentDeviceId(app_id);
+  if (device_id.empty()) {
+    LOG4CXX_WARN(logger_,
+                 "Couldn't find device info for application id: " << app_id);
+    return;
+  }
+  std::vector<FunctionalGroupPermission> group_permissons;
+  GetPermissionsForApp(device_id, app_id, group_permissons);
+
+  Permissions notification_data;
+
+  // Need to get rid of this call
+  utils::SharedPtr<policy_table::Table> policy_table_snapshot =
+      cache_->GenerateSnapshot();
+
+  PrepareNotificationData(
+      policy_table_snapshot->policy_table.functional_groupings,
+      app_policy.second.groups,
+      group_permissons,
+      notification_data);
+
+  LOG4CXX_INFO(logger_, "Send notification for application_id: " << app_id);
+  listener()->OnPermissionsUpdated(
+      app_id,
+      notification_data,
+      policy_table::EnumToJsonString(app_policy.second.default_hmi));
+}
+
+void PolicyManagerImpl::ProcessExternalConsentStatusUpdate(
+    const GroupsByExternalConsentStatus& groups_by_status) {
+  GroupsNames allowed_groups;
+  GroupsNames disallowed_groups;
+  CalculateGroupsConsentFromExternalConsent(
+      groups_by_status, allowed_groups, disallowed_groups);
+
+  std::map<std::string, std::string> known_links =
+      cache_->GetKnownLinksFromPT();
+  std::map<std::string, std::string> registered_links;
+  listener_->GetRegisteredLinks(registered_links);
+
+  std::map<std::string, std::string> all_known;
+  std::merge(known_links.begin(),
+             known_links.end(),
+             registered_links.begin(),
+             registered_links.end(),
+             std::inserter(all_known, all_known.begin()));
+
+  std::map<std::string, std::string>::const_iterator it_links =
+      all_known.begin();
+  for (; all_known.end() != it_links; ++it_links) {
+    UpdateAppConsentWithExternalConsent(
+        it_links->first, it_links->second, allowed_groups, disallowed_groups);
+  }
+}
+
+bool PolicyManagerImpl::SetExternalConsentStatus(
+    const ExternalConsentStatus& status) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (status.empty()) {
+    LOG4CXX_INFO(logger_, "External consent status is empty, skipping update.");
+    return false;
+  }
+
+  if (!cache_->SetExternalConsentStatus(status)) {
+    LOG4CXX_WARN(logger_, "Can't set external user consent status.");
+    return false;
+  }
+
+  GroupsByExternalConsentStatus groups_by_status =
+      cache_->GetGroupsWithSameEntities(status);
+  ProcessExternalConsentStatusUpdate(groups_by_status);
+
+  return true;
+}
+
+ExternalConsentStatus PolicyManagerImpl::GetExternalConsentStatus() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return cache_->GetExternalConsentStatus();
+}
+
+void PolicyManagerImpl::CalculateGroupsConsentFromExternalConsent(
+    const GroupsByExternalConsentStatus& groups_by_external_consent,
+    GroupsNames& out_allowed_groups,
+    GroupsNames& out_disallowed_groups) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  GroupSorter sorter(out_allowed_groups, out_disallowed_groups);
+  std::for_each(groups_by_external_consent.begin(),
+                groups_by_external_consent.end(),
+                sorter);
+
+  GroupsNames filtered_allowed_groups;
+  std::set_difference(
+      out_allowed_groups.begin(),
+      out_allowed_groups.end(),
+      out_disallowed_groups.begin(),
+      out_disallowed_groups.end(),
+      std::inserter(filtered_allowed_groups, filtered_allowed_groups.begin()));
+
+  out_allowed_groups = filtered_allowed_groups;
+}
+
 bool PolicyManagerImpl::ExceededDays() {
   LOG4CXX_AUTO_TRACE(logger_);
 
diff --git a/src/components/policy/policy_external/src/policy_table/types.cc b/src/components/policy/policy_external/src/policy_table/types.cc
index ade76399fc..85448e2677 100644
--- a/src/components/policy/policy_external/src/policy_table/types.cc
+++ b/src/components/policy/policy_external/src/policy_table/types.cc
@@ -271,7 +271,6 @@ bool ApplicationParams::is_valid() const {
   if (!heart_beat_timeout_ms.is_valid()) {
     return false;
   }
-
   return Validate();
 }
 
@@ -422,12 +421,22 @@ Rpcs::~Rpcs() {}
 Rpcs::Rpcs(const Json::Value* value__)
     : CompositeType(InitHelper(value__, &Json::Value::isObject))
     , user_consent_prompt(impl::ValueMember(value__, "user_consent_prompt"))
-    , rpcs(impl::ValueMember(value__, "rpcs")) {}
+    , rpcs(impl::ValueMember(value__, "rpcs"))
+    , disallowed_by_external_consent_entities_on(impl::ValueMember(
+          value__, "disallowed_by_external_consent_entities_on"))
+    , disallowed_by_external_consent_entities_off(impl::ValueMember(
+          value__, "disallowed_by_external_consent_entities_off")) {}
 
 Json::Value Rpcs::ToJsonValue() const {
   Json::Value result__(Json::objectValue);
   impl::WriteJsonField("user_consent_prompt", user_consent_prompt, &result__);
   impl::WriteJsonField("rpcs", rpcs, &result__);
+  impl::WriteJsonField("disallowed_by_external_consent_entities_on",
+                       disallowed_by_external_consent_entities_on,
+                       &result__);
+  impl::WriteJsonField("disallowed_by_external_consent_entities_off",
+                       disallowed_by_external_consent_entities_off,
+                       &result__);
   return result__;
 }
 
@@ -438,6 +447,12 @@ bool Rpcs::is_valid() const {
   if (!rpcs.is_valid()) {
     return false;
   }
+  if (!disallowed_by_external_consent_entities_on.is_valid()) {
+    return false;
+  }
+  if (!disallowed_by_external_consent_entities_off.is_valid()) {
+    return false;
+  }
   return Validate();
 }
 
@@ -452,7 +467,12 @@ bool Rpcs::struct_empty() const {
   if (rpcs.is_initialized()) {
     return false;
   }
-
+  if (disallowed_by_external_consent_entities_on.is_initialized()) {
+    return false;
+  }
+  if (disallowed_by_external_consent_entities_off.is_initialized()) {
+    return false;
+  }
   return true;
 }
 
@@ -467,12 +487,24 @@ void Rpcs::ReportErrors(rpc::ValidationReport* report__) const {
   if (!rpcs.is_valid()) {
     rpcs.ReportErrors(&report__->ReportSubobject("rpcs"));
   }
+  if (!disallowed_by_external_consent_entities_on.is_valid()) {
+    disallowed_by_external_consent_entities_on.ReportErrors(
+        &report__->ReportSubobject(
+            "disallowed_by_external_consent_entities_on"));
+  }
+  if (!disallowed_by_external_consent_entities_off.is_valid()) {
+    disallowed_by_external_consent_entities_off.ReportErrors(
+        &report__->ReportSubobject(
+            "disallowed_by_external_consent_entities_off"));
+  }
 }
 
 void Rpcs::SetPolicyTableType(PolicyTableType pt_type) {
   CompositeType::SetPolicyTableType(pt_type);
   user_consent_prompt.SetPolicyTableType(pt_type);
   rpcs.SetPolicyTableType(pt_type);
+  disallowed_by_external_consent_entities_off.SetPolicyTableType(pt_type);
+  disallowed_by_external_consent_entities_on.SetPolicyTableType(pt_type);
 }
 
 // ModuleConfig methods
@@ -655,7 +687,6 @@ bool ModuleConfig::struct_empty() const {
   if (vehicle_year.is_initialized()) {
     return false;
   }
-
   return true;
 }
 
@@ -705,35 +736,30 @@ void ModuleConfig::ReportErrors(rpc::ValidationReport* report__) const {
   if (!vehicle_year.is_valid()) {
     vehicle_year.ReportErrors(&report__->ReportSubobject("vehicle_year"));
   }
-
   const std::string validation_info =
       omitted_validation_info + PolicyTableTypeToString(GetPolicyTableType());
 
+  rpc::ValidationReport* omitted_field_report = NULL;
   switch (GetPolicyTableType()) {
     case PT_PRELOADED: {
       if (vehicle_make.is_initialized()) {
-        rpc::ValidationReport& vehicle_make_omitted_field_report =
-            report__->ReportSubobject("vehicle_make");
-        vehicle_make_omitted_field_report.set_validation_info(validation_info);
+        omitted_field_report = &report__->ReportSubobject("vehicle_make");
+        omitted_field_report->set_validation_info(validation_info);
       }
       if (vehicle_year.is_initialized()) {
-        rpc::ValidationReport& vehicle_year_omitted_field_report =
-            report__->ReportSubobject("vehicle_year");
-        vehicle_year_omitted_field_report.set_validation_info(validation_info);
+        omitted_field_report = &report__->ReportSubobject("vehicle_year");
+        omitted_field_report->set_validation_info(validation_info);
       }
       if (vehicle_model.is_initialized()) {
-        rpc::ValidationReport& vehicle_model_omitted_field_report =
-            report__->ReportSubobject("vehicle_model");
-        vehicle_model_omitted_field_report.set_validation_info(validation_info);
+        omitted_field_report = &report__->ReportSubobject("vehicle_model");
+        omitted_field_report->set_validation_info(validation_info);
       }
-
       break;
     }
     case PT_UPDATE: {
       if (preloaded_pt.is_initialized()) {
-        rpc::ValidationReport& preloaded_pt_omitted_field_report =
-            report__->ReportSubobject("preloaded_pt");
-        preloaded_pt_omitted_field_report.set_validation_info(validation_info);
+        omitted_field_report = &report__->ReportSubobject("preloaded_pt");
+        omitted_field_report->set_validation_info(validation_info);
       }
       if (preloaded_date.is_initialized()) {
         rpc::ValidationReport& preloaded_pt_omitted_field_report =
@@ -984,6 +1010,9 @@ void ConsumerFriendlyMessages::ReportErrors(
   if (struct_empty()) {
     rpc::CompositeType::ReportErrors(report__);
   }
+  if (!version.is_valid()) {
+    version.ReportErrors(&report__->ReportSubobject("version"));
+  }
   if (PT_SNAPSHOT == GetPolicyTableType()) {
     if (messages.is_initialized()) {
       std::string validation_info =
@@ -993,9 +1022,6 @@ void ConsumerFriendlyMessages::ReportErrors(
           .set_validation_info(validation_info);
     }
   }
-  if (!version.is_valid()) {
-    version.ReportErrors(&report__->ReportSubobject("version"));
-  }
   if (!messages.is_valid()) {
     messages.ReportErrors(&report__->ReportSubobject("messages"));
   }
@@ -1564,12 +1590,17 @@ ConsentRecords::~ConsentRecords() {}
 ConsentRecords::ConsentRecords(const Json::Value* value__)
     : CompositeType(InitHelper(value__, &Json::Value::isObject))
     , consent_groups(impl::ValueMember(value__, "consent_groups"))
+    , external_consent_status_groups(
+          impl::ValueMember(value__, "external_consent_status_groups"))
     , input(impl::ValueMember(value__, "input"))
     , time_stamp(impl::ValueMember(value__, "time_stamp")) {}
 
 Json::Value ConsentRecords::ToJsonValue() const {
   Json::Value result__(Json::objectValue);
   impl::WriteJsonField("consent_groups", consent_groups, &result__);
+  impl::WriteJsonField("external_consent_status_groups",
+                       external_consent_status_groups,
+                       &result__);
   impl::WriteJsonField("input", input, &result__);
   impl::WriteJsonField("time_stamp", time_stamp, &result__);
   return result__;
@@ -1582,6 +1613,9 @@ bool ConsentRecords::is_valid() const {
   if (!consent_groups.is_valid()) {
     return false;
   }
+  if (!external_consent_status_groups.is_valid()) {
+    return false;
+  }
   if (!input.is_valid()) {
     return false;
   }
@@ -1599,6 +1633,10 @@ bool ConsentRecords::struct_empty() const {
   if (consent_groups.is_initialized()) {
     return false;
   }
+
+  if (external_consent_status_groups.is_initialized()) {
+    return false;
+  }
   if (input.is_initialized()) {
     return false;
   }
@@ -1606,6 +1644,7 @@ bool ConsentRecords::struct_empty() const {
   if (time_stamp.is_initialized()) {
     return false;
   }
+
   return true;
 }
 
@@ -1616,6 +1655,10 @@ void ConsentRecords::ReportErrors(rpc::ValidationReport* report__) const {
   if (!consent_groups.is_valid()) {
     consent_groups.ReportErrors(&report__->ReportSubobject("consent_groups"));
   }
+  if (!consent_groups.is_valid()) {
+    external_consent_status_groups.ReportErrors(
+        &report__->ReportSubobject("external_consent_status_groups"));
+  }
   if (!input.is_valid()) {
     input.ReportErrors(&report__->ReportSubobject("input"));
   }
@@ -1627,6 +1670,7 @@ void ConsentRecords::ReportErrors(rpc::ValidationReport* report__) const {
 void ConsentRecords::SetPolicyTableType(PolicyTableType pt_type) {
   CompositeType::SetPolicyTableType(pt_type);
   consent_groups.SetPolicyTableType(pt_type);
+  external_consent_status_groups.SetPolicyTableType(pt_type);
   input.SetPolicyTableType(pt_type);
   time_stamp.SetPolicyTableType(pt_type);
 }
@@ -2023,5 +2067,60 @@ bool RequestTypes::is_cleaned_up() const {
   return is_cleaned_up_;
 }
 
+ExternalConsentEntity::ExternalConsentEntity()
+    : CompositeType(kUninitialized)
+    , entity_type(INT32_MAX)
+    , entity_id(INT32_MAX) {}
+
+ExternalConsentEntity::ExternalConsentEntity(const Json::Value* value__)
+    : CompositeType(InitHelper(value__, &Json::Value::isObject))
+    , entity_type(impl::ValueMember(value__, "entityType"))
+    , entity_id(impl::ValueMember(value__, "entityID")) {}
+
+ExternalConsentEntity::ExternalConsentEntity(const int32_t type,
+                                             const int32_t id)
+    : CompositeType(kUninitialized), entity_type(type), entity_id(id) {}
+
+Json::Value ExternalConsentEntity::ToJsonValue() const {
+  Json::Value result__(Json::objectValue);
+  impl::WriteJsonField("entityType", entity_type, &result__);
+  impl::WriteJsonField("entityID", entity_id, &result__);
+  return result__;
+}
+
+bool ExternalConsentEntity::operator==(const ExternalConsentEntity& rhs) const {
+  return rhs.entity_id == this->entity_id &&
+         rhs.entity_type == this->entity_type;
+}
+
+bool ExternalConsentEntity::is_valid() const {
+  if (!entity_type.is_valid()) {
+    return false;
+  }
+  if (!entity_id.is_valid()) {
+    return false;
+  }
+  return true;
+}
+
+bool ExternalConsentEntity::is_initialized() const {
+  return kInitialized == initialization_state__;
+}
+
+void ExternalConsentEntity::ReportErrors(ValidationReport* report__) const {
+  if (!entity_type.is_valid()) {
+    entity_type.ReportErrors(&report__->ReportSubobject("entityType"));
+  }
+  if (!entity_id.is_valid()) {
+    entity_id.ReportErrors(&report__->ReportSubobject("entityID"));
+  }
+}
+
+void ExternalConsentEntity::SetPolicyTableType(PolicyTableType pt_type) {
+  CompositeType::SetPolicyTableType(pt_type);
+  entity_type.SetPolicyTableType(pt_type);
+  entity_id.SetPolicyTableType(pt_type);
+}
+
 }  // namespace policy_table_interface_base
 }  // namespace rpc
diff --git a/src/components/policy/policy_external/src/policy_table/validation.cc b/src/components/policy/policy_external/src/policy_table/validation.cc
index 8852070a91..505b9b294f 100644
--- a/src/components/policy/policy_external/src/policy_table/validation.cc
+++ b/src/components/policy/policy_external/src/policy_table/validation.cc
@@ -209,6 +209,10 @@ bool UsageAndErrorCounts::Validate() const {
   return true;
 }
 bool ConsentRecords::Validate() const {
+  if (PT_SNAPSHOT != GetPolicyTableType()) {
+    return !external_consent_status_groups->is_initialized();
+  }
+
   return true;
 }
 bool DeviceParams::Validate() const {
diff --git a/src/components/policy/policy_external/src/sql_pt_ext_queries.cc b/src/components/policy/policy_external/src/sql_pt_ext_queries.cc
index 4a69aaf44f..f0cd32dc02 100644
--- a/src/components/policy/policy_external/src/sql_pt_ext_queries.cc
+++ b/src/components/policy/policy_external/src/sql_pt_ext_queries.cc
@@ -85,6 +85,9 @@ const std::string kSelectDeviceData = "SELECT * FROM `device`";
 const std::string kSelectConsentGroup =
     "SELECT * FROM `consent_group` WHERE `device_id` = ? ";
 
+const std::string kSelectExternalConsentStatusGroup =
+    "SELECT * FROM `external_consent_status_group` WHERE `device_id` = ? ";
+
 const std::string kInsertPreconsentedGroups =
     "INSERT INTO `preconsented_group` (`application_id`, `functional_group_id`)"
     "  SELECT ?, `id` FROM `functional_group` WHERE `name` = ? LIMIT 1";
@@ -136,6 +139,12 @@ const std::string kInsertConsentGroups =
     "`input`, `time_stamp`) "
     "VALUES (?,?,?,?,?,?)";
 
+const std::string kInsertExternalConsentStatusGroups =
+    "INSERT OR REPLACE INTO `external_consent_status_group` "
+    "(`device_id`, `application_id`, `functional_group_id`, `is_consented`, "
+    "`input`, `time_stamp`) "
+    "VALUES (?,?,?,?,?,?)";
+
 const std::string kDeleteAppGroupConsent =
     "DELETE FROM `consent_group` WHERE "
     "`application_id` = ? AND `functional_group_id` = ? ";
@@ -263,5 +272,28 @@ const std::string kHasMsgLanguageCode =
 const std::string kDeletePreconsentedGroupsByApplicationId =
     "DELETE FROM `preconsented_group` WHERE `application_id` = ?";
 
+const std::string kSelectExternalConsentStatus =
+    "SELECT `entity_type`, `entity_id`, `on_off` from "
+    "`_internal_external_consent_status`";
+
+const std::string kInsertExternalConsentStatus =
+    "INSERT OR REPLACE INTO `_internal_external_consent_status` "
+    "(`id`,`entity_type`, "
+    "`entity_id`, `on_off`) VALUES ((SELECT `id` from "
+    "`_internal_external_consent_status` "
+    "WHERE `entity_type` = ? AND `entity_id` = ?), ?, ?, ?)";
+
+const std::string kDeleteExternalConsentEntities =
+    "DELETE FROM `external_consent_entities`";
+
+const std::string kInsertExternalConsentEntity =
+    "INSERT INTO `external_consent_entities` (`group_id`, `entity_type`, "
+    "`entity_id`, `on_off`) "
+    "  VALUES (?, ?, ?, ?)";
+
+const std::string kSelectExternalConsentEntity =
+    "SELECT `group_id`, `entity_type`, `entity_id`, `on_off` from "
+    "`external_consent_entities`";
+
 }  // namespace sql_pt_ext
 }  // namespace policy
diff --git a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
index dda00af168..edc2fa14a9 100644
--- a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
@@ -1803,4 +1803,56 @@ bool SQLPTExtRepresentation::RemoveAppConsentForGroup(
   return true;
 }
 
+bool SQLPTExtRepresentation::SaveExternalConsentStatus(
+    const ExternalConsentStatus& status) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt_ext::kInsertExternalConsentStatus)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrect statement for saving external consent status.");
+    return false;
+  }
+
+  ExternalConsentStatus::const_iterator it = status.begin();
+  ExternalConsentStatus::const_iterator end = status.end();
+  for (; end != it; ++it) {
+    query.Bind(0, static_cast<int>(it->entity_type_));
+    query.Bind(1, static_cast<int>(it->entity_id_));
+    // Due to query structure need to provide that twice
+    query.Bind(2, static_cast<int>(it->entity_type_));
+    query.Bind(3, static_cast<int>(it->entity_id_));
+    query.Bind(4,
+               policy::kStatusOn == it->status_ ? std::string("ON")
+                                                : std::string("OFF"));
+    if (!query.Exec() || !query.Reset()) {
+      LOG4CXX_ERROR(logger_, "Error during ExternalConsent status saving.");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+ExternalConsentStatus SQLPTExtRepresentation::GetExternalConsentStatus() const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt_ext::kSelectExternalConsentStatus)) {
+    LOG4CXX_ERROR(logger_,
+                  "Incorrect statement for selecting external consent status.");
+    return ExternalConsentStatus();
+  }
+
+  ExternalConsentStatus status;
+  while (query.Next()) {
+    const policy::EntityStatus on_off =
+        query.GetString(2) == "ON" ? policy::kStatusOn : policy::kStatusOff;
+    ExternalConsentStatusItem item(static_cast<uint32_t>(query.GetInteger(0)),
+                                   static_cast<uint32_t>(query.GetInteger(1)),
+                                   on_off);
+    status.insert(item);
+  }
+
+  return status;
+}
+
 }  // namespace policy
diff --git a/src/components/policy/policy_external/src/sql_pt_queries.cc b/src/components/policy/policy_external/src/sql_pt_queries.cc
index f40b31f83a..1b514dff52 100644
--- a/src/components/policy/policy_external/src/sql_pt_queries.cc
+++ b/src/components/policy/policy_external/src/sql_pt_queries.cc
@@ -83,6 +83,15 @@ const std::string kCreateSchema =
     "  `user_consent_prompt` TEXT, "
     "  `name` VARCHAR(100) NOT NULL "
     "); "
+    "CREATE TABLE IF NOT EXISTS `external_consent_entities`( "
+    "  `group_id` INTEGER NOT NULL, "
+    "  `entity_type` INTEGER NOT NULL, "
+    "  `entity_id` INTEGER NOT NULL, "
+    "  `on_off` TEXT NOT NULL, "
+    "  CONSTRAINT `fk_external_consent_entities_group_id` "
+    "    FOREIGN KEY(`group_id`) "
+    "    REFERENCES `functional_group`(`id`) "
+    "); "
     "CREATE TABLE IF NOT EXISTS `priority`( "
     "  `value` VARCHAR(45) PRIMARY KEY NOT NULL "
     "); "
@@ -288,6 +297,24 @@ const std::string kCreateSchema =
     "    FOREIGN KEY(`functional_group_id`) "
     "    REFERENCES `functional_group`(`id`) "
     "); "
+    "CREATE TABLE IF NOT EXISTS `external_consent_status_group`( "
+    "  `device_id` VARCHAR(100) NOT NULL, "
+    "  `application_id` VARCHAR(45) NOT NULL, "
+    "  `functional_group_id` INTEGER NOT NULL, "
+    "  `is_consented` BOOL NOT NULL, "
+    "  `input` VARCHAR(45), "
+    "  `time_stamp` VARCHAR(45), "
+    "  PRIMARY KEY(`application_id`,`functional_group_id`,`device_id`), "
+    "  CONSTRAINT `fk_external_consent_status_group_device1` "
+    "    FOREIGN KEY(`device_id`) "
+    "    REFERENCES `device`(`id`), "
+    "  CONSTRAINT `fk_external_consent_status_group_application1` "
+    "    FOREIGN KEY(`application_id`) "
+    "    REFERENCES `application`(`id`), "
+    "  CONSTRAINT `fk_external_consent_status_group_functional_group1` "
+    "    FOREIGN KEY(`functional_group_id`) "
+    "    REFERENCES `functional_group`(`id`) "
+    "); "
     "CREATE INDEX IF NOT EXISTS "
     "`consent_group.fk_consent_group_device1_idx` "
     "  ON `device_consent_group`(`device_id`); "
@@ -369,6 +396,8 @@ const std::string kDropSchema =
     "DROP INDEX IF EXISTS "
     "`consent_group.fk_consent_group_functional_group1_idx`; "
     "DROP TABLE IF EXISTS `consent_group`; "
+    "DROP TABLE IF EXISTS `external_consent_status_group`; "
+    "DROP TABLE IF EXISTS `external_consent_entities`; "
     "DROP INDEX IF EXISTS `app_type.fk_app_type_application1_idx`; "
     "DROP TABLE IF EXISTS `app_type`; "
     "DROP TABLE IF EXISTS `request_type`; "
@@ -426,6 +455,8 @@ const std::string kDeleteData =
     "DELETE FROM `message`; "
     "DELETE FROM `endpoint`; "
     "DELETE FROM `consent_group`; "
+    "DELETE FROM `external_consent_status_group`; "
+    "DELETE FROM `external_consent_entities`; "
     "DELETE FROM `app_type`; "
     "DELETE FROM `nickname`; "
     "DELETE FROM `app_level`; "
@@ -487,6 +518,11 @@ const std::string kInsertRpc =
     "INSERT INTO `rpc` (`name`, `hmi_level_value`, `functional_group_id`) "
     "  VALUES (?, ?, ?)";
 
+const std::string kInsertExternalConsentEntity =
+    "INSERT INTO `external_consent_entities` (`group_id`, `entity_type`, "
+    "`entity_id`, `on_off`) "
+    "  VALUES (?, ?, ?, ?)";
+
 const std::string kInsertRpcWithParameter =
     "INSERT INTO `rpc` (`name`, `hmi_level_value`, `parameter`, "
     "`functional_group_id`) "
@@ -571,6 +607,9 @@ const std::string kDeleteFunctionalGroup = "DELETE FROM `functional_group`";
 
 const std::string kDeleteRpc = "DELETE FROM `rpc`";
 
+const std::string kDeleteExternalConsentEntities =
+    "DELETE FROM `external_consent_entities`";
+
 const std::string kDeleteAppGroup = "DELETE FROM `app_group`";
 
 const std::string kSelectModuleConfig =
@@ -601,6 +640,10 @@ const std::string kSelectAllRpcs =
     "SELECT `name`, `hmi_level_value`, `parameter` "
     "FROM `rpc` WHERE `functional_group_id` = ? ";
 
+const std::string kSelectExternalConsentEntities =
+    "SELECT `entity_type`, `entity_id`, `on_off` "
+    "FROM `external_consent_entities` WHERE `group_id` = ? ";
+
 const std::string kSelectUserMsgsVersion =
     "SELECT DISTINCT `number` FROM `version`";
 
diff --git a/src/components/policy/policy_external/src/sql_pt_representation.cc b/src/components/policy/policy_external/src/sql_pt_representation.cc
index 1e02685805..e91fafc43d 100644
--- a/src/components/policy/policy_external/src/sql_pt_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_representation.cc
@@ -69,6 +69,10 @@ const char* kDatabaseName = "policy.db";
 #else   // CUSTOMER_PASA
 const char* kDatabaseName = "policy";
 #endif  // CUSTOMER_PASA
+
+const std::string kExternalConsentEntitiesTypeStringOn = "ON";
+const std::string kExternalConsentEntitiesTypeStringOff = "OFF";
+
 }  // namespace
 
 SQLPTRepresentation::SQLPTRepresentation()
@@ -617,19 +621,32 @@ bool SQLPTRepresentation::GatherFunctionalGroupings(
     LOG4CXX_WARN(logger_, "Incorrect select from functional_groupings");
     return false;
   }
+
   utils::dbms::SQLQuery rpcs(db());
   if (!rpcs.Prepare(sql_pt::kSelectAllRpcs)) {
     LOG4CXX_WARN(logger_, "Incorrect select all from rpc");
     return false;
   }
 
+  utils::dbms::SQLQuery external_consent_entities(db());
+  if (!external_consent_entities.Prepare(
+          sql_pt::kSelectExternalConsentEntities)) {
+    LOG4CXX_WARN(logger_,
+                 "Incorrect select statement for 'external_consent_entities'.");
+    return false;
+  }
+
   while (func_group.Next()) {
     policy_table::Rpcs rpcs_tbl;
+
     if (!func_group.IsNull(2)) {
       *rpcs_tbl.user_consent_prompt = func_group.GetString(2);
     }
-    int func_id = func_group.GetInteger(0);
-    rpcs.Bind(0, func_id);
+
+    const int group_id = func_group.GetInteger(0);
+
+    rpcs.Bind(0, group_id);
+
     while (rpcs.Next()) {
       if (!rpcs.IsNull(1)) {
         policy_table::HmiLevel level;
@@ -650,10 +667,30 @@ bool SQLPTRepresentation::GatherFunctionalGroupings(
         }
       }
     }
+
+    rpcs.Reset();
+
     if (!rpcs_tbl.rpcs.is_initialized()) {
       rpcs_tbl.rpcs.set_to_null();
     }
-    rpcs.Reset();
+
+    // Collecting entities for disallowed_by_external_consent_entities_on/off
+    external_consent_entities.Bind(0, group_id);
+    while (external_consent_entities.Next()) {
+      policy_table::ExternalConsentEntity external_consent_entity(
+          external_consent_entities.GetInteger(0),
+          external_consent_entities.GetInteger(1));
+
+      policy_table::DisallowedByExternalConsentEntities&
+          external_consent_entities_container =
+              kExternalConsentEntitiesTypeStringOn ==
+                      external_consent_entities.GetString(2)
+                  ? *rpcs_tbl.disallowed_by_external_consent_entities_on
+                  : *rpcs_tbl.disallowed_by_external_consent_entities_off;
+
+      external_consent_entities_container.push_back(external_consent_entity);
+    }
+
     (*groups)[func_group.GetString(1)] = rpcs_tbl;
   }
   return true;
@@ -772,32 +809,38 @@ bool SQLPTRepresentation::SaveFunctionalGroupings(
     return false;
   }
 
+  if (!query_delete.Exec(sql_pt::kDeleteExternalConsentEntities)) {
+    LOG4CXX_WARN(logger_, "Incorrect delete from external consent entities.");
+    return false;
+  }
+
   utils::dbms::SQLQuery query(db());
   if (!query.Exec(sql_pt::kDeleteFunctionalGroup)) {
     LOG4CXX_WARN(logger_, "Incorrect delete from seconds between retries.");
     return false;
   }
+
   if (!query.Prepare(sql_pt::kInsertFunctionalGroup)) {
     LOG4CXX_WARN(logger_, "Incorrect insert statement for functional groups");
     return false;
   }
 
-  policy_table::FunctionalGroupings::const_iterator it;
+  policy_table::FunctionalGroupings::const_iterator groups_it;
 
-  for (it = groups.begin(); it != groups.end(); ++it) {
+  for (groups_it = groups.begin(); groups_it != groups.end(); ++groups_it) {
     // Since we uses this id in other tables, we have to be sure
     // that id for certain group will be same in case when
     // we drop records from the table and add them again.
     // That's why we use hash as a primary key insted of
     // simple auto incremental index.
-    const long int id = abs(utils::Djb2HashFromString(it->first));
+    const long int id = abs(utils::Djb2HashFromString(groups_it->first));
     // SQLite's Bind doesn support 'long' type
     // So we need to explicitly cast it to int64_t
     // to avoid ambiguity.
     query.Bind(0, static_cast<int64_t>(id));
-    query.Bind(1, it->first);
-    it->second.user_consent_prompt.is_initialized()
-        ? query.Bind(2, *(it->second.user_consent_prompt))
+    query.Bind(1, groups_it->first);
+    groups_it->second.user_consent_prompt.is_initialized()
+        ? query.Bind(2, *(groups_it->second.user_consent_prompt))
         : query.Bind(2);
 
     if (!query.Exec() || !query.Reset()) {
@@ -805,10 +848,27 @@ bool SQLPTRepresentation::SaveFunctionalGroupings(
       return false;
     }
 
-    if (!SaveRpcs(query.LastInsertId(), it->second.rpcs)) {
+    const int64_t last_group_id = query.LastInsertId();
+
+    if (!SaveRpcs(last_group_id, groups_it->second.rpcs)) {
+      return false;
+    }
+
+    if (!SaveExternalConsentEntities(
+            last_group_id,
+            *groups_it->second.disallowed_by_external_consent_entities_on,
+            kExternalConsentEntitiesTypeOn)) {
+      return false;
+    }
+
+    if (!SaveExternalConsentEntities(
+            last_group_id,
+            *groups_it->second.disallowed_by_external_consent_entities_off,
+            kExternalConsentEntitiesTypeOff)) {
       return false;
     }
   }
+
   return true;
 }
 
@@ -870,6 +930,40 @@ bool SQLPTRepresentation::SaveRpcs(int64_t group_id,
   return true;
 }
 
+bool SQLPTRepresentation::SaveExternalConsentEntities(
+    const int64_t group_id,
+    const policy_table::DisallowedByExternalConsentEntities& entities,
+    ExternalConsentEntitiesType type) const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kInsertExternalConsentEntity)) {
+    LOG4CXX_WARN(logger_,
+                 "Incorrect insert statement for external consent entities.");
+    return false;
+  }
+
+  const std::string external_consent_entity_type =
+      kExternalConsentEntitiesTypeOn == type
+          ? kExternalConsentEntitiesTypeStringOn
+          : kExternalConsentEntitiesTypeStringOff;
+
+  policy_table::DisallowedByExternalConsentEntities::const_iterator it_entity =
+      entities.begin();
+  for (; entities.end() != it_entity; ++it_entity) {
+    query.Bind(0, group_id);
+    query.Bind(1, it_entity->entity_type);
+    query.Bind(2, it_entity->entity_id);
+    query.Bind(3, external_consent_entity_type);
+    if (!query.Exec() || !query.Reset()) {
+      LOG4CXX_ERROR(logger_,
+                    "Can't insert '" << external_consent_entity_type
+                                     << "' external consent entity.");
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool SQLPTRepresentation::SaveApplicationPoliciesSection(
     const policy_table::ApplicationPoliciesSection& policies) {
   utils::dbms::SQLQuery query_delete(db());
diff --git a/src/components/policy/policy_external/test/include/policy/mock_cache_manager.h b/src/components/policy/policy_external/test/include/policy/mock_cache_manager.h
index 7d37260ef7..93583822ae 100644
--- a/src/components/policy/policy_external/test/include/policy/mock_cache_manager.h
+++ b/src/components/policy/policy_external/test/include/policy/mock_cache_manager.h
@@ -156,8 +156,9 @@ class MockCacheManagerInterface : public ::policy::CacheManagerInterface {
                     const StringArray& disallowed_groups));
   MOCK_METHOD2(ReactOnUserDevConsentForApp,
                bool(const std::string& app_id, bool is_device_allowed));
-  MOCK_METHOD1(SetUserPermissionsForApp,
-               bool(const PermissionConsent& permissions));
+  MOCK_METHOD2(SetUserPermissionsForApp,
+               bool(const PermissionConsent& permissions,
+                    bool* out_app_permissions_changed));
   MOCK_METHOD3(SetMetaInfo,
                bool(const std::string& ccpu_version,
                     const std::string& wers_country_code,
@@ -232,6 +233,16 @@ class MockCacheManagerInterface : public ::policy::CacheManagerInterface {
   MOCK_CONST_METHOD0(GetCertificate, std::string());
   MOCK_METHOD1(SetDecryptedCertificate, void(const std::string&));
   MOCK_METHOD1(set_settings, void(const PolicySettings* settings));
+  MOCK_METHOD1(GetHMITypes,
+               const policy_table::AppHMITypes*(const std::string& app_id));
+  MOCK_METHOD1(GetGroups, const policy_table::Strings&(const PTString& app_id));
+
+  MOCK_METHOD1(SetExternalConsentStatus, bool(const ExternalConsentStatus&));
+  MOCK_METHOD0(GetExternalConsentStatus, ExternalConsentStatus());
+  MOCK_METHOD1(GetGroupsWithSameEntities,
+               GroupsByExternalConsentStatus(const ExternalConsentStatus&));
+  MOCK_METHOD0(GetKnownLinksFromPT, std::map<std::string, std::string>());
+  MOCK_METHOD1(SetExternalConsentForApp, void(const PermissionConsent&));
 };
 
 }  // namespace policy_test
diff --git a/src/components/policy/policy_external/test/include/policy/mock_pt_ext_representation.h b/src/components/policy/policy_external/test/include/policy/mock_pt_ext_representation.h
index 2dda69bd73..3225e79e01 100644
--- a/src/components/policy/policy_external/test/include/policy/mock_pt_ext_representation.h
+++ b/src/components/policy/policy_external/test/include/policy/mock_pt_ext_representation.h
@@ -137,6 +137,9 @@ class MockPTExtRepresentation : public MockPTRepresentation,
   MOCK_CONST_METHOD2(RemoveAppConsentForGroup,
                      bool(const std::string& policy_app_id,
                           const std::string& functional_group));
+  MOCK_CONST_METHOD1(SaveExternalConsentStatus,
+                     bool(const ExternalConsentStatus&));
+  MOCK_CONST_METHOD0(GetExternalConsentStatus, ExternalConsentStatus());
 };
 
 }  // namespace policy_test
diff --git a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
index e0fc308cbc..0d2cc19db4 100644
--- a/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
+++ b/src/components/policy/policy_external/test/include/policy/policy_manager_impl_test_base.h
@@ -108,7 +108,7 @@ class PolicyManagerImplTest : public ::testing::Test {
  protected:
   const std::string unpaired_device_id_;
 
-  PolicyManagerImpl* manager_;
+  PolicyManagerImpl* policy_manager_;
   MockCacheManagerInterface* cache_manager_;
   MockUpdateStatusManager update_manager_;
   NiceMock<MockPolicyListener> listener_;
@@ -135,7 +135,7 @@ class PolicyManagerImplTest2 : public ::testing::Test {
   const std::string preloadet_pt_filename_;
   const bool in_memory_;
 
-  PolicyManagerImpl* manager_;
+  PolicyManagerImpl* policy_manager_;
   NiceMock<MockPolicyListener> listener_;
   ::policy::StringArray hmi_level_;
   ::policy::StringArray pt_request_types_;
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
index aa5245825b..5983f3c7c8 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
@@ -52,74 +52,74 @@ using ::testing::Return;
 using ::testing::ReturnRef;
 
 TEST_F(PolicyManagerImplTest,
-       TiggerPTUForNaviAppInCaseNoCertificateExistsInPolicyTable) {
+       DISABLED_TiggerPTUForNaviAppInCaseNoCertificateExistsInPolicyTable) {
   EXPECT_CALL(*cache_manager_, GetDeviceConsent(_))
       .WillOnce(Return(kDeviceAllowed));
-  EXPECT_CALL(*cache_manager_, IsPredataPolicy(_)).WillOnce(Return(false));
-  EXPECT_CALL(*cache_manager_, IsApplicationRepresented(_))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*cache_manager_, GetCertificate()).WillOnce(Return(""));
-  EXPECT_CALL(*cache_manager_, AppHasHMIType(_, policy_table::AHT_NAVIGATION))
-      .WillOnce(Return(true));
-  EXPECT_EQ(manager_->GetPolicyTableStatus(), "UP_TO_DATE");
-  manager_->AddApplication(kDefaultId);
-  EXPECT_EQ(manager_->GetPolicyTableStatus(), "UPDATE_NEEDED");
-}
+  const uint32_t type = 0;
+  const uint32_t id = 1;
+  const EntityStatus status = kStatusOn;
+  ExternalConsentStatusItem item(type, id, status);
+
+  ExternalConsentStatus external_consent_status;
+  external_consent_status.insert(item);
+
+  GroupsByExternalConsentStatus group;
+  group[item].push_back(std::make_pair<std::string, bool>("group_name", true));
+
+  EXPECT_CALL(*cache_manager_, GetExternalConsentStatus())
+      .WillOnce(Return(external_consent_status));
+
+  EXPECT_CALL(*cache_manager_,
+              GetGroupsWithSameEntities(external_consent_status))
+      .WillOnce(Return(group));
+
+  EXPECT_CALL(*cache_manager_, SetExternalConsentForApp(_));
 
-TEST_F(PolicyManagerImplTest,
-       TiggerPTUForNaviAppInCaseCertificateExistsInPolicyTable) {
-  EXPECT_CALL(*cache_manager_, GetDeviceConsent(_))
-      .WillOnce(Return(kDeviceAllowed));
   EXPECT_CALL(*cache_manager_, IsPredataPolicy(_)).WillOnce(Return(false));
   EXPECT_CALL(*cache_manager_, IsApplicationRepresented(_))
       .WillOnce(Return(true));
-  EXPECT_CALL(*cache_manager_, GetCertificate())
-      .WillOnce(Return(
-          "Any non empty string is ok here, "
-          "because we check that field is not empty"));
-
-  EXPECT_CALL(*cache_manager_, AppHasHMIType(_, policy_table::AHT_NAVIGATION))
-      .Times(0);
-  manager_->AddApplication(kDefaultId);
+  EXPECT_EQ(policy_manager_->GetPolicyTableStatus(), "UP_TO_DATE");
+  policy_manager_->AddApplication(kDefaultId);
+  EXPECT_EQ(policy_manager_->GetPolicyTableStatus(), "UP_TO_DATE");
 }
 
 TEST_F(PolicyManagerImplTest2, GetNotificationsNumberAfterPTUpdate) {
   // Arrange
 
   Json::Value table = createPTforLoad();
-  manager_->ForcePTExchange();
-  manager_->OnUpdateStarted();
+  policy_manager_->ForcePTExchange();
+  policy_manager_->OnUpdateStarted();
   policy_table::Table update(&table);
   update.SetPolicyTableType(rpc::policy_table_interface_base::PT_UPDATE);
   // Act
   std::string json = table.toStyledString();
   ::policy::BinaryMessage msg(json.begin(), json.end());
   EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 
   std::string priority = "emergency";
-  uint32_t notif_number = manager_->GetNotificationsNumber(priority);
+  uint32_t notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(1u, notif_number);
 
   priority = "navigation";
-  notif_number = manager_->GetNotificationsNumber(priority);
+  notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(2u, notif_number);
 
   priority = "emergency";
-  notif_number = manager_->GetNotificationsNumber(priority);
+  notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(1u, notif_number);
 
   priority = "VOICECOMM";
-  notif_number = manager_->GetNotificationsNumber(priority);
+  notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(3u, notif_number);
 
   priority = "normal";
-  notif_number = manager_->GetNotificationsNumber(priority);
+  notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(5u, notif_number);
 
   priority = "none";
-  notif_number = manager_->GetNotificationsNumber(priority);
+  notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(6u, notif_number);
 }
 
@@ -136,9 +136,9 @@ TEST_F(PolicyManagerImplTest2, IsAppRevoked_SetRevokedAppID_ExpectAppRevoked) {
   ifile.close();
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
-  EXPECT_TRUE(manager_->IsApplicationRevoked(app_id_1_));
+  ASSERT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+  EXPECT_TRUE(policy_manager_->IsApplicationRevoked(app_id_1_));
 }
 
 TEST_F(
@@ -179,7 +179,7 @@ TEST_F(PolicyManagerImplTest2,
        CheckPermissions_SetRevokedAppID_ExpectRPCDisallowed) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   cache->AddDevice(device_id_1_, "Bluetooth");
   cache->SetDeviceData(device_id_1_,
                        "hardware IPX",
@@ -191,9 +191,9 @@ TEST_F(PolicyManagerImplTest2,
                        "Bluetooth");
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
       .WillRepeatedly(Return(device_id_1_));
-  manager_->SetUserConsentForDevice(device_id_1_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(app_id_1_);
+  policy_manager_->AddApplication(app_id_1_);
   // Check before action
   policy_table::RpcParameters rpc_parameters;
   rpc_parameters.hmi_levels.push_back(policy_table::HL_FULL);
@@ -204,7 +204,7 @@ TEST_F(PolicyManagerImplTest2,
   ::policy::RPCParams input_params;
   ::policy::CheckPermissionResult output;
 
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       app_id_1_, kHmiLevelFull, "Alert", input_params, output);
 
   // Check RPC is allowed
@@ -222,10 +222,10 @@ TEST_F(PolicyManagerImplTest2,
   ifile.close();
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(cache->IsPTPreloaded());
 
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       app_id_1_, kHmiLevelFull, "Alert", input_params, output);
   // Check RPC is disallowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -236,8 +236,8 @@ TEST_F(PolicyManagerImplTest2,
        CheckPermissions_SetAppIDwithPolicies_ExpectRPCAllowed) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
 
   ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                    "hardware IPX",
@@ -249,9 +249,9 @@ TEST_F(PolicyManagerImplTest2,
                                    "Bluetooth"));
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(application_id_))
       .WillRepeatedly(Return(device_id_1_));
-  manager_->SetUserConsentForDevice(device_id_1_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(application_id_);
+  policy_manager_->AddApplication(application_id_);
   // Emulate PTU with new policies for app added above
   std::ifstream ifile(kValidSdlPtUpdateJson);
   Json::Reader reader;
@@ -289,7 +289,7 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
   // Load Json to cache
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   policy_table::RpcParameters rpc_parameters;
@@ -311,7 +311,7 @@ TEST_F(PolicyManagerImplTest2,
                        "Life",
                        2,
                        "Bluetooth");
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "Alert", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -334,7 +334,7 @@ TEST_F(PolicyManagerImplTest2,
   ::policy::RPCParams input_params;
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -344,7 +344,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -353,11 +353,11 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
   ASSERT_TRUE(output.list_of_allowed_params.empty());
@@ -365,7 +365,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
   // Check RPC is disallowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -392,7 +392,7 @@ TEST_F(
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
 
   // Group which has RPC does not require user consent, so its auto-allowed for
@@ -408,7 +408,7 @@ TEST_F(
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -420,11 +420,11 @@ TEST_F(
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
 
@@ -436,7 +436,7 @@ TEST_F(
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -467,7 +467,7 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -497,7 +497,7 @@ TEST_F(PolicyManagerImplTest2,
   output.list_of_undefined_params.clear();
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -516,11 +516,11 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
 
@@ -536,7 +536,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
   // Check RPC is disallowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -581,7 +581,7 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -601,7 +601,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -621,11 +621,11 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
   // Check list of allowed parameters is not empty
@@ -645,7 +645,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
   // Check RPC is disallowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -664,8 +664,8 @@ TEST_F(PolicyManagerImplTest2,
 
   // Arrange
   CreateLocalPT("json/sdl_preloaded_pt_send_location.json");
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                    "hardware IPX",
                                    "v.8.0.1",
@@ -676,7 +676,7 @@ TEST_F(PolicyManagerImplTest2,
                                    "Bluetooth"));
 
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(application_id_);
+  policy_manager_->AddApplication(application_id_);
 
   std::ifstream ifile("json/sdl_update_pt_2_groups_no_params_in1.json");
   Json::Reader reader;
@@ -688,7 +688,7 @@ TEST_F(PolicyManagerImplTest2,
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Will be called each time permissions are checked
@@ -702,7 +702,7 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -711,7 +711,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -720,11 +720,11 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
   EXPECT_TRUE(output.list_of_allowed_params.empty());
@@ -733,7 +733,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -750,8 +750,8 @@ TEST_F(PolicyManagerImplTest2,
 
   // Arrange
   CreateLocalPT("json/sdl_preloaded_pt_send_location.json");
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                    "hardware IPX",
                                    "v.8.0.1",
@@ -762,7 +762,7 @@ TEST_F(PolicyManagerImplTest2,
                                    "Bluetooth"));
 
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(application_id_);
+  policy_manager_->AddApplication(application_id_);
 
   std::ifstream ifile(
       "json/sdl_update_pt_2_groups_no_params_in1_omitted_in2.json");
@@ -775,7 +775,7 @@ TEST_F(PolicyManagerImplTest2,
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Will be called each time permissions are checked
@@ -789,7 +789,7 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
 
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -798,7 +798,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
   EXPECT_TRUE(output.list_of_allowed_params.empty());
@@ -806,11 +806,11 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
   EXPECT_TRUE(output.list_of_allowed_params.empty());
   EXPECT_EQ(10u, output.list_of_undefined_params.size());
@@ -818,7 +818,7 @@ TEST_F(PolicyManagerImplTest2,
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
   EXPECT_TRUE(output.list_of_allowed_params.empty());
@@ -828,8 +828,8 @@ TEST_F(PolicyManagerImplTest2,
 
 TEST_F(PolicyManagerImplTest, LoadPT_SetInvalidUpdatePT_PTIsNotLoaded) {
   // Arrange
-  manager_->ForcePTExchange();
-  manager_->OnUpdateStarted();
+  policy_manager_->ForcePTExchange();
+  policy_manager_->OnUpdateStarted();
   Json::Value table(Json::objectValue);
 
   policy_table::Table update(&table);
@@ -850,9 +850,9 @@ TEST_F(PolicyManagerImplTest, LoadPT_SetInvalidUpdatePT_PTIsNotLoaded) {
   EXPECT_CALL(*cache_manager_, SaveUpdateRequired(false)).Times(0);
   EXPECT_CALL(*cache_manager_, TimeoutResponse()).Times(0);
   EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_)).Times(0);
-  EXPECT_FALSE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_FALSE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_CALL(*cache_manager_, IsPTPreloaded());
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 }
 
 TEST_F(
@@ -860,13 +860,13 @@ TEST_F(
     AddApplication_AddExistingApplicationFromDeviceWithoutConsent_ExpectNoUpdateRequired) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   GetPTU(kValidSdlPtUpdateJson);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   // Try to add existing app
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check no update required
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 }
 
 uint32_t GetCurrentDaysCount() {
@@ -880,19 +880,19 @@ TEST_F(PolicyManagerImplTest2,
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   const uint32_t days = GetCurrentDaysCount();
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 
   GetPTU(kValidSdlPtUpdateJson);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 
-  manager_->AddApplication(app_id_2_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
   // Set PT was updated 10 days ago (limit is 30 days for now)
   // So no limit exceeded
-  manager_->PTUpdatedAt(counter, days - 10);
-  manager_->OnAppRegisteredOnMobile(app_id_2_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->PTUpdatedAt(counter, days - 10);
+  policy_manager_->OnAppRegisteredOnMobile(app_id_2_);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -900,17 +900,17 @@ TEST_F(PolicyManagerImplTest2,
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   const uint32_t days = GetCurrentDaysCount();
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   GetPTU(kValidSdlPtUpdateJson);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 
-  manager_->AddApplication(app_id_2_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
   // Set PT was updated 50 days ago (limit is 30 days for now)
-  manager_->PTUpdatedAt(counter, days - 50);
-  manager_->OnAppRegisteredOnMobile(app_id_2_);
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  policy_manager_->PTUpdatedAt(counter, days - 50);
+  policy_manager_->OnAppRegisteredOnMobile(app_id_2_);
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(
@@ -919,33 +919,35 @@ TEST_F(
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   const uint32_t days = GetCurrentDaysCount();
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   GetPTU(kValidSdlPtUpdateJson);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   // Try to add existing app
-  manager_->AddApplication(app_id_2_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   ::policy::Counters counter = ::policy::Counters::DAYS_AFTER_EPOCH;
   // Set PT was updated 10 days ago (limit is 30 days for now)
   // So no limit exceeded
-  manager_->PTUpdatedAt(counter, days - 10);
-  int ign_cycles = (manager_->GetCache())->IgnitionCyclesBeforeExchange();
+  policy_manager_->PTUpdatedAt(counter, days - 10);
+  int ign_cycles =
+      (policy_manager_->GetCache())->IgnitionCyclesBeforeExchange();
   // Set ignition cycles to value = 99 (limit is 100 which initiates auto
   // PTExchange)
   for (int i = 0; i < ign_cycles; ++i) {
-    manager_->IncrementIgnitionCycles();
+    policy_manager_->IncrementIgnitionCycles();
   }
-  manager_->OnAppRegisteredOnMobile(app_id_2_);
+  policy_manager_->OnAppRegisteredOnMobile(app_id_2_);
   // Check update required
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2,
        GetUserConsentForApp_SetUserConsentForApp_ExpectReceivedConsentCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -959,13 +961,13 @@ TEST_F(PolicyManagerImplTest2,
   ::policy::StringArray disallowed_groups;
   consented_groups.push_back(std::string("Notifications"));
   consented_groups.push_back(std::string("Notifications"));
-  (manager_->GetCache())
+  (policy_manager_->GetCache())
       ->SetUserPermissionsForDevice(
           device_id_2_, consented_groups, disallowed_groups);
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   GetPTU(kValidSdlPtUpdateJson);
 
   ::policy::PermissionConsent perm_consent;
@@ -983,11 +985,11 @@ TEST_F(PolicyManagerImplTest2,
   groups_permissions.push_back(group1_perm);
   perm_consent.group_permissions = groups_permissions;
 
-  manager_->SetUserConsentForApp(perm_consent);
-  manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
+  policy_manager_->SetUserConsentForApp(perm_consent);
+  policy_manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
   std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
   std::vector< ::policy::FunctionalGroupPermission>::iterator it;
-  manager_->GetUserConsentForApp(
+  policy_manager_->GetUserConsentForApp(
       device_id_2_, app_id_2_, actual_groups_permissions);
   uint32_t index = 0;
   for (; index < actual_groups_permissions.size(); ++index) {
@@ -1008,20 +1010,20 @@ TEST_F(PolicyManagerImplTest2,
        CanAppKeepContext_SetPoliciesForAppUpdated_ExpectAppCanKeepContext) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   GetPTU(kValidSdlPtUpdateJson);
   // Check keep context in updated policies for app
-  EXPECT_TRUE(manager_->CanAppKeepContext(app_id_2_));
+  EXPECT_TRUE(policy_manager_->CanAppKeepContext(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
        CanAppStealFocus_SetPoliciesForAppUpdated_ExpectAppCanStealFocus) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   GetPTU(kValidSdlPtUpdateJson);
   // Check keep context in updated policies for app
-  EXPECT_TRUE(manager_->CanAppKeepContext(app_id_2_));
+  EXPECT_TRUE(policy_manager_->CanAppKeepContext(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -1029,9 +1031,10 @@ TEST_F(PolicyManagerImplTest2,
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   GetPTU(kValidSdlPtUpdateJson);
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   policy_table::ModuleConfig& module_config = pt->policy_table.module_config;
-  ::policy::VehicleInfo vehicle_info = manager_->GetVehicleInfo();
+  ::policy::VehicleInfo vehicle_info = policy_manager_->GetVehicleInfo();
 
   EXPECT_EQ(static_cast<std::string>(*module_config.vehicle_make),
             vehicle_info.vehicle_make);
@@ -1047,8 +1050,9 @@ TEST_F(
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
 
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -1061,13 +1065,13 @@ TEST_F(
   ::policy::StringArray consented_groups;
   ::policy::StringArray disallowed_groups;
   consented_groups.push_back(std::string("Notifications"));
-  (manager_->GetCache())
+  (policy_manager_->GetCache())
       ->SetUserPermissionsForDevice(
           device_id_2_, consented_groups, disallowed_groups);
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
 
   GetPTU(kValidSdlPtUpdateJson);
   ::policy::PermissionConsent perm_consent;
@@ -1085,11 +1089,11 @@ TEST_F(
   groups_permissions.push_back(group1_perm);
   perm_consent.group_permissions = groups_permissions;
 
-  manager_->SetUserConsentForApp(perm_consent);
-  manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
+  policy_manager_->SetUserConsentForApp(perm_consent);
+  policy_manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
   std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
   std::vector< ::policy::FunctionalGroupPermission>::iterator it;
-  manager_->GetPermissionsForApp(
+  policy_manager_->GetPermissionsForApp(
       device_id_2_, app_id_2_, actual_groups_permissions);
   uint32_t index = 0;
   for (; index < actual_groups_permissions.size(); ++index) {
@@ -1112,15 +1116,16 @@ TEST_F(
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
 
-  manager_->AddApplication(app_id_3_);
-  ::policy::StringArray app_requests = manager_->GetAppRequestTypes(app_id_3_);
+  policy_manager_->AddApplication(app_id_3_);
+  ::policy::StringArray app_requests =
+      policy_manager_->GetAppRequestTypes(app_id_3_);
   EXPECT_EQ(1u, app_requests.size());
 
   Json::Value root = GetPTU(kPtuRequestTypeJson);
   Json::Value request_Types = Json::Value(Json::arrayValue);
   request_Types =
       root["policy_table"]["app_policies"][app_id_3_]["RequestType"];
-  app_requests = manager_->GetAppRequestTypes(app_id_3_);
+  app_requests = policy_manager_->GetAppRequestTypes(app_id_3_);
   EXPECT_EQ(request_Types.size(), app_requests.size());
   // Check nicknames match
   for (uint32_t i = 0; i < request_Types.size(); ++i) {
@@ -1133,7 +1138,8 @@ TEST_F(
     HertBeatTimeout_AddApp_UpdateAppPolicies_ExpectReceivedHertBeatTimeoutCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   ::policy_table::PolicyTableType type1 =
       ::policy_table::PolicyTableType::PT_PRELOADED;
   pt->SetPolicyTableType(type1);
@@ -1144,8 +1150,8 @@ TEST_F(
     pt->ReportErrors(&report);
   }
   // Add new app
-  manager_->AddApplication(app_id_2_);
-  uint32_t result = manager_->HeartBeatTimeout(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
+  uint32_t result = policy_manager_->HeartBeatTimeout(app_id_2_);
   // By default hertbeat timeout is 0
   EXPECT_EQ(0u, result);
   Json::Value root = GetPTU(kValidSdlPtUpdateJson);
@@ -1163,7 +1169,7 @@ TEST_F(
   Json::Value heart_beat_timeout = Json::Value(Json::uintValue);
   heart_beat_timeout =
       root["policy_table"]["app_policies"][app_id_2_]["heart_beat_timeout_ms"];
-  result = manager_->HeartBeatTimeout(app_id_2_);
+  result = policy_manager_->HeartBeatTimeout(app_id_2_);
   EXPECT_EQ(heart_beat_timeout.asUInt(), result);
 }
 
@@ -1171,8 +1177,9 @@ TEST_F(PolicyManagerImplTest2,
        RemoveAppConsentForGroup_SetUserConsentForApp_ExpectAppConsentDeleted) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -1185,13 +1192,13 @@ TEST_F(PolicyManagerImplTest2,
   ::policy::StringArray consented_groups;
   ::policy::StringArray disallowed_groups;
   consented_groups.push_back(std::string("Notifications"));
-  (manager_->GetCache())
+  (policy_manager_->GetCache())
       ->SetUserPermissionsForDevice(
           device_id_2_, consented_groups, disallowed_groups);
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   GetPTU(kValidSdlPtUpdateJson);
 
   ::policy::PermissionConsent perm_consent;
@@ -1209,11 +1216,11 @@ TEST_F(PolicyManagerImplTest2,
   groups_permissions.push_back(group1_perm);
   perm_consent.group_permissions = groups_permissions;
 
-  manager_->SetUserConsentForApp(perm_consent);
-  manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
+  policy_manager_->SetUserConsentForApp(perm_consent);
+  policy_manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
   std::vector< ::policy::FunctionalGroupPermission> actual_groups_permissions;
   std::vector< ::policy::FunctionalGroupPermission>::iterator it;
-  manager_->GetPermissionsForApp(
+  policy_manager_->GetPermissionsForApp(
       device_id_2_, app_id_2_, actual_groups_permissions);
   uint32_t index = 0;
   for (; index < actual_groups_permissions.size(); ++index) {
@@ -1228,7 +1235,8 @@ TEST_F(PolicyManagerImplTest2,
             actual_groups_permissions[index].group_name);
   EXPECT_EQ(group1_perm.group_id, actual_groups_permissions[index].group_id);
   EXPECT_EQ(group1_perm.state, actual_groups_permissions[index].state);
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   uint32_t ucr_size = 0;
   ::policy_table::DeviceData& device_data = *pt->policy_table.device_data;
   ::policy_table::DeviceData::const_iterator dev_data_iter =
@@ -1244,7 +1252,7 @@ TEST_F(PolicyManagerImplTest2,
     if (ucr_iter != ucr.end()) {
       EXPECT_TRUE((*(ucr_iter->second.consent_groups)).find("Notifications") !=
                   (*(ucr_iter->second.consent_groups)).end());
-      manager_->RemoveAppConsentForGroup(app_id_2_, "Notifications");
+      policy_manager_->RemoveAppConsentForGroup(app_id_2_, "Notifications");
       EXPECT_TRUE((*(ucr_iter->second.consent_groups)).find("Notifications") ==
                   (*(ucr_iter->second.consent_groups)).end());
     }
@@ -1263,10 +1271,10 @@ TEST_F(PolicyManagerImplTest2,
   // permissions, request type etc.
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_1_));
-  manager_->SetUserConsentForDevice(device_id_1_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
 
   // Add app
-  manager_->AddApplication(section_name);
+  policy_manager_->AddApplication(section_name);
   EXPECT_CALL(listener_, OnPendingPermissionChange(section_name)).Times(2);
 
   // PTU has single invalid RequestTypes, which must be dropped and replaced
@@ -1275,18 +1283,18 @@ TEST_F(PolicyManagerImplTest2,
 
   // Get RequestTypes from <app_id> section of app policies after PT update
   ::policy::StringArray app_request_types_after =
-      manager_->GetAppRequestTypes(section_name);
+      policy_manager_->GetAppRequestTypes(section_name);
 
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(kDefaultId))
       .WillOnce(Return(device_id_1_));
   ::policy::StringArray default_request_types_after =
-      manager_->GetAppRequestTypes(kDefaultId);
+      policy_manager_->GetAppRequestTypes(kDefaultId);
 
   // Check sizes of Request types of PT and PTU
   EXPECT_EQ(4u, app_request_types_after.size());
 
   ::policy::AppPermissions permissions =
-      manager_->GetAppPermissionsChanges(section_name);
+      policy_manager_->GetAppPermissionsChanges(section_name);
   EXPECT_TRUE(permissions.requestTypeChanged);
 
   policy_table::RequestType temp_res1;
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
index 54907ef6f2..6a10478399 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_snapshot_test.cc
@@ -78,8 +78,9 @@ TEST_F(PolicyManagerImplTest2, UpdatedPreloadedPT_ExpectLPT_IsUpdated) {
   ofile.close();
 
   //  Make PolicyManager to update LocalPT
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
-  EXPECT_TRUE(manager_->InitPT(preloadet_pt_filename_, &policy_settings_));
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
+  EXPECT_TRUE(
+      policy_manager_->InitPT(preloadet_pt_filename_, &policy_settings_));
   EXPECT_TRUE(cache->IsPTPreloaded());
 
   // Arrange
@@ -117,8 +118,9 @@ TEST_F(PolicyManagerImplTest2,
        SetSystemLanguage_ExpectSystemLanguageSetSuccessfully) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->SetSystemLanguage("it-it");
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  policy_manager_->SetSystemLanguage("it-it");
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   ::policy_table::ModuleMeta& ModuleMeta = *(pt->policy_table.module_meta);
   EXPECT_EQ("it-it", static_cast<std::string>(*(ModuleMeta.language)));
 }
@@ -127,8 +129,9 @@ TEST_F(PolicyManagerImplTest2, SetVINValue_ExpectVINSetSuccessfully) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   std::string vin_code("1FAPP6242VH100001");
-  manager_->SetVINValue(vin_code);
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  policy_manager_->SetVINValue(vin_code);
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   ::policy_table::ModuleMeta& ModuleMeta = *(pt->policy_table.module_meta);
   EXPECT_EQ(vin_code, static_cast<std::string>(*(ModuleMeta.vin)));
 }
@@ -136,8 +139,8 @@ TEST_F(PolicyManagerImplTest2, SetVINValue_ExpectVINSetSuccessfully) {
 TEST_F(PolicyManagerImplTest2, SetSystemInfo_ExpectSystemInfoSetSuccessfully) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->SetSystemInfo("4.1.3.B_EB355B", "WAEGB", "ru-ru");
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy_manager_->SetSystemInfo("4.1.3.B_EB355B", "WAEGB", "ru-ru");
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   utils::SharedPtr<policy_table::Table> pt = cache->GetPT();
   ::policy_table::ModuleMeta& ModuleMeta = *(pt->policy_table.module_meta);
   EXPECT_EQ("ru-ru", static_cast<std::string>(*(ModuleMeta.language)));
@@ -159,8 +162,8 @@ TEST_F(PolicyManagerImplTest2, CleanUnpairedDevice_ExpectDevicesDeleted) {
   dev_info1.carrier = "Life";
   dev_info1.max_number_rfcom_ports = 2;
   dev_info1.connection_type = "Bluetooth";
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  manager_->SetDeviceInfo(device_id_1_, dev_info1);
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy_manager_->SetDeviceInfo(device_id_1_, dev_info1);
 
   // Add second device
   ::policy::DeviceInfo dev_info2;
@@ -171,8 +174,8 @@ TEST_F(PolicyManagerImplTest2, CleanUnpairedDevice_ExpectDevicesDeleted) {
   dev_info2.carrier = "MTS";
   dev_info2.max_number_rfcom_ports = 2;
   dev_info2.connection_type = "Bluetooth";
-  manager_->AddDevice("ZZZ123456789YYY", "Bluetooth");
-  manager_->SetDeviceInfo("ZZZ123456789YYY", dev_info2);
+  policy_manager_->AddDevice("ZZZ123456789YYY", "Bluetooth");
+  policy_manager_->SetDeviceInfo("ZZZ123456789YYY", dev_info2);
 
   // Add third device
   ::policy::DeviceInfo dev_info3;
@@ -183,10 +186,11 @@ TEST_F(PolicyManagerImplTest2, CleanUnpairedDevice_ExpectDevicesDeleted) {
   dev_info3.carrier = "Kyivstar";
   dev_info3.max_number_rfcom_ports = 2;
   dev_info3.connection_type = "Bluetooth";
-  manager_->AddDevice("AAA123456789RRR", "Bluetooth");
-  manager_->SetDeviceInfo("AAA123456789RRR", dev_info3);
+  policy_manager_->AddDevice("AAA123456789RRR", "Bluetooth");
+  policy_manager_->SetDeviceInfo("AAA123456789RRR", dev_info3);
 
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   // Try to find first device in PT
   policy_table::DeviceData::const_iterator iter =
       (*(pt->policy_table.device_data)).find(device_id_1_);
@@ -203,10 +207,10 @@ TEST_F(PolicyManagerImplTest2, CleanUnpairedDevice_ExpectDevicesDeleted) {
   // Check third device successfully added to PT
   ASSERT_TRUE(iter != (*(pt->policy_table.device_data)).end());
 
-  manager_->MarkUnpairedDevice(device_id_1_);
-  manager_->MarkUnpairedDevice("ZZZ123456789YYY");
-  manager_->MarkUnpairedDevice("AAA123456789RRR");
-  manager_->CleanupUnpairedDevices();
+  policy_manager_->MarkUnpairedDevice(device_id_1_);
+  policy_manager_->MarkUnpairedDevice("ZZZ123456789YYY");
+  policy_manager_->MarkUnpairedDevice("AAA123456789RRR");
+  policy_manager_->CleanupUnpairedDevices();
 
   // Try to find first device in PT
   iter = (*(pt->policy_table.device_data)).find(device_id_1_);
@@ -260,10 +264,10 @@ TEST_F(
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Add app
-  manager_->AddApplication(section_name);
+  policy_manager_->AddApplication(section_name);
   // Check app gets RequestTypes from pre_DataConsent of app_policies
   // section
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
 
   // Only single item as in pre_DataConsent in preloaded PT
   EXPECT_EQ(1u, pt_request_types_.size());
@@ -276,7 +280,7 @@ TEST_F(
   // permissions, request type etc.
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(application_id_))
       .WillRepeatedly(Return(device_id_1_));
-  manager_->SetUserConsentForDevice(device_id_1_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
 
   // Get App Request Types from PTU
   ptu_request_types_ =
@@ -285,13 +289,13 @@ TEST_F(
 
   pt_request_types_.clear();
   // Get RequestTypes from <app_id> section of app policies after PT update
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
 
   // Check sizes of Request types of PT and PTU
   ASSERT_EQ(ptu_request_types_size_, pt_request_types_.size());
 
   ::policy::AppPermissions permissions =
-      manager_->GetAppPermissionsChanges(section_name);
+      policy_manager_->GetAppPermissionsChanges(section_name);
   EXPECT_TRUE(permissions.requestTypeChanged);
 
   ::policy::StringArray result;
@@ -310,10 +314,10 @@ TEST_F(PolicyManagerImplTest2, AddDevice_RegisterDevice_TRUE) {
   const std::string connection_type = "Bluetooth";
 
   const bool result =
-      (manager_->GetCache())->AddDevice(device_id_1_, connection_type);
+      (policy_manager_->GetCache())->AddDevice(device_id_1_, connection_type);
   // Get Policy table
   const utils::SharedPtr<policy_table::Table> policy_table =
-      manager_->GetCache()->GetPT();
+      policy_manager_->GetCache()->GetPT();
   // Get preloaded_pt flag from Policy table
   const bool is_preloaded_pt =
       *policy_table->policy_table.module_config.preloaded_pt;
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_test.cc
index bc9f5ac8e6..77a70f1b45 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_test.cc
@@ -62,13 +62,13 @@ TEST_F(
       .WillOnce(DoAll(SetArgReferee<0>(seconds), Return(true)));
 
   // Act
-  manager_->RefreshRetrySequence();
+  policy_manager_->RefreshRetrySequence();
 
   // Assert
-  EXPECT_EQ(50, manager_->NextRetryTimeout());
-  EXPECT_EQ(100, manager_->NextRetryTimeout());
-  EXPECT_EQ(200, manager_->NextRetryTimeout());
-  EXPECT_EQ(0, manager_->NextRetryTimeout());
+  EXPECT_EQ(50, policy_manager_->NextRetryTimeout());
+  EXPECT_EQ(100, policy_manager_->NextRetryTimeout());
+  EXPECT_EQ(200, policy_manager_->NextRetryTimeout());
+  EXPECT_EQ(0, policy_manager_->NextRetryTimeout());
 }
 
 TEST_F(PolicyManagerImplTest, GetNotificationsNumber) {
@@ -77,34 +77,34 @@ TEST_F(PolicyManagerImplTest, GetNotificationsNumber) {
   EXPECT_CALL(*cache_manager_, GetNotificationsNumber(priority))
       .WillOnce(Return(notif_number));
 
-  EXPECT_EQ(notif_number, manager_->GetNotificationsNumber(priority));
+  EXPECT_EQ(notif_number, policy_manager_->GetNotificationsNumber(priority));
 }
 
 TEST_F(PolicyManagerImplTest, IncrementGlobalCounter) {
   // Assert
   EXPECT_CALL(*cache_manager_, Increment(usage_statistics::SYNC_REBOOTS));
-  manager_->Increment(usage_statistics::SYNC_REBOOTS);
+  policy_manager_->Increment(usage_statistics::SYNC_REBOOTS);
 }
 
 TEST_F(PolicyManagerImplTest, IncrementAppCounter) {
   // Assert
   EXPECT_CALL(*cache_manager_,
               Increment("12345", usage_statistics::USER_SELECTIONS));
-  manager_->Increment("12345", usage_statistics::USER_SELECTIONS);
+  policy_manager_->Increment("12345", usage_statistics::USER_SELECTIONS);
 }
 
 TEST_F(PolicyManagerImplTest, SetAppInfo) {
   // Assert
   EXPECT_CALL(*cache_manager_,
               Set("12345", usage_statistics::LANGUAGE_GUI, "de-de"));
-  manager_->Set("12345", usage_statistics::LANGUAGE_GUI, "de-de");
+  policy_manager_->Set("12345", usage_statistics::LANGUAGE_GUI, "de-de");
 }
 
 TEST_F(PolicyManagerImplTest, AddAppStopwatch) {
   // Assert
   EXPECT_CALL(*cache_manager_,
               Add("12345", usage_statistics::SECONDS_HMI_FULL, 30));
-  manager_->Add("12345", usage_statistics::SECONDS_HMI_FULL, 30);
+  policy_manager_->Add("12345", usage_statistics::SECONDS_HMI_FULL, 30);
 }
 
 TEST_F(PolicyManagerImplTest, ResetPT) {
@@ -118,17 +118,17 @@ TEST_F(PolicyManagerImplTest, ResetPT) {
   EXPECT_CALL(*cache_manager_, TimeoutResponse());
   EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_));
 
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
-  EXPECT_TRUE(manager_->ResetPT("filename"));
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
+  EXPECT_TRUE(policy_manager_->ResetPT("filename"));
   EXPECT_TRUE(cache->IsPTPreloaded());
-  EXPECT_FALSE(manager_->ResetPT("filename"));
+  EXPECT_FALSE(policy_manager_->ResetPT("filename"));
   EXPECT_FALSE(cache->IsPTPreloaded());
 }
 
 TEST_F(PolicyManagerImplTest, LoadPT_SetPT_PTIsLoaded) {
   // Arrange
-  manager_->ForcePTExchange();
-  manager_->OnUpdateStarted();
+  policy_manager_->ForcePTExchange();
+  policy_manager_->OnUpdateStarted();
   Json::Value table = createPTforLoad();
 
   policy_table::Table update(&table);
@@ -155,9 +155,9 @@ TEST_F(PolicyManagerImplTest, LoadPT_SetPT_PTIsLoaded) {
   EXPECT_CALL(*cache_manager_, TimeoutResponse());
   EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_));
 
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_CALL(*cache_manager_, IsPTPreloaded());
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -165,24 +165,24 @@ TEST_F(PolicyManagerImplTest2,
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   ::policy::Counters counter = ::policy::Counters::KILOMETERS;
-  manager_->PTUpdatedAt(counter, 50000);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->PTUpdatedAt(counter, 50000);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   // Set kms changed but not exceed limit
-  manager_->KmsChanged(51500);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  policy_manager_->KmsChanged(51500);
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   // Set kms changed and exceed limit
-  manager_->KmsChanged(52500);
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  policy_manager_->KmsChanged(52500);
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2, ForcePTExchange_ExpectUpdateNeeded) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
   // Force OT Exchange
-  manager_->ForcePTExchange();
+  policy_manager_->ForcePTExchange();
   // Check update required
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2, OnSystemReady) {
@@ -190,16 +190,16 @@ TEST_F(PolicyManagerImplTest2, OnSystemReady) {
   CreateLocalPT(preloadet_pt_filename_);
   // Check
   EXPECT_CALL(listener_, OnSystemInfoUpdateRequired());
-  manager_->OnSystemReady();
+  policy_manager_->OnSystemReady();
 }
 
 TEST_F(PolicyManagerImplTest2, ResetRetrySequence) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->ResetRetrySequence();
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
-  manager_->OnUpdateStarted();
-  EXPECT_EQ("UPDATING", manager_->GetPolicyTableStatus());
+  policy_manager_->ResetRetrySequence();
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
+  policy_manager_->OnUpdateStarted();
+  EXPECT_EQ("UPDATING", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2, NextRetryTimeout_ExpectTimeoutsFromPT) {
@@ -214,7 +214,8 @@ TEST_F(PolicyManagerImplTest2, NextRetryTimeout_ExpectTimeoutsFromPT) {
     uint32_t size = seconds_between_retries.size();
     CreateLocalPT(preloadet_pt_filename_);
     for (uint32_t i = 0; i < size; ++i) {
-      EXPECT_EQ(seconds_between_retries[i], manager_->NextRetryTimeout());
+      EXPECT_EQ(seconds_between_retries[i],
+                policy_manager_->NextRetryTimeout());
     }
   }
 }
@@ -223,7 +224,7 @@ TEST_F(PolicyManagerImplTest2, TimeOutExchange) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Check value taken from PT
-  EXPECT_EQ(70000u, manager_->TimeoutExchangeMSec());
+  EXPECT_EQ(70000u, policy_manager_->TimeoutExchangeMSec());
 }
 
 TEST_F(PolicyManagerImplTest,
@@ -238,7 +239,7 @@ TEST_F(PolicyManagerImplTest,
   EXPECT_CALL(listener_, OnSnapshotCreated(_, _, _));
   EXPECT_CALL(*cache_manager_, GenerateSnapshot()).WillOnce(Return(p_table));
 
-  manager_->RequestPTUpdate();
+  policy_manager_->RequestPTUpdate();
 }
 
 TEST_F(PolicyManagerImplTest, RequestPTUpdate_InvalidPT_PTUpdateFail) {
@@ -250,7 +251,7 @@ TEST_F(PolicyManagerImplTest, RequestPTUpdate_InvalidPT_PTUpdateFail) {
   EXPECT_CALL(listener_, OnSnapshotCreated(_, _, _)).Times(0);
   EXPECT_CALL(*cache_manager_, GenerateSnapshot()).WillOnce(Return(p_table));
 
-  manager_->RequestPTUpdate();
+  policy_manager_->RequestPTUpdate();
 }
 
 TEST_F(PolicyManagerImplTest, RequestPTUpdate_InvalidSnapshot_PTUpdateFail) {
@@ -260,7 +261,7 @@ TEST_F(PolicyManagerImplTest, RequestPTUpdate_InvalidSnapshot_PTUpdateFail) {
   EXPECT_CALL(listener_, OnSnapshotCreated(_, _, _)).Times(0);
   EXPECT_CALL(*cache_manager_, GenerateSnapshot()).WillOnce(Return(p_table));
 
-  manager_->RequestPTUpdate();
+  policy_manager_->RequestPTUpdate();
 }
 
 TEST_F(PolicyManagerImplTest, ResetUserConsent_ResetOnlyOnce) {
@@ -268,25 +269,25 @@ TEST_F(PolicyManagerImplTest, ResetUserConsent_ResetOnlyOnce) {
       .WillOnce(Return(true))
       .WillOnce(Return(false));
 
-  EXPECT_TRUE(manager_->ResetUserConsent());
-  EXPECT_FALSE(manager_->ResetUserConsent());
+  EXPECT_TRUE(policy_manager_->ResetUserConsent());
+  EXPECT_FALSE(policy_manager_->ResetUserConsent());
 }
 
 TEST_F(PolicyManagerImplTest2, GetPolicyTableStatus_ExpectUpToDate) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Check
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest,
        SetUpdateStarted_GetPolicyTableStatus_Expect_Updating) {
   // Arrange
-  manager_->ForcePTExchange();
+  policy_manager_->ForcePTExchange();
   EXPECT_CALL(*cache_manager_, SaveUpdateRequired(true));
-  manager_->OnUpdateStarted();
+  policy_manager_->OnUpdateStarted();
   // Check
-  EXPECT_EQ("UPDATING", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UPDATING", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -301,7 +302,7 @@ TEST_F(PolicyManagerImplTest2,
         root["policy_table"]["module_config"]["seconds_between_retries"];
     uint32_t size = seconds_between_retries.size();
     CreateLocalPT(preloadet_pt_filename_);
-    std::vector<int> delaySecs = manager_->RetrySequenceDelaysSeconds();
+    std::vector<int> delaySecs = policy_manager_->RetrySequenceDelaysSeconds();
     // Check
     ASSERT_EQ(size, delaySecs.size());
     for (uint32_t i = 0; i < size; ++i) {
@@ -314,10 +315,10 @@ TEST_F(PolicyManagerImplTest2,
        OnExceededTimeout_GetPolicyTableStatus_ExpectUpdateNeeded) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->ForcePTExchange();
-  manager_->OnExceededTimeout();
+  policy_manager_->ForcePTExchange();
+  policy_manager_->OnExceededTimeout();
   // Check
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(PolicyManagerImplTest, MarkUnpairedDevice) {
@@ -331,13 +332,13 @@ TEST_F(PolicyManagerImplTest, MarkUnpairedDevice) {
   EXPECT_CALL(*cache_manager_, IgnitionCyclesBeforeExchange());
   EXPECT_CALL(*cache_manager_, DaysBeforeExchange(_));
   // Act
-  manager_->MarkUnpairedDevice(unpaired_device_id_);
+  policy_manager_->MarkUnpairedDevice(unpaired_device_id_);
 }
 
 TEST_F(PolicyManagerImplTest2, GetCurrentDeviceId) {
   // Arrange
-  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_)).Times(1);
-  EXPECT_EQ("", manager_->GetCurrentDeviceId(app_id_2_));
+  EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_));
+  EXPECT_EQ("", policy_manager_->GetCurrentDeviceId(app_id_2_));
 }
 
 }  // namespace policy
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
index 63bcb30374..30007babad 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_test_base.cc
@@ -193,18 +193,18 @@ void InsertRpcParametersInList(::policy::RPCParams& input_params) {
 // PolicyManagerImplTest class methods
 PolicyManagerImplTest::PolicyManagerImplTest()
     : unpaired_device_id_("08-00-27-CE-76-FE")
-    , manager_(NULL)
+    , policy_manager_(NULL)
     , cache_manager_(NULL) {}
 
 void PolicyManagerImplTest::SetUp() {
-  manager_ = new PolicyManagerImpl();
+  policy_manager_ = new PolicyManagerImpl();
   cache_manager_ = new MockCacheManagerInterface();
-  manager_->set_cache_manager(cache_manager_);
-  manager_->set_listener(&listener_);
+  policy_manager_->set_cache_manager(cache_manager_);
+  policy_manager_->set_listener(&listener_);
 }
 
 void PolicyManagerImplTest::TearDown() {
-  delete manager_;
+  delete policy_manager_;
 }
 
 ::testing::AssertionResult PolicyManagerImplTest::IsValid(
@@ -229,7 +229,7 @@ PolicyManagerImplTest2::PolicyManagerImplTest2()
     , app_storage_folder_("storage1")
     , preloadet_pt_filename_(kSdlPreloadedPtJson)
     , in_memory_(true)
-    , manager_(NULL)
+    , policy_manager_(NULL)
     , ptu_request_types_size_(0u)
     , index_(0u)
     , ptu_request_types_(Json::arrayValue) {}
@@ -237,10 +237,10 @@ PolicyManagerImplTest2::PolicyManagerImplTest2()
 void PolicyManagerImplTest2::SetUp() {
   file_system::CreateDirectory(app_storage_folder_);
 
-  manager_ = new PolicyManagerImpl(in_memory_);
+  policy_manager_ = new PolicyManagerImpl(in_memory_);
   ON_CALL(policy_settings_, app_storage_folder())
       .WillByDefault(ReturnRef(app_storage_folder_));
-  manager_->set_listener(&listener_);
+  policy_manager_->set_listener(&listener_);
   const char* levels[] = {"BACKGROUND", "FULL", "LIMITED", "NONE"};
   hmi_level_.assign(levels, levels + sizeof(levels) / sizeof(levels[0]));
   srand(time(NULL));
@@ -268,8 +268,8 @@ const Json::Value PolicyManagerImplTest2::GetPTU(const std::string& file_name) {
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
   // Load Json to cache
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
   return root;
 }
 
@@ -277,8 +277,8 @@ void PolicyManagerImplTest2::CreateLocalPT(const std::string& file_name) {
   file_system::remove_directory_content(app_storage_folder_);
   ON_CALL(policy_settings_, app_storage_folder())
       .WillByDefault(ReturnRef(app_storage_folder_));
-  ASSERT_TRUE(manager_->InitPT(file_name, &policy_settings_));
-  EXPECT_TRUE(manager_->GetCache()->IsPTPreloaded());
+  ASSERT_TRUE(policy_manager_->InitPT(file_name, &policy_settings_));
+  EXPECT_TRUE(policy_manager_->GetCache()->IsPTPreloaded());
 }
 
 void PolicyManagerImplTest2::AddRTtoPT(const std::string& update_file_name,
@@ -288,7 +288,7 @@ void PolicyManagerImplTest2::AddRTtoPT(const std::string& update_file_name,
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Get RequestTypes from section of preloaded_pt app_policies
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
   EXPECT_EQ(rt_number, pt_request_types_.size());
   Json::Value root = GetPTU(update_file_name);
   // Get Request Types from JSON (PTU)
@@ -297,7 +297,7 @@ void PolicyManagerImplTest2::AddRTtoPT(const std::string& update_file_name,
   ptu_request_types_size_ = ptu_request_types_.size();
   pt_request_types_.clear();
   // Get RequestTypes from section of PT app policies after update
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
   // Check number of RT in PTU and PT now are equal
   ASSERT_EQ(ptu_request_types_size_ - invalid_rt_number,
             pt_request_types_.size());
@@ -311,10 +311,10 @@ void PolicyManagerImplTest2::AddRTtoAppSectionPT(
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
   // Add app
-  manager_->AddApplication(section_name);
+  policy_manager_->AddApplication(section_name);
   // Check app gets RequestTypes from pre_DataConsent of app_policies
   // section
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
   EXPECT_EQ(rt_number, pt_request_types_.size());
   EXPECT_CALL(listener_, OnPendingPermissionChange(section_name)).Times(1);
   Json::Value root = GetPTU(update_file_name);
@@ -326,13 +326,13 @@ void PolicyManagerImplTest2::AddRTtoAppSectionPT(
 
   pt_request_types_.clear();
   // Get RequestTypes from <app_id> section of app policies after PT update
-  pt_request_types_ = manager_->GetAppRequestTypes(section_name);
+  pt_request_types_ = policy_manager_->GetAppRequestTypes(section_name);
   // Check sizes of Request types of PT and PTU
   ASSERT_EQ(ptu_request_types_size_ - invalid_rt_number,
             pt_request_types_.size());
 
   ::policy::AppPermissions permissions =
-      manager_->GetAppPermissionsChanges(section_name);
+      policy_manager_->GetAppPermissionsChanges(section_name);
   EXPECT_TRUE(permissions.requestTypeChanged);
 }
 
@@ -392,7 +392,7 @@ void PolicyManagerImplTest2::FillMultimapFromFunctionalGroupings(
 void PolicyManagerImplTest2::GetFunctionalGroupingsFromManager(
     policy_table::FunctionalGroupings& input_functional_groupings) {
   // Get cache
-  ::policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  ::policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   // Get table_snapshot
   utils::SharedPtr<policy_table::Table> table = cache->GenerateSnapshot();
   // Set functional groupings from policy table
@@ -400,7 +400,7 @@ void PolicyManagerImplTest2::GetFunctionalGroupingsFromManager(
 }
 
 void PolicyManagerImplTest2::TearDown() {
-  delete manager_;
+  delete policy_manager_;
   file_system::RemoveDirectory(app_storage_folder_, true);
 }
 
@@ -418,8 +418,8 @@ void PolicyManagerImplTest2::
         const std::string& update_file) {
   // Arrange
   CreateLocalPT("json/sdl_preloaded_pt_send_location.json");
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  policy::CacheManagerInterfaceSPtr cache = manager_->GetCache();
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy::CacheManagerInterfaceSPtr cache = policy_manager_->GetCache();
   ASSERT_TRUE(cache->SetDeviceData(device_id_1_,
                                    "hardware IPX",
                                    "v.8.0.1",
@@ -430,7 +430,7 @@ void PolicyManagerImplTest2::
                                    "Bluetooth"));
 
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(application_id_);
+  policy_manager_->AddApplication(application_id_);
 
   // Expect all parameters are allowed
   std::ifstream ifile(update_file);
@@ -443,7 +443,7 @@ void PolicyManagerImplTest2::
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Will be called each time permissions are checked
@@ -457,7 +457,7 @@ void PolicyManagerImplTest2::
 
   ::policy::CheckPermissionResult output;
   // Rpc in FULL level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -468,7 +468,7 @@ void PolicyManagerImplTest2::
   ResetOutputList(output);
 
   // Rpc in LIMITED level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelLimited, "SendLocation", input_params, output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
@@ -479,11 +479,11 @@ void PolicyManagerImplTest2::
   ResetOutputList(output);
 
   // Rpc in BACKGROUND level
-  manager_->CheckPermissions(application_id_,
-                             kHmiLevelBackground,
-                             "SendLocation",
-                             input_params,
-                             output);
+  policy_manager_->CheckPermissions(application_id_,
+                                    kHmiLevelBackground,
+                                    "SendLocation",
+                                    input_params,
+                                    output);
   // Check RPC is allowed
   EXPECT_EQ(::policy::kRpcAllowed, output.hmi_level_permitted);
   // Check list of allowed parameters is not empty
@@ -494,7 +494,7 @@ void PolicyManagerImplTest2::
   ResetOutputList(output);
 
   // Rpc in NONE level
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelNone, "SendLocation", input_params, output);
   // Check RPC is disallowed
   EXPECT_EQ(::policy::kRpcDisallowed, output.hmi_level_permitted);
@@ -508,7 +508,7 @@ void PolicyManagerImplTest2::CheckRpcPermissions(
     const std::string& rpc_name, const PermitResult& expected_permission) {
   ::policy::RPCParams input_params;
   ::policy::CheckPermissionResult output;
-  manager_->CheckPermissions(
+  policy_manager_->CheckPermissions(
       application_id_, kHmiLevelFull, rpc_name, input_params, output);
   EXPECT_EQ(expected_permission, output.hmi_level_permitted);
 }
@@ -516,8 +516,8 @@ void PolicyManagerImplTest2::CheckRpcPermissions(
 // To avoid duplicate arrange of test
 void PolicyManagerImplTest2::AddSetDeviceData() {
   CreateLocalPT("json/sdl_preloaded_pt_send_location.json");
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  ASSERT_TRUE((manager_->GetCache())
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_1_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -528,8 +528,8 @@ void PolicyManagerImplTest2::AddSetDeviceData() {
                                   "Bluetooth"));
 
   // Add app from consented device. App will be assigned with default policies
-  manager_->AddApplication(application_id_);
-  (manager_->GetCache())->AddDevice(device_id_1_, "Bluetooth");
+  policy_manager_->AddApplication(application_id_);
+  (policy_manager_->GetCache())->AddDevice(device_id_1_, "Bluetooth");
 }
 
 // Load Json File and set it as PTU
@@ -546,8 +546,8 @@ void PolicyManagerImplTest2::LoadPTUFromJsonFile(
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(manager_->LoadPT(kFilePtUpdateJson, msg));
-  EXPECT_FALSE(manager_->GetCache()->IsPTPreloaded());
+  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 }
 
 // PolicyManagerImplTest_RequestTypes class methods
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
index be266a3a03..56a779f350 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
@@ -52,11 +52,11 @@ TEST_F(
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
       .WillOnce(Return(device_id_1_));
 
-  manager_->SetUserConsentForDevice(device_id_1_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, true);
 
-  manager_->AddApplication(app_id_1_);
+  policy_manager_->AddApplication(app_id_1_);
 
-  EXPECT_EQ("UPDATE_NEEDED", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(
@@ -72,17 +72,17 @@ TEST_F(
   const int kSecondsInDay = 60 * 60 * 24;
   const int days_after_epoch = current_time.tv_sec / kSecondsInDay;
 
-  manager_->PTUpdatedAt(DAYS_AFTER_EPOCH, days_after_epoch);
-  manager_->PTUpdatedAt(KILOMETERS, 1000);
+  policy_manager_->PTUpdatedAt(DAYS_AFTER_EPOCH, days_after_epoch);
+  policy_manager_->PTUpdatedAt(KILOMETERS, 1000);
 
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_1_))
       .WillOnce(Return(device_id_1_));
 
-  manager_->SetUserConsentForDevice(device_id_1_, false);
+  policy_manager_->SetUserConsentForDevice(device_id_1_, false);
 
-  manager_->AddApplication(app_id_1_);
+  policy_manager_->AddApplication(app_id_1_);
 
-  EXPECT_EQ("UP_TO_DATE", manager_->GetPolicyTableStatus());
+  EXPECT_EQ("UP_TO_DATE", policy_manager_->GetPolicyTableStatus());
 }
 
 TEST_F(
@@ -90,10 +90,10 @@ TEST_F(
     ReactOnUserDevConsentForApp_AddNewApplicationFromDeviceWithoutConsent_ExpectPreDataConsent) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_1_);
-  ASSERT_TRUE(manager_->IsPredataPolicy(app_id_1_));
-  manager_->ReactOnUserDevConsentForApp(app_id_1_, false);
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_1_));
+  policy_manager_->AddApplication(app_id_1_);
+  ASSERT_TRUE(policy_manager_->IsPredataPolicy(app_id_1_));
+  policy_manager_->ReactOnUserDevConsentForApp(app_id_1_, false);
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_1_));
 }
 
 // Related to manual test APPLINK-18768
@@ -101,8 +101,9 @@ TEST_F(PolicyManagerImplTest2,
        CheckPreDataConsent_AppRegistered_ExpectReceivedRpcPermissionCorrect) {
   // Arrange
   CreateLocalPT(kSdlPreloadedPtJson2);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  manager_->AddApplication(application_id_);
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  policy_manager_->AddApplication(application_id_);
 
   // Expect RPCs from pre_dataConsent group are allowed
   // Next checks are equal to BaseBeforeDataConsent_APIs.xml checks from task
@@ -150,15 +151,15 @@ TEST_F(PolicyManagerImplTest2,
 TEST_F(PolicyManagerImplTest2, CheckPreDataConsent_GetDefaultHmiLevel_NONE) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   std::string default_hmi;
   // Default HMI level is NONE
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi);
   EXPECT_EQ("NONE", default_hmi);
 
   // Default priority level is NONE
   std::string priority1;
-  EXPECT_TRUE(manager_->GetPriority(app_id_2_, &priority1));
+  EXPECT_TRUE(policy_manager_->GetPriority(app_id_2_, &priority1));
   EXPECT_EQ("NONE", priority1);
 }
 
@@ -167,14 +168,14 @@ TEST_F(PolicyManagerImplTest2,
        CheckPreDataConsent_GetDefaultHmiLevel_BACKGROUNG) {
   // Arrange
   CreateLocalPT(kSdlPreloadedPtJson2);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   std::string default_hmi;
   // Default HMI level is BACKGROUND
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi);
   EXPECT_EQ("BACKGROUND", default_hmi);
   // Default priority level is EMERGENCY
   std::string priority1;
-  EXPECT_TRUE(manager_->GetPriority(app_id_2_, &priority1));
+  EXPECT_TRUE(policy_manager_->GetPriority(app_id_2_, &priority1));
   EXPECT_EQ("EMERGENCY", priority1);
 }
 
@@ -184,12 +185,12 @@ TEST_F(
   // Arrange
   // RequestTypes for default & preDataConsent are different
   CreateLocalPT("json/ptu_requestType.json");
-  manager_->AddApplication(app_id_1_);
-  ASSERT_TRUE(manager_->IsPredataPolicy(app_id_1_));
-  manager_->ReactOnUserDevConsentForApp(app_id_1_, true);
-  EXPECT_FALSE(manager_->IsPredataPolicy(app_id_1_));
+  policy_manager_->AddApplication(app_id_1_);
+  ASSERT_TRUE(policy_manager_->IsPredataPolicy(app_id_1_));
+  policy_manager_->ReactOnUserDevConsentForApp(app_id_1_, true);
+  EXPECT_FALSE(policy_manager_->IsPredataPolicy(app_id_1_));
   // Expect app_id_1_ has default policy
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_1_));
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_1_));
 }
 
 TEST_F(
@@ -198,12 +199,12 @@ TEST_F(
   // Arrange
   // RequestTypes for default & preDataConsent are the same
   CreateLocalPT(kPtu2RequestTypeJson);
-  manager_->AddApplication(app_id_1_);
-  ASSERT_TRUE(manager_->IsPredataPolicy(app_id_1_));
+  policy_manager_->AddApplication(app_id_1_);
+  ASSERT_TRUE(policy_manager_->IsPredataPolicy(app_id_1_));
   EXPECT_CALL(listener_, OnPendingPermissionChange(app_id_1_)).Times(0);
-  manager_->ReactOnUserDevConsentForApp(app_id_1_, true);
-  EXPECT_FALSE(manager_->IsPredataPolicy(app_id_1_));
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_1_));
+  policy_manager_->ReactOnUserDevConsentForApp(app_id_1_, true);
+  EXPECT_FALSE(policy_manager_->IsPredataPolicy(app_id_1_));
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_1_));
 }
 
 TEST_F(
@@ -211,9 +212,10 @@ TEST_F(
     GetUserConsentForDevice_SetDeviceWithoutConcent_ExpectReceivedConsentCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceHasNoConsent, consent);
 }
@@ -222,9 +224,10 @@ TEST_F(PolicyManagerImplTest2,
        GetUserConsentForDevice_SetDeviceAllowed_ExpectReceivedConsentCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
 
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -234,9 +237,9 @@ TEST_F(PolicyManagerImplTest2,
                                   2,
                                   "Bluetooth"));
 
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
 }
@@ -246,8 +249,9 @@ TEST_F(
     GetUserConsentForDevice_SetDeviceDisallowed_ExpectReceivedConsentCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -257,9 +261,9 @@ TEST_F(
                                   2,
                                   "Bluetooth"));
 
-  manager_->SetUserConsentForDevice(device_id_2_, false);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, false);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceDisallowed, consent);
 }
@@ -268,8 +272,9 @@ TEST_F(PolicyManagerImplTest2,
        GetDefaultHmi_SetDeviceDisallowed_ExpectReceivedHmiCorrect) {
   // Arrange
   CreateLocalPT(kPtu2RequestTypeJson);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -279,16 +284,16 @@ TEST_F(PolicyManagerImplTest2,
                                   2,
                                   "Bluetooth"));
 
-  manager_->SetUserConsentForDevice(device_id_2_, false);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, false);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceDisallowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   std::string default_hmi;
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi);
   EXPECT_EQ("NONE", default_hmi);
 }
 
@@ -296,14 +301,15 @@ TEST_F(PolicyManagerImplTest2,
        GetDefaultHmi_SetDeviceAllowed_ExpectReceivedHmiCorrect) {
   // Arrange
   CreateLocalPT(kPtu2RequestTypeJson);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
   std::string default_hmi1;
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi1);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi1);
   EXPECT_EQ("NONE", default_hmi1);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -312,17 +318,17 @@ TEST_F(PolicyManagerImplTest2,
                                   "Life",
                                   2,
                                   "Bluetooth"));
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_2_));
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_2_));
   std::string default_hmi2;
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi2);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi2);
   EXPECT_EQ("LIMITED", default_hmi2);
 }
 
@@ -330,14 +336,15 @@ TEST_F(PolicyManagerImplTest2,
        GetDefaultPriority_SetDeviceAllowed_ExpectReceivedPriorityCorrect) {
   // Arrange
   CreateLocalPT(kPtu2RequestTypeJson);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
   std::string priority1;
-  EXPECT_TRUE(manager_->GetPriority(app_id_2_, &priority1));
+  EXPECT_TRUE(policy_manager_->GetPriority(app_id_2_, &priority1));
   EXPECT_EQ("NONE", priority1);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -346,17 +353,17 @@ TEST_F(PolicyManagerImplTest2,
                                   "Life",
                                   2,
                                   "Bluetooth"));
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_2_));
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_2_));
   std::string priority2;
-  EXPECT_TRUE(manager_->GetPriority(app_id_2_, &priority2));
+  EXPECT_TRUE(policy_manager_->GetPriority(app_id_2_, &priority2));
   EXPECT_EQ("EMERGENCY", priority2);
 }
 
@@ -370,12 +377,13 @@ TEST_F(PolicyManagerImplTest2,
   const std::string language = "en-us";
   const std::string active_hmi_language = language;
   std::vector< ::policy::UserFriendlyMessage> result =
-      manager_->GetUserFriendlyMessages(
+      policy_manager_->GetUserFriendlyMessages(
           message_code, language, active_hmi_language);
   uint32_t size = result.size();
   EXPECT_GT(size, 0u);
   std::vector< ::policy::UserFriendlyMessage>::iterator result_iter;
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
 
   policy_table::ConsumerFriendlyMessages& consumer_friendly_messages =
       *(pt->policy_table.consumer_friendly_messages);
@@ -435,7 +443,8 @@ TEST_F(PolicyManagerImplTest2,
 TEST_F(PolicyManagerImplTest2, SetDeviceInfo_ExpectDevInfoAddedToPT) {
   // Arrange
   ::policy::DeviceInfo dev_info;
-  utils::SharedPtr<policy_table::Table> pt = (manager_->GetCache())->GetPT();
+  utils::SharedPtr<policy_table::Table> pt =
+      (policy_manager_->GetCache())->GetPT();
   dev_info.hardware = "hardware IPX";
   dev_info.firmware_rev = "v.8.0.1";
   dev_info.os = "Android";
@@ -443,8 +452,8 @@ TEST_F(PolicyManagerImplTest2, SetDeviceInfo_ExpectDevInfoAddedToPT) {
   dev_info.carrier = "Life";
   dev_info.max_number_rfcom_ports = 2;
   dev_info.connection_type = "Bluetooth";
-  manager_->AddDevice(device_id_1_, "Bluetooth");
-  manager_->SetDeviceInfo(device_id_1_, dev_info);
+  policy_manager_->AddDevice(device_id_1_, "Bluetooth");
+  policy_manager_->SetDeviceInfo(device_id_1_, dev_info);
   // Find device in PT
   policy_table::DeviceData::const_iterator iter =
       (*(pt->policy_table.device_data)).find(device_id_1_);
@@ -468,10 +477,10 @@ TEST_F(PolicyManagerImplTest2, SetDeviceInfo_ExpectDevInfoAddedToPT) {
 TEST_F(PolicyManagerImplTest2, GetInitialAppData_ExpectReceivedConsentCorrect) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   ::policy::StringArray app_nicknames;
   ::policy::StringArray app_hmi_types;
-  manager_->GetInitialAppData(app_id_2_, &app_nicknames, &app_hmi_types);
+  policy_manager_->GetInitialAppData(app_id_2_, &app_nicknames, &app_hmi_types);
   // Expect Empty nicknames and AppHMITypes
   EXPECT_EQ(0u, app_nicknames.size());
   EXPECT_EQ(0u, app_hmi_types.size());
@@ -488,7 +497,8 @@ TEST_F(PolicyManagerImplTest2, GetInitialAppData_ExpectReceivedConsentCorrect) {
 
   ::policy::StringArray app_nicknames1;
   ::policy::StringArray app_hmi_types1;
-  manager_->GetInitialAppData(app_id_2_, &app_nicknames1, &app_hmi_types1);
+  policy_manager_->GetInitialAppData(
+      app_id_2_, &app_nicknames1, &app_hmi_types1);
   const uint32_t nick_names_size = app_nicknames1.size();
   const uint32_t app_hmi_types_size = app_hmi_types1.size();
   ASSERT_EQ(appHmiType_size, app_hmi_types_size);
@@ -510,20 +520,21 @@ TEST_F(
     CanAppKeepContext_AddAppFromUnconsentedDevice_ExpectAppCannotKeepContext) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
   // Check keep context in preData policy
-  EXPECT_FALSE(manager_->CanAppKeepContext(app_id_2_));
+  EXPECT_FALSE(policy_manager_->CanAppKeepContext(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
        CanAppKeepContext_AddAppFromConsentedDevice_ExpectAppCannotKeepContext) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  manager_->AddApplication(app_id_2_);
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  policy_manager_->AddApplication(app_id_2_);
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -532,36 +543,37 @@ TEST_F(PolicyManagerImplTest2,
                                   "Life",
                                   2,
                                   "Bluetooth"));
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_2_));
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_2_));
   // Check keep context in default policy
-  EXPECT_FALSE(manager_->CanAppKeepContext(app_id_2_));
+  EXPECT_FALSE(policy_manager_->CanAppKeepContext(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
        CanAppStealFocus_AddAppFromUnconsentedDevice_ExpectAppCannotStealFocus) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
   // Check keep context in preData policy
-  EXPECT_FALSE(manager_->CanAppStealFocus(app_id_2_));
+  EXPECT_FALSE(policy_manager_->CanAppStealFocus(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
        CanAppStealFocus_AddAppFromConsentedDevice_ExpectAppCannotStealFocus) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  manager_->AddApplication(app_id_2_);
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  policy_manager_->AddApplication(app_id_2_);
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -570,25 +582,25 @@ TEST_F(PolicyManagerImplTest2,
                                   "Life",
                                   2,
                                   "Bluetooth"));
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_2_));
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_2_));
   // Check keep context in default policy
-  EXPECT_FALSE(manager_->CanAppStealFocus(app_id_2_));
+  EXPECT_FALSE(policy_manager_->CanAppStealFocus(app_id_2_));
 }
 
 TEST_F(PolicyManagerImplTest2,
        IsPredataPolicy_SetAppWIthPredataPolicy_ExpectPredataPolicy) {
   // Arrange
   CreateLocalPT(preloadet_pt_filename_);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
 }
 
 TEST_F(
@@ -596,20 +608,21 @@ TEST_F(
     SendNotificationOnPermissionsUpdated_SetDeviceAllowed_ExpectNotificationSent) {
   // Arrange
   CreateLocalPT(kPtu2RequestTypeJson);
-  manager_->AddApplication(app_id_2_);
+  policy_manager_->AddApplication(app_id_2_);
   // Check if app has preData policy
-  EXPECT_TRUE(manager_->IsPredataPolicy(app_id_2_));
+  EXPECT_TRUE(policy_manager_->IsPredataPolicy(app_id_2_));
   std::string default_hmi1;
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi1);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi1);
   EXPECT_EQ("NONE", default_hmi1);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillOnce(Return(""));
   EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_2_, _, default_hmi1))
       .Times(0);
-  manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
+  policy_manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
 
-  ASSERT_TRUE((manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
-  ASSERT_TRUE((manager_->GetCache())
+  ASSERT_TRUE(
+      (policy_manager_->GetCache())->AddDevice(device_id_2_, "Bluetooth"));
+  ASSERT_TRUE((policy_manager_->GetCache())
                   ->SetDeviceData(device_id_2_,
                                   "hardware IPX",
                                   "v.8.0.1",
@@ -618,20 +631,20 @@ TEST_F(
                                   "Life",
                                   2,
                                   "Bluetooth"));
-  manager_->SetUserConsentForDevice(device_id_2_, true);
+  policy_manager_->SetUserConsentForDevice(device_id_2_, true);
   ::policy::DeviceConsent consent =
-      manager_->GetUserConsentForDevice(device_id_2_);
+      policy_manager_->GetUserConsentForDevice(device_id_2_);
   // Check
   EXPECT_EQ(::policy::DeviceConsent::kDeviceAllowed, consent);
   EXPECT_CALL(listener_, OnCurrentDeviceIdUpdateRequired(app_id_2_))
       .WillRepeatedly(Return(device_id_2_));
-  manager_->AddApplication(app_id_2_);
-  EXPECT_TRUE((manager_->GetCache())->IsDefaultPolicy(app_id_2_));
+  policy_manager_->AddApplication(app_id_2_);
+  EXPECT_TRUE((policy_manager_->GetCache())->IsDefaultPolicy(app_id_2_));
   std::string default_hmi2;
-  manager_->GetDefaultHmi(app_id_2_, &default_hmi2);
+  policy_manager_->GetDefaultHmi(app_id_2_, &default_hmi2);
   EXPECT_EQ("LIMITED", default_hmi2);
   EXPECT_CALL(listener_, OnPermissionsUpdated(app_id_2_, _, default_hmi2));
-  manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
+  policy_manager_->SendNotificationOnPermissionsUpdated(app_id_2_);
 }
 
 }  // namespace policy
diff --git a/src/components/policy/policy_external/test/sql_pt_representation_test.cc b/src/components/policy/policy_external/test/sql_pt_representation_test.cc
index 531b4e67b7..61c769bd61 100644
--- a/src/components/policy/policy_external/test/sql_pt_representation_test.cc
+++ b/src/components/policy/policy_external/test/sql_pt_representation_test.cc
@@ -62,10 +62,15 @@ using testing::ReturnRef;
 using testing::Return;
 using testing::NiceMock;
 using testing::Mock;
+
 namespace test {
 namespace components {
 namespace policy_test {
 
+namespace {
+const int32_t kPolicyTablesNumber = 27;
+}
+
 class SQLPTRepresentationTest : public SQLPTRepresentation,
                                 public ::testing::Test {
  public:
@@ -224,6 +229,7 @@ class SQLPTRepresentationTest : public SQLPTRepresentation,
     policy_table["app_policies"] = Json::Value(Json::objectValue);
 
     Json::Value& module_config = policy_table["module_config"];
+    module_config["preloaded_date"] = Json::Value("25-04-2015");
     module_config["exchange_after_x_ignition_cycles"] = Json::Value(10);
     module_config["exchange_after_x_kilometers"] = Json::Value(100);
     module_config["exchange_after_x_days"] = Json::Value(5);
@@ -400,7 +406,7 @@ TEST_F(SQLPTRepresentationTest,
   // Check PT structure destroyed and tables number is 0
   query.Prepare(query_select);
   query.Next();
-  ASSERT_EQ(25, query.GetInteger(0));
+  ASSERT_EQ(kPolicyTablesNumber, query.GetInteger(0));
 
   const std::string query_select_count_of_iap_buffer_full =
       "SELECT `count_of_iap_buffer_full` FROM `usage_and_error_count`";
diff --git a/src/components/policy/policy_regular/include/policy/cache_manager.h b/src/components/policy/policy_regular/include/policy/cache_manager.h
index 47d8e69551..1bd506656c 100644
--- a/src/components/policy/policy_regular/include/policy/cache_manager.h
+++ b/src/components/policy/policy_regular/include/policy/cache_manager.h
@@ -593,12 +593,13 @@ class CacheManager : public CacheManagerInterface {
   /**
    * @brief MergePreloadPT allows to load policy table from certain JSON file,
    * and then decide if merge is needed. The merge is needed in case when
-   *preload
+   * preload
    * JSON date is different than current database.
    *
    * @param file_name the preloaded policy table JSON file.
+   * @return false in case of invalid preloaded_pt
    */
-  void MergePreloadPT(const std::string& file_name);
+  bool MergePreloadPT(const std::string& file_name);
 
   /**
    * @brief MergeMC allows to merge ModuleConfig section by definite rules.
diff --git a/src/components/policy/policy_regular/src/cache_manager.cc b/src/components/policy/policy_regular/src/cache_manager.cc
index e1a6544c23..3d831b886f 100644
--- a/src/components/policy/policy_regular/src/cache_manager.cc
+++ b/src/components/policy/policy_regular/src/cache_manager.cc
@@ -1333,7 +1333,9 @@ bool CacheManager::Init(const std::string& file_name,
           backup_->UpdateDBVersion();
           Backup();
         }
-        MergePreloadPT(file_name);
+        if (!MergePreloadPT(file_name)) {
+          result = false;
+        }
       }
     } break;
     case InitResult::SUCCESS: {
@@ -1475,12 +1477,12 @@ std::string CacheManager::GetCertificate() const {
   return std::string("");
 }
 
-void CacheManager::MergePreloadPT(const std::string& file_name) {
+bool CacheManager::MergePreloadPT(const std::string& file_name) {
   LOG4CXX_AUTO_TRACE(logger_);
   policy_table::Table table;
   if (!LoadFromFile(file_name, table)) {
     LOG4CXX_DEBUG(logger_, "Unable to load preloaded PT.");
-    return;
+    return false;
   }
 
   sync_primitives::AutoLock lock(cache_lock_);
@@ -1495,6 +1497,7 @@ void CacheManager::MergePreloadPT(const std::string& file_name) {
     MergeCFM(new_table, current);
     Backup();
   }
+  return true;
 }
 
 void CacheManager::MergeMC(const policy_table::PolicyTable& new_pt,
diff --git a/src/components/policy/policy_regular/test/include/policy/mock_policy_listener.h b/src/components/policy/policy_regular/test/include/policy/mock_policy_listener.h
index 931a3c0338..2e4073aae9 100644
--- a/src/components/policy/policy_regular/test/include/policy/mock_policy_listener.h
+++ b/src/components/policy/policy_regular/test/include/policy/mock_policy_listener.h
@@ -74,6 +74,8 @@ class MockPolicyListener : public PolicyListener {
   MOCK_METHOD1(OnCertificateUpdated, void(const std::string&));
   MOCK_CONST_METHOD2(SendOnAppPermissionsChanged,
                      void(const AppPermissions&, const std::string&));
+  MOCK_CONST_METHOD1(GetRegisteredLinks,
+                     void(std::map<std::string, std::string>&));
 };
 
 }  // namespace policy