xref: /openbmc/telemetry/tests/src/test_trigger.cpp (revision 89cf7d7dafe2c073d781a40d59fa9c46cb344be6) 
1 #include "dbus_environment.hpp"
2 #include "helpers.hpp"
3 #include "messages/collect_trigger_id.hpp"
4 #include "messages/trigger_presence_changed_ind.hpp"
5 #include "mocks/json_storage_mock.hpp"
6 #include "mocks/report_manager_mock.hpp"
7 #include "mocks/sensor_mock.hpp"
8 #include "mocks/threshold_mock.hpp"
9 #include "mocks/trigger_factory_mock.hpp"
10 #include "mocks/trigger_manager_mock.hpp"
11 #include "params/trigger_params.hpp"
12 #include "trigger.hpp"
13 #include "trigger_manager.hpp"
14 #include "utils/conversion_trigger.hpp"
15 #include "utils/dbus_path_utils.hpp"
16 #include "utils/messanger.hpp"
17 #include "utils/string_utils.hpp"
18 #include "utils/transform.hpp"
19 #include "utils/tstring.hpp"
20 
21 #include <boost/range/combine.hpp>
22 
23 using namespace testing;
24 using namespace std::literals::string_literals;
25 using sdbusplus::message::object_path;
26 
27 static constexpr size_t expectedTriggerVersion = 2;
28 
29 class TestTrigger : public Test
30 {
31   public:
32     TriggerParams triggerParams;
33     TriggerParams triggerDiscreteParams =
34         TriggerParams()
35             .id("DiscreteTrigger")
36             .name("My Discrete Trigger")
37             .thresholdParams(std::vector<discrete::LabeledThresholdParam>{
38                 discrete::LabeledThresholdParam{
39                     "userId", discrete::Severity::warning,
40                     Milliseconds(10).count(), "15.2"},
41                 discrete::LabeledThresholdParam{
42                     "userId_2", discrete::Severity::critical,
43                     Milliseconds(5).count(), "32.7"},
44             });
45 
46     std::unique_ptr<ReportManagerMock> reportManagerMockPtr =
47         std::make_unique<NiceMock<ReportManagerMock>>();
48     std::unique_ptr<TriggerManagerMock> triggerManagerMockPtr =
49         std::make_unique<NiceMock<TriggerManagerMock>>();
50     std::unique_ptr<TriggerFactoryMock> triggerFactoryMockPtr =
51         std::make_unique<NiceMock<TriggerFactoryMock>>();
52     testing::NiceMock<StorageMock> storageMock;
53     NiceMock<MockFunction<void(const messages::TriggerPresenceChangedInd)>>
54         triggerPresenceChanged;
55     std::vector<std::shared_ptr<interfaces::Threshold>> thresholdMocks;
56     utils::Messanger messanger;
57     std::unique_ptr<Trigger> sut;
58 
59     TestTrigger() : messanger(DbusEnvironment::getIoc())
60     {
61         messanger.on_receive<messages::TriggerPresenceChangedInd>(
62             [this](const auto& msg) { triggerPresenceChanged.Call(msg); });
63     }
64 
65     void SetUp() override
66     {
67         sut = makeTrigger(triggerParams);
68     }
69 
70     static std::vector<LabeledSensorInfo>
71         convertToLabeledSensor(const SensorsInfo& sensorsInfo)
72     {
73         return utils::transform(sensorsInfo, [](const auto& sensorInfo) {
74             const auto& [sensorPath, sensorMetadata] = sensorInfo;
75             return LabeledSensorInfo("service1", sensorPath, sensorMetadata);
76         });
77     }
78 
79     std::unique_ptr<Trigger> makeTrigger(const TriggerParams& params)
80     {
81         thresholdMocks =
82             ThresholdMock::makeThresholds(params.thresholdParams());
83 
84         auto id = std::make_unique<const std::string>(params.id());
85 
86         return std::make_unique<Trigger>(
87             DbusEnvironment::getIoc(), DbusEnvironment::getObjServer(),
88             std::move(id), params.name(), params.triggerActions(),
89             std::make_shared<std::vector<std::string>>(
90                 params.reportIds().begin(), params.reportIds().end()),
91             std::vector<std::shared_ptr<interfaces::Threshold>>(thresholdMocks),
92             *triggerManagerMockPtr, storageMock, *triggerFactoryMockPtr,
93             SensorMock::makeSensorMocks(params.sensors()));
94     }
95 
96     static interfaces::JsonStorage::FilePath to_file_path(std::string name)
97     {
98         return interfaces::JsonStorage::FilePath(
99             std::to_string(std::hash<std::string>{}(name)));
100     }
101 
102     template <class T>
103     static T getProperty(const std::string& path, const std::string& property)
104     {
105         return DbusEnvironment::getProperty<T>(path, Trigger::triggerIfaceName,
106                                                property);
107     }
108 
109     template <class T>
110     static boost::system::error_code setProperty(const std::string& path,
111                                                  const std::string& property,
112                                                  const T& newValue)
113     {
114         return DbusEnvironment::setProperty<T>(path, Trigger::triggerIfaceName,
115                                                property, newValue);
116     }
117 
118     template <class T>
119     struct ChangePropertyParams
120     {
121         Matcher<T> valueBefore = _;
122         T newValue;
123         Matcher<boost::system::error_code> ec =
124             Eq(boost::system::errc::success);
125         Matcher<T> valueAfter = Eq(newValue);
126     };
127 
128     template <class T>
129     static void changeProperty(const std::string& path,
130                                const std::string& property,
131                                ChangePropertyParams<T> p)
132     {
133         ASSERT_THAT(getProperty<T>(path, property), p.valueBefore);
134         ASSERT_THAT(setProperty<T>(path, property, p.newValue), p.ec);
135         EXPECT_THAT(getProperty<T>(path, property), p.valueAfter);
136     }
137 
138     boost::system::error_code deleteTrigger(const std::string& path)
139     {
140         std::promise<boost::system::error_code> methodPromise;
141         DbusEnvironment::getBus()->async_method_call(
142             [&methodPromise](boost::system::error_code ec) {
143                 methodPromise.set_value(ec);
144             },
145             DbusEnvironment::serviceName(), path, Trigger::deleteIfaceName,
146             "Delete");
147         return DbusEnvironment::waitForFuture(methodPromise.get_future());
148     }
149 };
150 
151 TEST_F(TestTrigger, checkIfPropertiesAreSet)
152 {
153     EXPECT_THAT(getProperty<std::string>(sut->getPath(), "Name"),
154                 Eq(triggerParams.name()));
155     EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistent"), Eq(true));
156     EXPECT_THAT(
157         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerActions"),
158         Eq(utils::transform(
159             triggerParams.triggerActions(),
160             [](const auto& action) { return actionToString(action); })));
161     EXPECT_THAT((getProperty<SensorsInfo>(sut->getPath(), "Sensors")),
162                 Eq(utils::fromLabeledSensorsInfo(triggerParams.sensors())));
163     EXPECT_THAT(
164         getProperty<std::vector<object_path>>(sut->getPath(), "Reports"),
165         Eq(triggerParams.reports()));
166     EXPECT_THAT(
167         getProperty<bool>(sut->getPath(), "Discrete"),
168         Eq(isTriggerThresholdDiscrete(triggerParams.thresholdParams())));
169     EXPECT_THAT(
170         getProperty<TriggerThresholdParams>(sut->getPath(), "Thresholds"),
171         Eq(std::visit(utils::FromLabeledThresholdParamConversion(),
172                       triggerParams.thresholdParams())));
173 }
174 
175 TEST_F(TestTrigger, checkBasicGetters)
176 {
177     EXPECT_THAT(sut->getId(), Eq(triggerParams.id()));
178     EXPECT_THAT(sut->getPath(),
179                 Eq(utils::constants::triggerDirPath.str + triggerParams.id()));
180 }
181 
182 TEST_F(TestTrigger, setPropertyNameToCorrectValue)
183 {
184     std::string name = "custom name 1234 %^#5";
185     EXPECT_THAT(setProperty(sut->getPath(), "Name", name),
186                 Eq(boost::system::errc::success));
187     EXPECT_THAT(getProperty<std::string>(sut->getPath(), "Name"), Eq(name));
188 }
189 
190 TEST_F(TestTrigger, setPropertyReportNames)
191 {
192     std::vector<object_path> newNames = {
193         utils::constants::reportDirPath / "abc",
194         utils::constants::reportDirPath / "one",
195         utils::constants::reportDirPath / "prefix" / "two"};
196     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newNames),
197                 Eq(boost::system::errc::success));
198     EXPECT_THAT(
199         getProperty<std::vector<object_path>>(sut->getPath(), "Reports"),
200         Eq(newNames));
201 }
202 
203 TEST_F(TestTrigger, sendsUpdateWhenReportNamesChanges)
204 {
205     std::vector<object_path> newPropertyVal = {
206         utils::constants::reportDirPath / "abc",
207         utils::constants::reportDirPath / "one",
208         utils::constants::reportDirPath / "two"};
209 
210     EXPECT_CALL(triggerPresenceChanged,
211                 Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
212                                UnorderedElementsAre("abc", "one", "two"))));
213 
214     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
215                 Eq(boost::system::errc::success));
216 }
217 
218 TEST_F(TestTrigger, sendsUpdateWhenReportNamesChangesToSameValue)
219 {
220     const std::vector<object_path> newPropertyVal = triggerParams.reports();
221 
222     EXPECT_CALL(
223         triggerPresenceChanged,
224         Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
225                        UnorderedElementsAreArray(triggerParams.reportIds()))));
226 
227     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
228                 Eq(boost::system::errc::success));
229 }
230 
231 TEST_F(TestTrigger,
232        DISABLED_settingPropertyReportNamesThrowsExceptionWhenDuplicateReportIds)
233 {
234     std::vector<object_path> newPropertyVal{
235         utils::constants::reportDirPath / "report1",
236         utils::constants::reportDirPath / "report2",
237         utils::constants::reportDirPath / "report1"};
238 
239     EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
240 
241     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
242                 Eq(boost::system::errc::invalid_argument));
243 }
244 
245 TEST_F(
246     TestTrigger,
247     DISABLED_settingPropertyReportNamesThrowsExceptionWhenReportWithTooManyPrefixes)
248 {
249     std::vector<object_path> newPropertyVal{
250         object_path("/xyz/openbmc_project/Telemetry/Reports/P1/P2/MyReport")};
251 
252     EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
253 
254     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
255                 Eq(boost::system::errc::invalid_argument));
256 }
257 
258 TEST_F(
259     TestTrigger,
260     DISABLED_settingPropertyReportNamesThrowsExceptionWhenReportWithTooLongPrefix)
261 {
262     std::vector<object_path> newPropertyVal{
263         object_path("/xyz/openbmc_project/Telemetry/Reports/" +
264                     utils::string_utils::getTooLongPrefix() + "/MyReport")};
265 
266     EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
267 
268     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
269                 Eq(boost::system::errc::invalid_argument));
270 }
271 
272 TEST_F(
273     TestTrigger,
274     DISABLED_settingPropertyReportNamesThrowsExceptionWhenReportWithTooLongId)
275 {
276     std::vector<object_path> newPropertyVal{
277         object_path("/xyz/openbmc_project/Telemetry/Reports/Prefix/" +
278                     utils::string_utils::getTooLongId())};
279 
280     EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
281 
282     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
283                 Eq(boost::system::errc::invalid_argument));
284 }
285 
286 TEST_F(TestTrigger,
287        DISABLED_settingPropertyReportNamesThrowsExceptionWhenReportWithBadPath)
288 {
289     std::vector<object_path> newPropertyVal{
290         object_path("/xyz/openbmc_project/Telemetry/NotReports/MyReport")};
291 
292     EXPECT_CALL(triggerPresenceChanged, Call(_)).Times(0);
293 
294     EXPECT_THAT(setProperty(sut->getPath(), "Reports", newPropertyVal),
295                 Eq(boost::system::errc::invalid_argument));
296 }
297 
298 TEST_F(TestTrigger, setPropertySensors)
299 {
300     EXPECT_CALL(*triggerFactoryMockPtr, updateSensors(_, _));
301     for (const auto& threshold : thresholdMocks)
302     {
303         auto thresholdMockPtr =
304             std::dynamic_pointer_cast<NiceMock<ThresholdMock>>(threshold);
305         EXPECT_CALL(*thresholdMockPtr, updateSensors(_));
306     }
307     SensorsInfo newSensors(
308         {std::make_pair(object_path("/abc/def"), "metadata")});
309     EXPECT_THAT(setProperty(sut->getPath(), "Sensors", newSensors),
310                 Eq(boost::system::errc::success));
311 }
312 
313 TEST_F(TestTrigger, setPropertyThresholds)
314 {
315     EXPECT_CALL(*triggerFactoryMockPtr, updateThresholds(_, _, _, _, _, _));
316     TriggerThresholdParams newThresholds =
317         std::vector<discrete::ThresholdParam>(
318             {std::make_tuple("discrete threshold", "OK", 10, "12.3")});
319     EXPECT_THAT(setProperty(sut->getPath(), "Thresholds", newThresholds),
320                 Eq(boost::system::errc::success));
321 }
322 
323 TEST_F(TestTrigger, setThresholdParamsWithTooLongDiscreteName)
324 {
325     const TriggerThresholdParams currentValue =
326         std::visit(utils::FromLabeledThresholdParamConversion(),
327                    triggerParams.thresholdParams());
328 
329     TriggerThresholdParams newThresholds =
330         std::vector<discrete::ThresholdParam>({std::make_tuple(
331             utils::string_utils::getTooLongName(), "OK", 10, "12.3")});
332 
333     changeProperty<TriggerThresholdParams>(
334         sut->getPath(), "Thresholds",
335         {.valueBefore = Eq(currentValue),
336          .newValue = newThresholds,
337          .ec = Eq(boost::system::errc::invalid_argument),
338          .valueAfter = Eq(currentValue)});
339 }
340 
341 TEST_F(TestTrigger, setNameTooLong)
342 {
343     std::string currentValue = TriggerParams().name();
344 
345     changeProperty<std::string>(
346         sut->getPath(), "Name",
347         {.valueBefore = Eq(currentValue),
348          .newValue = utils::string_utils::getTooLongName(),
349          .ec = Eq(boost::system::errc::invalid_argument),
350          .valueAfter = Eq(currentValue)});
351 }
352 
353 TEST_F(TestTrigger, checkIfNumericCoversionsAreGood)
354 {
355     const auto& labeledParamsBase =
356         std::get<std::vector<numeric::LabeledThresholdParam>>(
357             triggerParams.thresholdParams());
358     const auto paramsToCheck =
359         std::visit(utils::FromLabeledThresholdParamConversion(),
360                    triggerParams.thresholdParams());
361     const auto labeledParamsToCheck =
362         std::get<std::vector<numeric::LabeledThresholdParam>>(std::visit(
363             utils::ToLabeledThresholdParamConversion(), paramsToCheck));
364 
365     for (const auto& [tocheck, base] :
366          boost::combine(labeledParamsToCheck, labeledParamsBase))
367     {
368         EXPECT_THAT(tocheck.at_label<utils::tstring::Type>(),
369                     Eq(base.at_label<utils::tstring::Type>()));
370         EXPECT_THAT(tocheck.at_label<utils::tstring::Direction>(),
371                     Eq(base.at_label<utils::tstring::Direction>()));
372         EXPECT_THAT(tocheck.at_label<utils::tstring::DwellTime>(),
373                     Eq(base.at_label<utils::tstring::DwellTime>()));
374         EXPECT_THAT(tocheck.at_label<utils::tstring::ThresholdValue>(),
375                     Eq(base.at_label<utils::tstring::ThresholdValue>()));
376     }
377 }
378 
379 TEST_F(TestTrigger, checkIfDiscreteCoversionsAreGood)
380 {
381     const auto& labeledParamsBase =
382         std::get<std::vector<discrete::LabeledThresholdParam>>(
383             triggerDiscreteParams.thresholdParams());
384     const auto paramsToCheck =
385         std::visit(utils::FromLabeledThresholdParamConversion(),
386                    triggerDiscreteParams.thresholdParams());
387     const auto labeledParamsToCheck =
388         std::get<std::vector<discrete::LabeledThresholdParam>>(std::visit(
389             utils::ToLabeledThresholdParamConversion(), paramsToCheck));
390 
391     for (const auto& [tocheck, base] :
392          boost::combine(labeledParamsToCheck, labeledParamsBase))
393     {
394         EXPECT_THAT(tocheck.at_label<utils::tstring::UserId>(),
395                     Eq(base.at_label<utils::tstring::UserId>()));
396         EXPECT_THAT(tocheck.at_label<utils::tstring::Severity>(),
397                     Eq(base.at_label<utils::tstring::Severity>()));
398         EXPECT_THAT(tocheck.at_label<utils::tstring::DwellTime>(),
399                     Eq(base.at_label<utils::tstring::DwellTime>()));
400         EXPECT_THAT(tocheck.at_label<utils::tstring::ThresholdValue>(),
401                     Eq(base.at_label<utils::tstring::ThresholdValue>()));
402     }
403 }
404 
405 TEST_F(TestTrigger, deleteTrigger)
406 {
407     EXPECT_CALL(storageMock, remove(to_file_path(sut->getId())));
408     EXPECT_CALL(*triggerManagerMockPtr, removeTrigger(sut.get()));
409 
410     auto ec = deleteTrigger(sut->getPath());
411     EXPECT_THAT(ec, Eq(boost::system::errc::success));
412 }
413 
414 TEST_F(TestTrigger, sendUpdateWhenTriggerIsDeleted)
415 {
416     EXPECT_CALL(triggerPresenceChanged,
417                 Call(FieldsAre(messages::Presence::Removed, triggerParams.id(),
418                                UnorderedElementsAre())));
419 
420     auto ec = deleteTrigger(sut->getPath());
421     EXPECT_THAT(ec, Eq(boost::system::errc::success));
422 }
423 
424 TEST_F(TestTrigger, deletingNonExistingTriggerReturnInvalidRequestDescriptor)
425 {
426     auto ec =
427         deleteTrigger(utils::constants::triggerDirPath.str + "NonExisting"s);
428     EXPECT_THAT(ec.value(), Eq(EBADR));
429 }
430 
431 TEST_F(TestTrigger, settingPersistencyToFalseRemovesTriggerFromStorage)
432 {
433     EXPECT_CALL(storageMock, remove(to_file_path(sut->getId())));
434 
435     bool persistent = false;
436     EXPECT_THAT(setProperty(sut->getPath(), "Persistent", persistent),
437                 Eq(boost::system::errc::success));
438     EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistent"),
439                 Eq(persistent));
440 }
441 
442 class TestTriggerInitialization : public TestTrigger
443 {
444   public:
445     void SetUp() override
446     {}
447 
448     nlohmann::json storedConfiguration;
449 };
450 
451 TEST_F(TestTriggerInitialization,
452        exceptionDuringTriggerStoreDisablesPersistency)
453 {
454     EXPECT_CALL(storageMock, store(_, _))
455         .WillOnce(Throw(std::runtime_error("Generic error!")));
456 
457     sut = makeTrigger(triggerParams);
458 
459     EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistent"), Eq(false));
460 }
461 
462 TEST_F(TestTriggerInitialization, creatingTriggerThrowsExceptionWhenIdIsInvalid)
463 {
464     EXPECT_CALL(storageMock, store(_, _)).Times(0);
465 
466     EXPECT_THROW(makeTrigger(triggerParams.id("inv?lidId")),
467                  sdbusplus::exception::SdBusError);
468 }
469 
470 TEST_F(TestTriggerInitialization, creatingTriggerUpdatesTriggersIdsInReports)
471 {
472     EXPECT_CALL(
473         triggerPresenceChanged,
474         Call(FieldsAre(messages::Presence::Exist, triggerParams.id(),
475                        UnorderedElementsAreArray(triggerParams.reportIds()))));
476 
477     sut = makeTrigger(triggerParams);
478 }
479 
480 class TestTriggerStore : public TestTrigger
481 {
482   public:
483     nlohmann::json storedConfiguration;
484     nlohmann::json storedDiscreteConfiguration;
485     std::unique_ptr<Trigger> sutDiscrete;
486 
487     void SetUp() override
488     {
489         ON_CALL(storageMock, store(_, _))
490             .WillByDefault(SaveArg<1>(&storedConfiguration));
491         sut = makeTrigger(triggerParams);
492 
493         ON_CALL(storageMock, store(_, _))
494             .WillByDefault(SaveArg<1>(&storedDiscreteConfiguration));
495         sutDiscrete = makeTrigger(triggerDiscreteParams);
496     }
497 };
498 
499 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerVersion)
500 {
501     ASSERT_THAT(storedConfiguration.at("Version"), Eq(expectedTriggerVersion));
502 }
503 
504 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerId)
505 {
506     ASSERT_THAT(storedConfiguration.at("Id"), Eq(triggerParams.id()));
507 }
508 
509 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerName)
510 {
511     ASSERT_THAT(storedConfiguration.at("Name"), Eq(triggerParams.name()));
512 }
513 
514 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerTriggerActions)
515 {
516     ASSERT_THAT(storedConfiguration.at("TriggerActions"),
517                 Eq(utils::transform(triggerParams.triggerActions(),
518                                     [](const auto& action) {
519                                         return actionToString(action);
520                                     })));
521 }
522 
523 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerReportIds)
524 {
525     ASSERT_THAT(storedConfiguration.at("ReportIds"),
526                 Eq(triggerParams.reportIds()));
527 }
528 
529 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerSensors)
530 {
531     nlohmann::json expectedItem;
532     expectedItem["service"] = "service1";
533     expectedItem["path"] = "/xyz/openbmc_project/sensors/temperature/BMC_Temp";
534     expectedItem["metadata"] = "metadata1";
535 
536     ASSERT_THAT(storedConfiguration.at("Sensors"), ElementsAre(expectedItem));
537 }
538 
539 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerThresholdParams)
540 {
541     nlohmann::json expectedItem0;
542     expectedItem0["type"] = 0;
543     expectedItem0["dwellTime"] = 10;
544     expectedItem0["direction"] = 1;
545     expectedItem0["thresholdValue"] = 0.5;
546 
547     nlohmann::json expectedItem1;
548     expectedItem1["type"] = 3;
549     expectedItem1["dwellTime"] = 10;
550     expectedItem1["direction"] = 2;
551     expectedItem1["thresholdValue"] = 90.2;
552 
553     ASSERT_THAT(storedConfiguration.at("ThresholdParamsDiscriminator"), Eq(0));
554     ASSERT_THAT(storedConfiguration.at("ThresholdParams"),
555                 ElementsAre(expectedItem0, expectedItem1));
556 }
557 
558 TEST_F(TestTriggerStore,
559        settingPersistencyToTrueStoresDiscreteTriggerThresholdParams)
560 {
561     nlohmann::json expectedItem0;
562     expectedItem0["userId"] = "userId";
563     expectedItem0["severity"] = discrete::Severity::warning;
564     expectedItem0["dwellTime"] = 10;
565     expectedItem0["thresholdValue"] = "15.2";
566 
567     nlohmann::json expectedItem1;
568     expectedItem1["userId"] = "userId_2";
569     expectedItem1["severity"] = discrete::Severity::critical;
570     expectedItem1["dwellTime"] = 5;
571     expectedItem1["thresholdValue"] = "32.7";
572 
573     ASSERT_THAT(storedDiscreteConfiguration.at("ThresholdParamsDiscriminator"),
574                 Eq(1));
575     ASSERT_THAT(storedDiscreteConfiguration.at("ThresholdParams"),
576                 ElementsAre(expectedItem0, expectedItem1));
577 }
578