Fix PTU notifications order (#3051)

* Fix order of actions taken during PTU

The existing order of actions were changed to
make it more obvious for external systems like
HMI and mobile apps. The main concern was that
SDL is sending OnStatusUpdate(UP_TO_DATE) when
policy table update was not actually done.
The order of actions done during PTU was updated
to perform sending of UP_TO_DATE only when all
policy actions were actually done.
Related unit tests were updated respectively.

5 files changed, 192 insertions, 99 deletions

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 321294aa3d..60d70a9283 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
@@ -127,8 +127,10 @@ class PolicyManagerImpl : public PolicyManager {
    * @param pt_content PTU as binary string
    * @return true if successfully
    */
-  bool LoadPT(const std::string& file,
-              const BinaryMessage& pt_content) OVERRIDE;
+  PtProcessingResult LoadPT(const std::string& file,
+                            const BinaryMessage& pt_content) OVERRIDE;
+
+  void OnPTUFinished(const PtProcessingResult ptu_result) OVERRIDE;
 
   /**
    * @brief Resets Policy Table
@@ -853,14 +855,11 @@ class PolicyManagerImpl : public PolicyManager {
   }
 
   /**
-   * @brief Setter for send_on_update_sent_out and wrong_ptu_update_received
+   * @brief Setter for send_on_update_sent_out
    * @param send_on_update_sent_out new value of this flag
-   * @param wrong_ptu_update_received new value of this flag
    */
-  inline void SetSendOnUpdateFlags(const bool send_on_update_sent_out,
-                                   const bool wrong_ptu_update_received) {
+  inline void SetSendOnUpdateFlags(const bool send_on_update_sent_out) {
     send_on_update_sent_out_ = send_on_update_sent_out;
-    wrong_ptu_update_received_ = wrong_ptu_update_received;
   }
 #endif  // BUILD_TESTS
 
@@ -1221,6 +1220,12 @@ class PolicyManagerImpl : public PolicyManager {
                             const AppPoliciesValueType& app_policy);
 
   /**
+   * @brief Resumes all policy actions for all apps, suspended during
+   * PTU applying
+   */
+  void ResumePendingAppPolicyActions();
+
+  /**
    * @brief Gets groups names from collection of groups permissions
    * @param app_group_permissions Collection of groups permissions
    * @return Collection of group names
@@ -1327,11 +1332,6 @@ class PolicyManagerImpl : public PolicyManager {
   friend struct ProccessAppGroups;
 
   /**
-   * @brief Flag for notifying that invalid PTU was received
-   */
-  bool wrong_ptu_update_received_;
-
-  /**
    * @brief Flag for notifying that PTU was started
    */
   bool send_on_update_sent_out_;
@@ -1346,6 +1346,21 @@ class PolicyManagerImpl : public PolicyManager {
    * progress
    */
   bool is_ptu_in_progress_;
+
+  typedef std::list<std::pair<std::string, AppPoliciesValueType> >
+      PendingAppPolicyActionsList;
+
+  /**
+   * @brief List containing device_id and pending permissions structure pairs
+   * which can be processed later on demand
+   */
+  PendingAppPolicyActionsList notify_system_list_;
+
+  /**
+   * @brief List containing device_id and pending permissions structure pairs
+   * which can be processed later on demand
+   */
+  PendingAppPolicyActionsList send_permissions_list_;
 };
 
 }  // namespace policy
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 7fd4624179..2d8df07271 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -226,7 +226,6 @@ PolicyManagerImpl::PolicyManagerImpl(bool in_memory)
     , retry_sequence_index_(0)
     , ignition_check(true)
     , retry_sequence_url_(0, 0, "")
-    , wrong_ptu_update_received_(false)
     , send_on_update_sent_out_(false)
     , trigger_ptu_(false)
     , is_ptu_in_progress_(false) {}
@@ -456,8 +455,8 @@ void FilterPolicyTable(
   }
 }
 
-bool PolicyManagerImpl::LoadPT(const std::string& file,
-                               const BinaryMessage& pt_content) {
+PolicyManager::PtProcessingResult PolicyManagerImpl::LoadPT(
+    const std::string& file, const BinaryMessage& pt_content) {
   LOG4CXX_INFO(logger_, "LoadPT of size " << pt_content.size());
   LOG4CXX_DEBUG(
       logger_,
@@ -467,8 +466,7 @@ bool PolicyManagerImpl::LoadPT(const std::string& file,
   std::shared_ptr<policy_table::Table> pt_update = Parse(pt_content);
   if (!pt_update) {
     LOG4CXX_WARN(logger_, "Parsed table pointer is NULL.");
-    update_status_manager_.OnWrongUpdateReceived();
-    return false;
+    return PtProcessingResult::kWrongPtReceived;
   }
 
   file_system::DeleteFile(file);
@@ -476,85 +474,100 @@ bool PolicyManagerImpl::LoadPT(const std::string& file,
 
   FilterPolicyTable(pt_update->policy_table, current_vd_items);
   if (!IsPTValid(pt_update, policy_table::PT_UPDATE)) {
-    wrong_ptu_update_received_ = true;
-    update_status_manager_.OnWrongUpdateReceived();
-    return false;
+    LOG4CXX_WARN(logger_, "Received policy table update is not valid");
+    return PtProcessingResult::kWrongPtReceived;
   }
 
-  update_status_manager_.OnValidUpdateReceived();
   cache_->SaveUpdateRequired(false);
+  sync_primitives::AutoLock lock(apps_registration_lock_);
 
-  {
-    sync_primitives::AutoLock lock(apps_registration_lock_);
+  // Get current DB data, since it could be updated during awaiting of PTU
+  auto policy_table_snapshot = cache_->GenerateSnapshot();
+  if (!policy_table_snapshot) {
+    LOG4CXX_ERROR(
+        logger_,
+        "Failed to create snapshot of policy table, trying another exchange");
+    return PtProcessingResult::kNewPtRequired;
+  }
 
-    // Get current DB data, since it could be updated during awaiting of PTU
-    std::shared_ptr<policy_table::Table> policy_table_snapshot =
-        cache_->GenerateSnapshot();
-    if (!policy_table_snapshot) {
-      LOG4CXX_ERROR(
-          logger_,
-          "Failed to create snapshot of policy table, trying another exchange");
-      ForcePTExchange();
-      return false;
-    }
+  // Checking of difference between PTU and current policy state
+  // Must to be done before PTU applying since it is possible, that functional
+  // groups, which had been present before are absent in PTU and will be
+  // removed after update. So in case of revoked groups system has to know
+  // names and ids of revoked groups before they will be removed.
+  CheckAppPolicyResults results =
+      CheckPermissionsChanges(pt_update, policy_table_snapshot);
 
-    // Checking of difference between PTU and current policy state
-    // Must to be done before PTU applying since it is possible, that functional
-    // groups, which had been present before are absent in PTU and will be
-    // removed after update. So in case of revoked groups system has to know
-    // names and ids of revoked groups before they will be removed.
-    CheckAppPolicyResults results =
-        CheckPermissionsChanges(pt_update, policy_table_snapshot);
-
-    // Replace current data with updated
-    if (!cache_->ApplyUpdate(*pt_update)) {
-      LOG4CXX_WARN(
-          logger_,
-          "Unsuccessful save of updated policy table, trying another exchange");
-      ForcePTExchange();
-      return false;
-    }
+  // Replace current data with updated
+  if (!cache_->ApplyUpdate(*pt_update)) {
+    LOG4CXX_WARN(
+        logger_,
+        "Unsuccessful save of updated policy table, trying another exchange");
+    return PtProcessingResult::kNewPtRequired;
+  }
 
-    ExternalConsentStatus status = cache_->GetExternalConsentStatus();
-    GroupsByExternalConsentStatus groups_by_status =
-        cache_->GetGroupsWithSameEntities(status);
+  ExternalConsentStatus status = cache_->GetExternalConsentStatus();
+  GroupsByExternalConsentStatus groups_by_status =
+      cache_->GetGroupsWithSameEntities(status);
 
-    ProcessExternalConsentStatusUpdate(
-        groups_by_status, ConsentProcessingPolicy::kExternalConsentBased);
+  ProcessExternalConsentStatusUpdate(
+      groups_by_status, ConsentProcessingPolicy::kExternalConsentBased);
 
-    ProcessAppPolicyCheckResults(
-        results, pt_update->policy_table.app_policies_section.apps);
+  ProcessAppPolicyCheckResults(
+      results, pt_update->policy_table.app_policies_section.apps);
 
-    CheckPermissionsChangesAfterUpdate(*pt_update, *policy_table_snapshot);
+  CheckPermissionsChangesAfterUpdate(*pt_update, *policy_table_snapshot);
 
-    listener_->OnCertificateUpdated(
-        *(pt_update->policy_table.module_config.certificate));
+  listener_->OnCertificateUpdated(
+      *(pt_update->policy_table.module_config.certificate));
 
-    std::map<std::string, StringArray> app_hmi_types;
-    cache_->GetHMIAppTypeAfterUpdate(app_hmi_types);
-    if (!app_hmi_types.empty()) {
-      LOG4CXX_INFO(logger_, "app_hmi_types is full calling OnUpdateHMIAppType");
-      listener_->OnUpdateHMIAppType(app_hmi_types);
-    } else {
-      LOG4CXX_INFO(logger_, "app_hmi_types empty");
-    }
+  std::map<std::string, StringArray> app_hmi_types;
+  cache_->GetHMIAppTypeAfterUpdate(app_hmi_types);
+  if (!app_hmi_types.empty()) {
+    LOG4CXX_INFO(logger_, "app_hmi_types is full calling OnUpdateHMIAppType");
+    listener_->OnUpdateHMIAppType(app_hmi_types);
+  } else {
+    LOG4CXX_INFO(logger_, "app_hmi_types empty");
+  }
 
-    std::vector<std::string> enabled_apps;
-    cache_->GetEnabledCloudApps(enabled_apps);
-    for (auto it = enabled_apps.begin(); it != enabled_apps.end(); ++it) {
-      SendAuthTokenUpdated(*it);
-    }
+  std::vector<std::string> enabled_apps;
+  cache_->GetEnabledCloudApps(enabled_apps);
+  for (auto it = enabled_apps.begin(); it != enabled_apps.end(); ++it) {
+    SendAuthTokenUpdated(*it);
+  }
+
+  return PtProcessingResult::kSuccess;
+}
+
+void PolicyManagerImpl::OnPTUFinished(const PtProcessingResult ptu_result) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (PtProcessingResult::kWrongPtReceived == ptu_result) {
+    LOG4CXX_DEBUG(logger_, "Wrong PT was received");
+    update_status_manager_.OnWrongUpdateReceived();
+    return;
+  }
+
+  update_status_manager_.OnValidUpdateReceived();
+
+  if (PtProcessingResult::kNewPtRequired == ptu_result) {
+    LOG4CXX_DEBUG(logger_, "New PTU interation is required");
+    ForcePTExchange();
+    return;
   }
 
+  ResumePendingAppPolicyActions();
+
   // If there was a user request for policy table update, it should be started
   // right after current update is finished
   if (update_status_manager_.IsUpdateRequired()) {
+    LOG4CXX_DEBUG(logger_,
+                  "PTU was successful and new PTU iteration was scheduled");
     StartPTExchange();
-    return true;
+    return;
   }
 
   RefreshRetrySequence();
-  return true;
 }
 
 CheckAppPolicyResults PolicyManagerImpl::CheckPermissionsChanges(
@@ -599,6 +612,9 @@ void PolicyManagerImpl::ProcessAppPolicyCheckResults(
 void PolicyManagerImpl::ProcessActionsForAppPolicies(
     const ApplicationsPoliciesActions& actions,
     const policy_table::ApplicationPolicies& app_policies) {
+  notify_system_list_.clear();
+  send_permissions_list_.clear();
+
   for (const auto& action : actions) {
     const auto& app_policy = app_policies.find(action.first);
     if (app_policies.end() == app_policy) {
@@ -622,11 +638,12 @@ void PolicyManagerImpl::ProcessActionsForAppPolicies(
       }
 
       if (action.second.is_notify_system) {
-        NotifySystem(device_id, *app_policy);
+        notify_system_list_.push_back(std::make_pair(device_id, *app_policy));
       }
 
       if (action.second.is_send_permissions_to_app) {
-        SendPermissionsToApp(device_id, *app_policy);
+        send_permissions_list_.push_back(
+            std::make_pair(device_id, *app_policy));
       }
     }
   }
@@ -1671,6 +1688,21 @@ void PolicyManagerImpl::UpdateAppConsentWithExternalConsent(
   cache_->SetExternalConsentForApp(updated_external_consent_permissions);
 }
 
+void PolicyManagerImpl::ResumePendingAppPolicyActions() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  for (auto& notify_system_params : notify_system_list_) {
+    NotifySystem(notify_system_params.first, notify_system_params.second);
+  }
+  notify_system_list_.clear();
+
+  for (auto& send_permissions_params : send_permissions_list_) {
+    SendPermissionsToApp(send_permissions_params.first,
+                         send_permissions_params.second);
+  }
+  send_permissions_list_.clear();
+}
+
 void PolicyManagerImpl::NotifySystem(
     const std::string& device_id,
     const PolicyManagerImpl::AppPoliciesValueType& app_policy) const {
@@ -1871,7 +1903,8 @@ std::string PolicyManagerImpl::ForcePTExchange() {
 
 void policy::PolicyManagerImpl::StopRetrySequence() {
   LOG4CXX_AUTO_TRACE(logger_);
-  if (update_status_manager_.IsUpdateRequired()) {
+
+  if (cache_->UpdateRequired()) {
     ResetRetrySequence(ResetRetryCountType::kResetWithStatusUpdate);
   }
 }
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 49390b3aa1..333f4e8f84 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
@@ -110,10 +110,13 @@ TEST_F(PolicyManagerImplTest2, GetNotificationsNumberAfterPTUpdate) {
   // Act
   std::string json = table.toStyledString();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 
+  EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   std::string priority = "EMERGENCY";
   uint32_t notif_number = policy_manager_->GetNotificationsNumber(priority);
   EXPECT_EQ(1u, notif_number);
@@ -162,7 +165,10 @@ TEST_F(PolicyManagerImplTest2, IsAppRevoked_SetRevokedAppID_ExpectAppRevoked) {
   ifile.close();
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
   CheckRpcPermissions(
       app_id_1_, "UnregisterAppInterface", ::policy::kRpcDisallowed);
@@ -253,7 +259,10 @@ TEST_F(PolicyManagerImplTest2,
   ifile.close();
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   policy_manager_->CheckPermissions(
@@ -323,7 +332,10 @@ TEST_F(PolicyManagerImplTest2,
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
   // Load Json to cache
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   policy_table::RpcParameters rpc_parameters;
@@ -798,7 +810,10 @@ TEST_F(PolicyManagerImplTest2,
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Check RPC in each level
@@ -897,7 +912,10 @@ TEST_F(PolicyManagerImplTest2,
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Check RPC in each level
@@ -978,15 +996,20 @@ TEST_F(PolicyManagerImplTest, LoadPT_SetInvalidUpdatePT_PTIsNotLoaded) {
   // Assert
   EXPECT_CALL(*cache_manager_, ApplyUpdate(_)).Times(0);
   EXPECT_CALL(listener_, GetAppName(_)).Times(0);
-  EXPECT_CALL(listener_, OnUpdateStatusChanged(_)).Times(1);
   EXPECT_CALL(*cache_manager_, SaveUpdateRequired(false)).Times(0);
   EXPECT_CALL(*cache_manager_, TimeoutResponse()).Times(0);
   EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_)).Times(0);
   EXPECT_CALL(*cache_manager_, GetVehicleDataItems())
       .WillOnce(Return(std::vector<policy_table::VehicleDataItem>()));
-  EXPECT_FALSE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kWrongPtReceived,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+
   EXPECT_CALL(*cache_manager_, IsPTPreloaded());
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+
+  EXPECT_CALL(listener_, OnUpdateStatusChanged(_)).Times(1);
+  policy_manager_->OnPTUFinished(
+      PolicyManager::PtProcessingResult::kWrongPtReceived);
 }
 
 TEST_F(
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 ef5e3e98bc..809c0b5599 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
@@ -107,7 +107,7 @@ TEST_F(PolicyManagerImplTest, LoadPT_SetPT_PTIsLoaded) {
   EXPECT_CALL(*cache_manager_, DaysBeforeExchange(_))
       .WillOnce(Return(kNonZero));
   policy_manager_->ForcePTExchange();
-  policy_manager_->SetSendOnUpdateFlags(true, false);
+  policy_manager_->SetSendOnUpdateFlags(true);
   policy_manager_->OnUpdateStarted();
   Json::Value table = createPTforLoad();
 
@@ -131,16 +131,20 @@ TEST_F(PolicyManagerImplTest, LoadPT_SetPT_PTIsLoaded) {
   EXPECT_CALL(*cache_manager_, ApplyUpdate(_)).WillOnce(Return(true));
   EXPECT_CALL(listener_, GetDevicesIds("1234"))
       .WillRepeatedly(Return(transport_manager::DeviceList()));
-  EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
   EXPECT_CALL(*cache_manager_, SaveUpdateRequired(false));
-  EXPECT_CALL(*cache_manager_, TimeoutResponse());
-  EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_));
 
   EXPECT_CALL(*cache_manager_, GetVehicleDataItems())
       .WillOnce(Return(std::vector<policy_table::VehicleDataItem>()));
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+
   EXPECT_CALL(*cache_manager_, IsPTPreloaded());
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
+
+  EXPECT_CALL(*cache_manager_, TimeoutResponse());
+  EXPECT_CALL(*cache_manager_, SecondsBetweenRetries(_));
+  EXPECT_CALL(listener_, OnUpdateStatusChanged(_));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
 }
 
 TEST_F(PolicyManagerImplTest2,
@@ -182,7 +186,7 @@ TEST_F(PolicyManagerImplTest2, ResetRetrySequence) {
   policy_manager_->ResetRetrySequence(
       policy::ResetRetryCountType::kResetWithStatusUpdate);
   EXPECT_EQ("UPDATE_NEEDED", policy_manager_->GetPolicyTableStatus());
-  policy_manager_->SetSendOnUpdateFlags(false, false);
+  policy_manager_->SetSendOnUpdateFlags(false);
   policy_manager_->OnUpdateStarted();
   EXPECT_EQ("UPDATING", policy_manager_->GetPolicyTableStatus());
 }
@@ -863,7 +867,9 @@ TEST_F(PolicyManagerImplTest_ExternalConsent,
 
   EXPECT_CALL(listener_, OnCertificateUpdated(_));
 
-  EXPECT_TRUE(policy_manager_->LoadPT("DummyFileName", msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT("DummyFileName", msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
 
   pt = policy_manager_->GetCache()->GetPT();
 
@@ -982,7 +988,9 @@ TEST_F(PolicyManagerImplTest_ExternalConsent,
 
   EXPECT_CALL(listener_, OnCertificateUpdated(_));
 
-  EXPECT_TRUE(policy_manager_->LoadPT("DummyFileName", msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT("DummyFileName", msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
 
   pt = policy_manager_->GetCache()->GetPT();
 
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 81e5c77ff0..b3c85df65b 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
@@ -291,7 +291,9 @@ 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(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
   return root;
 }
@@ -478,7 +480,10 @@ void PolicyManagerImplTest2::
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(cache->IsPTPreloaded());
 
   // Check RPC in each level
@@ -584,7 +589,9 @@ void PolicyManagerImplTest2::EmulatePTAppRevoked(const std::string& ptu_name) {
   ifile.close();
 
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  ASSERT_TRUE(policy_manager_->LoadPT(kDummyUpdateFileName, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kDummyUpdateFileName, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
 }
 
 // To avoid duplicate arrange of test
@@ -622,7 +629,10 @@ void PolicyManagerImplTest2::LoadPTUFromJsonFile(
   json = root.toStyledString();
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
-  EXPECT_TRUE(policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  ASSERT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_->OnPTUFinished(PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(policy_manager_->GetCache()->IsPTPreloaded());
 }
 
@@ -683,7 +693,11 @@ const Json::Value PolicyManagerImplTest_RequestTypes::GetPTU(
   ifile.close();
   ::policy::BinaryMessage msg(json.begin(), json.end());
   // Load Json to cache
-  EXPECT_TRUE(policy_manager_impl_sptr_->LoadPT(kFilePtUpdateJson, msg));
+  EXPECT_EQ(PolicyManager::PtProcessingResult::kSuccess,
+            policy_manager_impl_sptr_->LoadPT(kFilePtUpdateJson, msg));
+  policy_manager_impl_sptr_->OnPTUFinished(
+      PolicyManager::PtProcessingResult::kSuccess);
+
   EXPECT_FALSE(policy_manager_impl_sptr_->GetCache()->IsPTPreloaded());
   return root;
 }