diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index 58c71d6..c2e4dd2 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -16,7 +16,7 @@
             return LabeledMetricParameters(
                 utils::transform(std::get<0>(params),
                                  [](const auto& sensorData) {
-                                     return LabeledSensorParameters(
+                                     return LabeledSensorInfo(
                                          "Service", std::get<0>(sensorData),
                                          std::get<1>(sensorData));
                                  }),
diff --git a/tests/src/mocks/sensor_mock.hpp b/tests/src/mocks/sensor_mock.hpp
index 9ff72e2..9b7f28b 100644
--- a/tests/src/mocks/sensor_mock.hpp
+++ b/tests/src/mocks/sensor_mock.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "interfaces/sensor.hpp"
+#include "utils/conv_container.hpp"
 #include "utils/generate_unique_mock_id.hpp"
 
 #include <gmock/gmock.h>
@@ -23,12 +24,30 @@
         return Id("SensorMock", service, path);
     }
 
+    static std::vector<std::shared_ptr<interfaces::Sensor>>
+        makeSensorMocks(const std::vector<LabeledSensorInfo>& sensorsInfo)
+    {
+        using namespace testing;
+        std::vector<std::shared_ptr<NiceMock<SensorMock>>> result;
+        for (const auto& sensorInfo : sensorsInfo)
+        {
+            auto& sensorMock =
+                result.emplace_back(std::make_shared<NiceMock<SensorMock>>());
+            ON_CALL(*sensorMock, getLabeledSensorInfo())
+                .WillByDefault(Return(sensorInfo));
+        }
+        return utils::convContainer<std::shared_ptr<interfaces::Sensor>>(
+            result);
+    }
+
     MOCK_METHOD(Id, id, (), (const, override));
     MOCK_METHOD(std::string, metadata, (), (const, override));
+    MOCK_METHOD(std::string, getName, (), (const, override));
     MOCK_METHOD(void, registerForUpdates,
                 (const std::weak_ptr<interfaces::SensorListener>&), (override));
     MOCK_METHOD(void, unregisterFromUpdates,
                 (const std::weak_ptr<interfaces::SensorListener>&), (override));
+    MOCK_METHOD(LabeledSensorInfo, getLabeledSensorInfo, (), (const, override));
 
     const uint64_t mockId = generateUniqueMockId();
 
diff --git a/tests/src/mocks/threshold_mock.hpp b/tests/src/mocks/threshold_mock.hpp
new file mode 100644
index 0000000..2f81b60
--- /dev/null
+++ b/tests/src/mocks/threshold_mock.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "interfaces/sensor.hpp"
+#include "interfaces/threshold.hpp"
+#include "utils/conv_container.hpp"
+
+#include <vector>
+
+#include <gmock/gmock.h>
+
+class ThresholdMock :
+    public interfaces::Threshold,
+    public std::enable_shared_from_this<ThresholdMock>
+{
+  public:
+    MOCK_METHOD(void, initialize, (), (override));
+
+    MOCK_METHOD(LabeledThresholdParam, getThresholdParam, (),
+                (const, override));
+
+    MOCK_METHOD(void, updateSensors, (Sensors newSensors), (override));
+
+    static std::vector<std::shared_ptr<interfaces::Threshold>>
+        makeThresholds(const LabeledTriggerThresholdParams& params)
+    {
+        using namespace testing;
+        std::vector<std::shared_ptr<NiceMock<ThresholdMock>>> result;
+        if (std::holds_alternative<std::vector<numeric::LabeledThresholdParam>>(
+                params))
+        {
+            auto unpackedParams =
+                std::get<std::vector<numeric::LabeledThresholdParam>>(params);
+            for (const auto& param : unpackedParams)
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(param));
+            }
+        }
+        else
+        {
+            auto unpackedParams =
+                std::get<std::vector<discrete::LabeledThresholdParam>>(params);
+            for (const auto& param : unpackedParams)
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(param));
+            }
+            if (unpackedParams.empty())
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(std::monostate{}));
+            }
+        }
+
+        return utils::convContainer<std::shared_ptr<interfaces::Threshold>>(
+            result);
+    }
+};
diff --git a/tests/src/mocks/trigger_factory_mock.hpp b/tests/src/mocks/trigger_factory_mock.hpp
index 9fa2f48..80a62a1 100644
--- a/tests/src/mocks/trigger_factory_mock.hpp
+++ b/tests/src/mocks/trigger_factory_mock.hpp
@@ -5,6 +5,7 @@
 #include "params/trigger_params.hpp"
 #include "trigger.hpp"
 #include "utils/conversion_trigger.hpp"
+#include "utils/transform.hpp"
 
 #include <gmock/gmock.h>
 
@@ -35,6 +36,23 @@
                 (boost::asio::yield_context&, const SensorsInfo&),
                 (const, override));
 
+    MOCK_METHOD(std::vector<LabeledSensorInfo>, getLabeledSensorsInfo,
+                (const SensorsInfo&), (const, override));
+
+    MOCK_METHOD(void, updateThresholds,
+                (std::vector<std::shared_ptr<interfaces::Threshold>> &
+                     currentThresholds,
+                 const std::vector<TriggerAction>& triggerActions,
+                 const std::shared_ptr<std::vector<std::string>>& reportIds,
+                 const Sensors& sensors,
+                 const LabeledTriggerThresholdParams& newParams),
+                (const, override));
+
+    MOCK_METHOD(void, updateSensors,
+                (Sensors & currentSensors,
+                 const std::vector<LabeledSensorInfo>& senorParams),
+                (const, override));
+
     auto& expectMake(
         std::optional<TriggerParams> paramsOpt,
         const testing::Matcher<interfaces::TriggerManager&>& tm,
@@ -53,7 +71,11 @@
                 .WillByDefault(Return(params.sensors()));
 
             return EXPECT_CALL(
-                *this, make(params.id(), params.name(), params.triggerActions(),
+                *this, make(params.id(), params.name(),
+                            utils::transform(params.triggerActions(),
+                                             [](const auto& action) {
+                                                 return actionToString(action);
+                                             }),
                             params.reportIds(), tm, triggerStorage,
                             params.thresholdParams(), params.sensors()));
         }