diff --git a/tests/meson.build b/tests/meson.build
index 27cdb42..89c6a00 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -1,5 +1,5 @@
-gtest_dep = dependency('gtest', main: false, required: false, version: '>=1.10.0')
-gmock_dep = dependency('gmock', required: false, version: '>=1.10.0')
+gtest_dep = dependency('gtest', main: false, required: false, version: '>=1.11.0')
+gmock_dep = dependency('gmock', required: false, version: '>=1.11.0')
 if not gtest_dep.found() or not gmock_dep.found()
     gtest_proj = import('cmake').subproject('googletest')
     gtest_dep = gtest_proj.dependency('gtest')
@@ -29,6 +29,7 @@
             '../src/types/report_types.cpp',
             '../src/utils/conversion_trigger.cpp',
             '../src/utils/generate_id.cpp',
+            '../src/utils/messanger_service.cpp',
             'src/dbus_environment.cpp',
             'src/main.cpp',
             'src/stubs/dbus_sensor_object.cpp',
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index cf9047f..6a7d8bd 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -37,7 +37,7 @@
                 WithArgs<1>(Invoke(&ReportFactoryMock::convertToLabeled)));
 
         ON_CALL(*this,
-                make(A<const std::string&>(), _, _, _, _, _, _, _, _, _, _, _))
+                make(A<const std::string&>(), _, _, _, _, _, _, _, _, _, _))
             .WillByDefault(WithArgs<0>(Invoke([](const std::string& id) {
                 return std::make_unique<NiceMock<ReportMock>>(id);
             })));
@@ -52,7 +52,7 @@
                  const std::vector<ReportAction>&, Milliseconds, uint64_t,
                  const ReportUpdates, interfaces::ReportManager&,
                  interfaces::JsonStorage&, std::vector<LabeledMetricParameters>,
-                 bool, const std::vector<std::string>&),
+                 bool),
                 (const, override));
 
     auto& expectMake(
@@ -69,12 +69,11 @@
                             params.reportingType(), params.reportActions(),
                             params.interval(), params.appendLimit(),
                             params.reportUpdates(), rm, js,
-                            params.metricParameters(), params.enabled(), _));
+                            params.metricParameters(), params.enabled()));
         }
         else
         {
-            return EXPECT_CALL(*this,
-                               make(_, _, _, _, _, _, _, rm, js, _, _, _));
+            return EXPECT_CALL(*this, make(_, _, _, _, _, _, _, rm, js, _, _));
         }
     }
 };
diff --git a/tests/src/mocks/report_manager_mock.hpp b/tests/src/mocks/report_manager_mock.hpp
index 25f40a0..872a6e6 100644
--- a/tests/src/mocks/report_manager_mock.hpp
+++ b/tests/src/mocks/report_manager_mock.hpp
@@ -8,9 +8,4 @@
 {
   public:
     MOCK_METHOD(void, removeReport, (const interfaces::Report*), (override));
-    MOCK_METHOD(void, updateReport, (const std::string& name), (override));
-    MOCK_METHOD(void, updateTriggerIds,
-                (const std::string& reportId, const std::string& triggerId,
-                 TriggerIdUpdate updateType),
-                (override));
 };
diff --git a/tests/src/mocks/report_mock.hpp b/tests/src/mocks/report_mock.hpp
index 6ececfc..c7c900f 100644
--- a/tests/src/mocks/report_mock.hpp
+++ b/tests/src/mocks/report_mock.hpp
@@ -23,10 +23,6 @@
 
     MOCK_METHOD(std::string, getId, (), (override, const));
     MOCK_METHOD(std::string, getPath, (), (override, const));
-    MOCK_METHOD(void, updateReadings, (), (override));
-    MOCK_METHOD(void, updateTriggerIds,
-                (const std::string& triggerId, TriggerIdUpdate updateType),
-                (override));
 
     MOCK_METHOD(void, Die, ());
 };
diff --git a/tests/src/mocks/trigger_manager_mock.hpp b/tests/src/mocks/trigger_manager_mock.hpp
index f9f898d..9377d2a 100644
--- a/tests/src/mocks/trigger_manager_mock.hpp
+++ b/tests/src/mocks/trigger_manager_mock.hpp
@@ -9,6 +9,4 @@
   public:
     MOCK_METHOD(void, removeTrigger, (const interfaces::Trigger* trigger),
                 (override));
-    MOCK_METHOD(std::vector<std::string>, getTriggerIdsForReport,
-                (const std::string& reportId), (const, override));
 };
diff --git a/tests/src/mocks/trigger_mock.hpp b/tests/src/mocks/trigger_mock.hpp
index bb38257..cd0e5f4 100644
--- a/tests/src/mocks/trigger_mock.hpp
+++ b/tests/src/mocks/trigger_mock.hpp
@@ -23,7 +23,5 @@
 
     MOCK_METHOD(std::string, getId, (), (const, override));
     MOCK_METHOD(std::string, getPath, (), (const, override));
-    MOCK_METHOD(const std::vector<std::string>&, getReportIds, (),
-                (const, override));
     MOCK_METHOD(void, Die, ());
 };
diff --git a/tests/src/params/report_params.hpp b/tests/src/params/report_params.hpp
index f6e547e..19ea519 100644
--- a/tests/src/params/report_params.hpp
+++ b/tests/src/params/report_params.hpp
@@ -108,17 +108,6 @@
         return metricParametersProperty;
     }
 
-    ReportParams& triggerIds(std::vector<std::string> val)
-    {
-        triggerIdsProperty = std::move(val);
-        return *this;
-    }
-
-    std::vector<std::string> triggerIds() const
-    {
-        return triggerIdsProperty;
-    }
-
   private:
     std::string reportIdProperty = "TestId";
     std::string reportNameProperty = "TestReport";
@@ -144,6 +133,5 @@
              "MetricId2",
              CollectionTimeScope::point,
              CollectionDuration(Milliseconds(0u))}}};
-    std::vector<std::string> triggerIdsProperty{};
     bool enabledProperty = true;
 };
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
index 3e6b049..4e3ce8d 100644
--- a/tests/src/test_report.cpp
+++ b/tests/src/test_report.cpp
@@ -1,6 +1,9 @@
 #include "dbus_environment.hpp"
 #include "fakes/clock_fake.hpp"
 #include "helpers.hpp"
+#include "messages/collect_trigger_id.hpp"
+#include "messages/trigger_presence_changed_ind.hpp"
+#include "messages/update_report_ind.hpp"
 #include "mocks/json_storage_mock.hpp"
 #include "mocks/metric_mock.hpp"
 #include "mocks/report_manager_mock.hpp"
@@ -10,6 +13,7 @@
 #include "utils/clock.hpp"
 #include "utils/contains.hpp"
 #include "utils/conv_container.hpp"
+#include "utils/messanger.hpp"
 #include "utils/transform.hpp"
 #include "utils/tstring.hpp"
 
@@ -34,10 +38,11 @@
     std::unique_ptr<ClockFake> clockFakePtr = std::make_unique<ClockFake>();
     ClockFake& clockFake = *clockFakePtr;
     std::unique_ptr<Report> sut;
+    utils::Messanger messanger;
 
     MockFunction<void()> checkPoint;
 
-    TestReport()
+    TestReport() : messanger(DbusEnvironment::getIoc())
     {
         clockFake.system.set(systemTimestamp);
     }
@@ -86,7 +91,7 @@
             params.reportUpdates(), *reportManagerMock, storageMock,
             utils::convContainer<std::shared_ptr<interfaces::Metric>>(
                 metricMocks),
-            params.enabled(), std::move(clockFakePtr), params.triggerIds());
+            params.enabled(), std::move(clockFakePtr));
     }
 
     template <class T>
@@ -256,57 +261,70 @@
     EXPECT_THAT(ec, Eq(boost::system::errc::success));
 }
 
-TEST_F(TestReport, triggerIdsAreUpdatedProperly)
+TEST_F(TestReport, updatesTriggerIdWhenTriggerIsAdded)
 {
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Add);
-    EXPECT_THAT(
-        getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger1"));
+    utils::Messanger messanger(DbusEnvironment::getIoc());
 
-    sut->updateTriggerIds("trigger2", TriggerIdUpdate::Add);
-    EXPECT_THAT(
-        getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger1", "trigger2"));
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger2", {"someOtherReport"}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist,
+        "trigger3",
+        {"someOtherReport", defaultParams.reportId()}});
 
-    sut->updateTriggerIds("trigger3", TriggerIdUpdate::Add);
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger1", "trigger2", "trigger3"));
-
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Remove);
-    EXPECT_THAT(
-        getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger2", "trigger3"));
+        UnorderedElementsAre("trigger1", "trigger3"));
 }
 
-TEST_F(TestReport, successWhenRemovingSameTriggerIdMultipleTimes)
+TEST_F(TestReport, updatesTriggerIdWhenTriggerIsRemoved)
 {
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Add);
-    sut->updateTriggerIds("trigger2", TriggerIdUpdate::Add);
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Remove);
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Remove);
+    utils::Messanger messanger(DbusEnvironment::getIoc());
+
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger2", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Removed, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Removed, "trigger2", {}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Removed, "trigger1", {defaultParams.reportId()}});
+
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger2"));
+        UnorderedElementsAre("trigger3"));
 }
 
-TEST_F(TestReport, successWhenRemovingNonExistingTriggerId)
+TEST_F(TestReport, updatesTriggerIdWhenTriggerIsModified)
 {
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Add);
-    sut->updateTriggerIds("notTrigger", TriggerIdUpdate::Remove);
-    EXPECT_THAT(
-        getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger1"));
-}
+    utils::Messanger messanger(DbusEnvironment::getIoc());
 
-TEST_F(TestReport, noDuplicatesWhenSameTriggerIdIsAdded)
-{
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Add);
-    sut->updateTriggerIds("trigger2", TriggerIdUpdate::Add);
-    sut->updateTriggerIds("trigger1", TriggerIdUpdate::Add);
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger2", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger2", {}});
+    messanger.send(messages::TriggerPresenceChangedInd{
+        messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
-        UnorderedElementsAre("trigger1", "trigger2"));
+        UnorderedElementsAre("trigger1", "trigger3"));
 }
 
 class TestReportStore :
@@ -462,29 +480,38 @@
                 Eq(GetParam().reportingType()));
 }
 
-TEST_P(TestReportAllReportTypes, updateReadingsCallEnabledPropertyOff)
+TEST_P(TestReportAllReportTypes, readingsAreUpdated)
+{
+    clockFake.system.advance(10ms);
+
+    messanger.send(messages::UpdateReportInd{{sut->getId()}});
+    const auto [timestamp, readings] =
+        getProperty<Readings>(sut->getPath(), "Readings");
+
+    EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
+}
+
+TEST_P(TestReportAllReportTypes, readingsAreNotUpdatedWhenReportIsDisabled)
 {
     clockFake.system.advance(10ms);
 
     setProperty(sut->getPath(), "Enabled", false);
-    sut->updateReadings();
+    messanger.send(messages::UpdateReportInd{{sut->getId()}});
     const auto [timestamp, readings] =
         getProperty<Readings>(sut->getPath(), "Readings");
 
-    EXPECT_THAT(getProperty<bool>(sut->getPath(), "Enabled"), Eq(false));
     EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
 }
 
-TEST_P(TestReportAllReportTypes, updateReadingsCallEnabledPropertyOn)
+TEST_P(TestReportAllReportTypes, readingsAreNotUpdatedWhenReportIdDiffers)
 {
     clockFake.system.advance(10ms);
 
-    sut->updateReadings();
+    messanger.send(messages::UpdateReportInd{{sut->getId() + "x"s}});
     const auto [timestamp, readings] =
         getProperty<Readings>(sut->getPath(), "Readings");
 
-    EXPECT_THAT(getProperty<bool>(sut->getPath(), "Enabled"), Eq(true));
-    EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
+    EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
 }
 
 class TestReportOnRequestType : public TestReport
@@ -714,7 +741,7 @@
 {
     for (int i = 0; i < 4; i++)
     {
-        sut->updateReadings();
+        messanger.send(messages::UpdateReportInd{{sut->getId()}});
     }
 
     const auto [timestamp, readings] =
@@ -841,7 +868,15 @@
 
 TEST_F(TestReportInitialization, triggerIdsPropertyIsInitialzed)
 {
-    sut = makeReport(ReportParams().triggerIds({"trigger1", "trigger2"}));
+    for (const auto& triggerId : {"trigger1", "trigger2"})
+    {
+        messanger.on_receive<messages::CollectTriggerIdReq>(
+            [&](const auto& msg) {
+                messanger.send(messages::CollectTriggerIdResp{triggerId});
+            });
+    }
+
+    sut = makeReport(ReportParams());
 
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index bf76efc..fca6451 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -31,9 +31,6 @@
         std::make_unique<NiceMock<ReportMock>>(reportParams.reportId());
     ReportMock& reportMock = *reportMockPtr;
 
-    std::unique_ptr<interfaces::TriggerManager> triggerManagerMockPtr =
-        std::make_unique<NiceMock<TriggerManagerMock>>();
-
     std::unique_ptr<ReportManager> sut;
 
     MockFunction<void(std::string)> checkPoint;
@@ -43,9 +40,9 @@
         EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _))
             .Times(AnyNumber());
 
-        sut = std::make_unique<ReportManager>(
-            std::move(reportFactoryMockPtr), std::move(storageMockPtr),
-            DbusEnvironment::getObjServer(), triggerManagerMockPtr);
+        sut = std::make_unique<ReportManager>(std::move(reportFactoryMockPtr),
+                                              std::move(storageMockPtr),
+                                              DbusEnvironment::getObjServer());
     }
 
     void TearDown() override
@@ -363,52 +360,6 @@
     checkPoint.Call("end");
 }
 
-TEST_F(TestReportManager, updateReportCallsUpdateReadingsForExistReport)
-{
-    reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
-        .WillOnce(Return(ByMove(std::move(reportMockPtr))));
-    EXPECT_CALL(reportMock, updateReadings());
-
-    addReport(reportParams);
-    sut->updateReport(reportParams.reportId());
-}
-
-TEST_F(TestReportManager, updateReportDoNothingIfReportDoesNotExist)
-{
-    reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
-        .WillOnce(Return(ByMove(std::move(reportMockPtr))));
-    EXPECT_CALL(reportMock, updateReadings()).Times(0);
-
-    addReport(reportParams);
-    sut->updateReport("NotAReport");
-}
-
-TEST_F(TestReportManager, updateTriggerIdsUpdatesThemForExistReport)
-{
-    reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
-        .WillOnce(Return(ByMove(std::move(reportMockPtr))));
-    EXPECT_CALL(reportMock, updateTriggerIds("Trigger1", TriggerIdUpdate::Add));
-    EXPECT_CALL(reportMock,
-                updateTriggerIds("Trigger2", TriggerIdUpdate::Remove));
-
-    addReport(reportParams);
-    sut->updateTriggerIds(reportParams.reportId(), "Trigger1",
-                          TriggerIdUpdate::Add);
-
-    sut->updateTriggerIds(reportParams.reportId(), "Trigger2",
-                          TriggerIdUpdate::Remove);
-}
-
-TEST_F(TestReportManager, updateTriggerIdsDoNothingIfReportDoesNotExist)
-{
-    reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
-        .WillOnce(Return(ByMove(std::move(reportMockPtr))));
-    EXPECT_CALL(reportMock, updateTriggerIds(_, _)).Times(0);
-
-    addReport(reportParams);
-    sut->updateTriggerIds("NotAReport", "Trigger1", TriggerIdUpdate::Add);
-}
-
 class TestReportManagerWithAggregationOperationType :
     public TestReportManager,
     public WithParamInterface<OperationType>
@@ -462,9 +413,9 @@
 
     void makeReportManager()
     {
-        sut = std::make_unique<ReportManager>(
-            std::move(reportFactoryMockPtr), std::move(storageMockPtr),
-            DbusEnvironment::getObjServer(), triggerManagerMockPtr);
+        sut = std::make_unique<ReportManager>(std::move(reportFactoryMockPtr),
+                                              std::move(storageMockPtr),
+                                              DbusEnvironment::getObjServer());
     }
 
     nlohmann::json data = nlohmann::json{
diff --git a/tests/src/test_trigger.cpp b/tests/src/test_trigger.cpp
index 5ad2a81..cfb08e9 100644
--- a/tests/src/test_trigger.cpp
+++ b/tests/src/test_trigger.cpp
@@ -1,5 +1,7 @@
 #include "dbus_environment.hpp"
 #include "helpers.hpp"
+#include "messages/collect_trigger_id.hpp"
+#include "messages/trigger_presence_changed_ind.hpp"
 #include "mocks/json_storage_mock.hpp"
 #include "mocks/report_manager_mock.hpp"
 #include "mocks/sensor_mock.hpp"
@@ -10,6 +12,7 @@
 #include "trigger.hpp"
 #include "trigger_manager.hpp"
 #include "utils/conversion_trigger.hpp"
+#include "utils/messanger.hpp"
 #include "utils/transform.hpp"
 #include "utils/tstring.hpp"
 
@@ -44,9 +47,18 @@
     std::unique_ptr<TriggerFactoryMock> triggerFactoryMockPtr =
         std::make_unique<NiceMock<TriggerFactoryMock>>();
     testing::NiceMock<StorageMock> storageMock;
+    NiceMock<MockFunction<void(const messages::TriggerPresenceChangedInd)>>
+        triggerPresenceChanged;
     std::vector<std::shared_ptr<interfaces::Threshold>> thresholdMocks;
+    utils::Messanger messanger;
     std::unique_ptr<Trigger> sut;
 
+    TestTrigger() : messanger(DbusEnvironment::getIoc())
+    {
+        messanger.on_receive<messages::TriggerPresenceChangedInd>(
+            [this](const auto& msg) { triggerPresenceChanged.Call(msg); });
+    }
+
     void SetUp() override
     {
         sut = makeTrigger(triggerParams);
@@ -73,8 +85,7 @@
                 params.reportIds().begin(), params.reportIds().end()),
             std::vector<std::shared_ptr<interfaces::Threshold>>(thresholdMocks),
             *triggerManagerMockPtr, storageMock, *triggerFactoryMockPtr,
-            SensorMock::makeSensorMocks(params.sensors()),
-            *reportManagerMockPtr);
+            SensorMock::makeSensorMocks(params.sensors()));
     }
 
     static interfaces::JsonStorage::FilePath to_file_path(std::string name)
@@ -140,7 +151,6 @@
 {
     EXPECT_THAT(sut->getId(), Eq(triggerParams.id()));
     EXPECT_THAT(sut->getPath(), Eq(Trigger::triggerDir + triggerParams.id()));
-    EXPECT_THAT(sut->getReportIds(), Eq(triggerParams.reportIds()));
 }
 
 TEST_F(TestTrigger, setPropertyNameToCorrectValue)
@@ -159,56 +169,28 @@
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "ReportNames"),
         Eq(newNames));
-    EXPECT_THAT(
-        getProperty<std::vector<std::string>>(sut->getPath(), "ReportNames"),
-        Eq(sut->getReportIds()));
 }
 
-TEST_F(TestTrigger, settingPropertyReportNamesUptadesTriggerIdsInReports)
+TEST_F(TestTrigger, sendsUpdateWhenReportNamesChanges)
 {
-    std::vector<std::string> newPropertyVal = {"abc", "one", "two"};
+    const std::vector<std::string> newPropertyVal = {"abc", "one", "two"};
 
-    for (const auto& reportId : newPropertyVal)
-    {
-        EXPECT_CALL(
-            *reportManagerMockPtr,
-            updateTriggerIds(reportId, sut->getId(), TriggerIdUpdate::Add));
-    }
-    for (const auto& reportId : triggerParams.reportIds())
-    {
-        EXPECT_CALL(
-            *reportManagerMockPtr,
-            updateTriggerIds(reportId, sut->getId(), TriggerIdUpdate::Remove));
-    }
+    EXPECT_CALL(triggerPresenceChanged,
+                Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
+                               UnorderedElementsAreArray(newPropertyVal))));
 
     EXPECT_THAT(setProperty(sut->getPath(), "ReportNames", newPropertyVal),
                 Eq(boost::system::errc::success));
 }
 
-TEST_F(TestTrigger, settingPropertyReportNamesWillNotRemoveTriggerIdsInReports)
+TEST_F(TestTrigger, sendsUpdateWhenReportNamesChangesToSameValue)
 {
-    std::vector<std::string> newPropertyVal = triggerParams.reportIds();
-    std::vector<std::string> newNames{"abc", "one", "two"};
-    newPropertyVal.insert(newPropertyVal.end(), newNames.begin(),
-                          newNames.end());
+    const std::vector<std::string> newPropertyVal = triggerParams.reportIds();
 
-    for (const auto& reportId : newNames)
-    {
-        EXPECT_CALL(
-            *reportManagerMockPtr,
-            updateTriggerIds(reportId, sut->getId(), TriggerIdUpdate::Add));
-    }
-
-    EXPECT_THAT(setProperty(sut->getPath(), "ReportNames", newPropertyVal),
-                Eq(boost::system::errc::success));
-}
-
-TEST_F(TestTrigger,
-       settingPropertyReportNamesToSameValueWillNotUpdateTriggerIdsInReports)
-{
-    std::vector<std::string> newPropertyVal = triggerParams.reportIds();
-
-    EXPECT_CALL(*reportManagerMockPtr, updateTriggerIds(_, _, _)).Times(0);
+    EXPECT_CALL(
+        triggerPresenceChanged,
+        Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
+                       UnorderedElementsAreArray(triggerParams.reportIds()))));
 
     EXPECT_THAT(setProperty(sut->getPath(), "ReportNames", newPropertyVal),
                 Eq(boost::system::errc::success));
@@ -217,9 +199,9 @@
 TEST_F(TestTrigger,
        DISABLED_settingPropertyReportNamesThrowsExceptionWhenDuplicateReportIds)
 {
-    std::vector<std::string> newPropertyVal{"trigger1", "trigger2", "trigger1"};
+    std::vector<std::string> newPropertyVal{"report1", "report2", "report1"};
 
-    EXPECT_CALL(*reportManagerMockPtr, updateTriggerIds(_, _, _)).Times(0);
+    EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
 
     EXPECT_THAT(setProperty(sut->getPath(), "ReportNames", newPropertyVal),
                 Eq(boost::system::errc::invalid_argument));
@@ -306,12 +288,17 @@
 {
     EXPECT_CALL(storageMock, remove(to_file_path(sut->getId())));
     EXPECT_CALL(*triggerManagerMockPtr, removeTrigger(sut.get()));
-    for (const auto& reportId : triggerParams.reportIds())
-    {
-        EXPECT_CALL(
-            *reportManagerMockPtr,
-            updateTriggerIds(reportId, sut->getId(), TriggerIdUpdate::Remove));
-    }
+
+    auto ec = deleteTrigger(sut->getPath());
+    EXPECT_THAT(ec, Eq(boost::system::errc::success));
+}
+
+TEST_F(TestTrigger, sendUpdateWhenTriggerIsDeleted)
+{
+    EXPECT_CALL(triggerPresenceChanged,
+                Call(FieldsAre(messages::Presence::Removed, triggerParams.id(),
+                               UnorderedElementsAre())));
+
     auto ec = deleteTrigger(sut->getPath());
     EXPECT_THAT(ec, Eq(boost::system::errc::success));
 }
@@ -363,12 +350,10 @@
 
 TEST_F(TestTriggerInitialization, creatingTriggerUpdatesTriggersIdsInReports)
 {
-    for (const auto& reportId : triggerParams.reportIds())
-    {
-        EXPECT_CALL(*reportManagerMockPtr,
-                    updateTriggerIds(reportId, triggerParams.id(),
-                                     TriggerIdUpdate::Add));
-    }
+    EXPECT_CALL(
+        triggerPresenceChanged,
+        Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
+                       UnorderedElementsAreArray(triggerParams.reportIds()))));
 
     sut = makeTrigger(triggerParams);
 }
diff --git a/tests/src/test_trigger_actions.cpp b/tests/src/test_trigger_actions.cpp
index b902e5a..d3e36b8 100644
--- a/tests/src/test_trigger_actions.cpp
+++ b/tests/src/test_trigger_actions.cpp
@@ -1,8 +1,12 @@
-#include "mocks/report_manager_mock.hpp"
+#include "dbus_environment.hpp"
+#include "messages/update_report_ind.hpp"
 #include "trigger_actions.hpp"
+#include "utils/messanger.hpp"
 
 #include <stdexcept>
 
+#include <gmock/gmock.h>
+
 using namespace testing;
 
 namespace action
@@ -218,20 +222,27 @@
 class TestUpdateReport : public Test
 {
   public:
+    TestUpdateReport() : messanger(DbusEnvironment::getIoc())
+    {}
+
     void make(std::vector<std::string> names)
     {
+        messanger.on_receive<messages::UpdateReportInd>(
+            [this](const auto& msg) { updateReport.Call(msg); });
+
         sut = std::make_unique<UpdateReport>(
-            reportManager,
+            DbusEnvironment::getIoc(),
             std::make_shared<std::vector<std::string>>(std::move(names)));
     }
 
-    NiceMock<ReportManagerMock> reportManager;
+    utils::Messanger messanger;
+    NiceMock<MockFunction<void(const messages::UpdateReportInd&)>> updateReport;
     std::unique_ptr<UpdateReport> sut;
 };
 
 TEST_F(TestUpdateReport, commitWhenReportNameIsEmptyExpectNoReportUpdate)
 {
-    EXPECT_CALL(reportManager, updateReport(_)).Times(0);
+    EXPECT_CALL(updateReport, Call(_)).Times(0);
 
     make({});
     sut->commit("Test", Milliseconds{100'000}, 90.0);
@@ -240,10 +251,8 @@
 TEST_F(TestUpdateReport, commitExpectReportUpdate)
 {
     std::vector<std::string> names = {"Report1", "Report2", "Report3"};
-    for (const auto& name : names)
-    {
-        EXPECT_CALL(reportManager, updateReport(name));
-    }
+    EXPECT_CALL(updateReport,
+                Call(FieldsAre(UnorderedElementsAreArray(names))));
 
     make(names);
     sut->commit("Test", Milliseconds{100'000}, 90.0);