1 #include "dbus_environment.hpp"
2 #include "helpers.hpp"
3 #include "mocks/json_storage_mock.hpp"
4 #include "mocks/trigger_factory_mock.hpp"
5 #include "mocks/trigger_mock.hpp"
6 #include "params/trigger_params.hpp"
7 #include "trigger.hpp"
8 #include "trigger_manager.hpp"
9 #include "utils/conversion_trigger.hpp"
10 #include "utils/dbus_path_utils.hpp"
11 #include "utils/string_utils.hpp"
12 #include "utils/transform.hpp"
13
14 using namespace testing;
15 using sdbusplus::message::object_path;
16 using namespace std::literals::string_literals;
17
18 class TestTriggerManager : public Test
19 {
20 public:
21 TriggerParams triggerParams;
addTrigger(const TriggerParams & params)22 std::pair<boost::system::error_code, std::string> addTrigger(
23 const TriggerParams& params)
24 {
25 const auto sensorInfos =
26 utils::fromLabeledSensorsInfo(params.sensors());
27 const std::vector<numeric::LabeledThresholdParam> numThresh =
28 params.numericThresholdParams();
29 const std::vector<discrete::LabeledThresholdParam> discThresh =
30 params.discreteThresholdParams();
31 const std::vector<numeric::ThresholdParam> numThresh2 = std::get<0>(
32 utils::FromLabeledThresholdParamConversion()(numThresh));
33 const auto discThresh2 = std::get<1>(
34 utils::FromLabeledThresholdParamConversion()(discThresh));
35
36 std::promise<std::pair<boost::system::error_code, std::string>>
37 addTriggerPromise;
38 DbusEnvironment::getBus()->async_method_call(
39 [&addTriggerPromise](boost::system::error_code ec,
40 const std::string& path) {
41 addTriggerPromise.set_value({ec, path});
42 },
43 DbusEnvironment::serviceName(), TriggerManager::triggerManagerPath,
44 TriggerManager::triggerManagerIfaceName, "AddTrigger", params.id(),
45 params.name(),
46 utils::transform(params.triggerActions(),
47 [](const auto& action) {
48 return actionToString(action);
49 }),
50 sensorInfos, params.reports(), numThresh2, discThresh2);
51 return DbusEnvironment::waitForFuture(addTriggerPromise.get_future());
52 }
53
makeTriggerManager()54 std::unique_ptr<TriggerManager> makeTriggerManager()
55 {
56 return std::make_unique<TriggerManager>(
57 std::move(triggerFactoryMockPtr), std::move(storageMockPtr),
58 DbusEnvironment::getObjServer());
59 }
60
SetUp()61 void SetUp() override
62 {
63 sut = makeTriggerManager();
64 }
65
66 std::unique_ptr<StorageMock> storageMockPtr =
67 std::make_unique<NiceMock<StorageMock>>();
68 StorageMock& storageMock = *storageMockPtr;
69 std::unique_ptr<TriggerFactoryMock> triggerFactoryMockPtr =
70 std::make_unique<NiceMock<TriggerFactoryMock>>();
71 TriggerFactoryMock& triggerFactoryMock = *triggerFactoryMockPtr;
72 std::unique_ptr<TriggerMock> triggerMockPtr =
73 std::make_unique<NiceMock<TriggerMock>>(TriggerParams().id());
74 TriggerMock& triggerMock = *triggerMockPtr;
75 std::unique_ptr<TriggerManager> sut;
76 MockFunction<void(std::string)> checkPoint;
77 };
78
TEST_F(TestTriggerManager,addTrigger)79 TEST_F(TestTriggerManager, addTrigger)
80 {
81 triggerFactoryMock.expectMake(TriggerParams(), Ref(*sut), Ref(storageMock))
82 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
83
84 auto [ec, path] = addTrigger(TriggerParams());
85 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
86 EXPECT_THAT(path, Eq(triggerMock.getPath()));
87 }
88
TEST_F(TestTriggerManager,addTriggerWithDiscreteThresholds)89 TEST_F(TestTriggerManager, addTriggerWithDiscreteThresholds)
90 {
91 TriggerParams triggerParamsDiscrete;
92 auto thresholds = std::vector<discrete::LabeledThresholdParam>{
93 {"discrete_threshold1", discrete::Severity::ok, 10, "11.0"},
94 {"discrete_threshold2", discrete::Severity::warning, 10, "12.0"},
95 {"discrete_threshold3", discrete::Severity::critical, 10, "13.0"}};
96
97 triggerParamsDiscrete.thresholdParams(thresholds);
98
99 auto [ec, path] = addTrigger(triggerParamsDiscrete);
100 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
101 EXPECT_THAT(path, Eq(triggerMock.getPath()));
102 }
103
TEST_F(TestTriggerManager,addDiscreteTriggerWithoutThresholds)104 TEST_F(TestTriggerManager, addDiscreteTriggerWithoutThresholds)
105 {
106 TriggerParams triggerParamsDiscrete;
107 auto thresholds = std::vector<discrete::LabeledThresholdParam>();
108
109 triggerParamsDiscrete.thresholdParams(thresholds);
110
111 auto [ec, path] = addTrigger(triggerParamsDiscrete);
112 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
113 EXPECT_THAT(path, Eq(triggerMock.getPath()));
114 }
115
TEST_F(TestTriggerManager,failToAddTriggerTwice)116 TEST_F(TestTriggerManager, failToAddTriggerTwice)
117 {
118 triggerFactoryMock.expectMake(TriggerParams(), Ref(*sut), Ref(storageMock))
119 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
120
121 addTrigger(TriggerParams());
122
123 auto [ec, path] = addTrigger(TriggerParams());
124 EXPECT_THAT(ec.value(), Eq(boost::system::errc::file_exists));
125 EXPECT_THAT(path, Eq(std::string()));
126 }
127
TEST_F(TestTriggerManager,failToAddTriggerWithInvalidId)128 TEST_F(TestTriggerManager, failToAddTriggerWithInvalidId)
129 {
130 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
131 .Times(0);
132
133 auto [ec, path] = addTrigger(TriggerParams().id("not valid?"));
134 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
135 EXPECT_THAT(path, Eq(std::string()));
136 }
137
TEST_F(TestTriggerManager,failToAddTriggerWithDuplicatesInReportsIds)138 TEST_F(TestTriggerManager, failToAddTriggerWithDuplicatesInReportsIds)
139 {
140 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
141 .Times(0);
142
143 auto [ec, path] = addTrigger(
144 TriggerParams().reportIds({"trigger1", "trigger2", "trigger1"}));
145 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
146 EXPECT_THAT(path, Eq(std::string()));
147 }
148
TEST_F(TestTriggerManager,addTriggerWithProperReportPaths)149 TEST_F(TestTriggerManager, addTriggerWithProperReportPaths)
150 {
151 auto [ec, path] = addTrigger(TriggerParams().reports(
152 {object_path("/xyz/openbmc_project/Telemetry/Reports/MyReport"),
153 object_path(
154 "/xyz/openbmc_project/Telemetry/Reports/MyPrefix/MyReport")}));
155 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
156 EXPECT_THAT(path, Eq(triggerMock.getPath()));
157 }
158
TEST_F(TestTriggerManager,failToAddTriggerWithBadReportsPath)159 TEST_F(TestTriggerManager, failToAddTriggerWithBadReportsPath)
160 {
161 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
162 .Times(0);
163
164 auto [ec, path] = addTrigger(TriggerParams().reports(
165 {object_path("/xyz/openbmc_project/Telemetry/NotReports/MyReport")}));
166 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
167 EXPECT_THAT(path, Eq(std::string()));
168 }
169
TEST_F(TestTriggerManager,failToAddTriggerWithTooManyReportPrefixes)170 TEST_F(TestTriggerManager, failToAddTriggerWithTooManyReportPrefixes)
171 {
172 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
173 .Times(0);
174
175 auto [ec, path] = addTrigger(TriggerParams().reports({object_path(
176 "/xyz/openbmc_project/Telemetry/Reports/P1/P2/MyReport")}));
177 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
178 EXPECT_THAT(path, Eq(std::string()));
179 }
180
TEST_F(TestTriggerManager,addTriggerWithoutIdAndName)181 TEST_F(TestTriggerManager, addTriggerWithoutIdAndName)
182 {
183 triggerFactoryMock
184 .expectMake(TriggerParams()
185 .id(TriggerManager::triggerNameDefault)
186 .name(TriggerManager::triggerNameDefault),
187 Ref(*sut), Ref(storageMock))
188 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
189
190 auto [ec, path] = addTrigger(TriggerParams().id("").name(""));
191 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
192 EXPECT_THAT(path, Not(Eq("")));
193 }
194
TEST_F(TestTriggerManager,addTriggerWithPrefixId)195 TEST_F(TestTriggerManager, addTriggerWithPrefixId)
196 {
197 triggerFactoryMock
198 .expectMake(TriggerParams()
199 .id("TelemetryService/HackyName")
200 .name("Hacky/Name!@#$"),
201 Ref(*sut), Ref(storageMock))
202 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
203
204 auto [ec, path] = addTrigger(
205 TriggerParams().id("TelemetryService/").name("Hacky/Name!@#$"));
206 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
207 EXPECT_THAT(path, Not(Eq("")));
208 }
209
TEST_F(TestTriggerManager,addTriggerWithoutIdTwice)210 TEST_F(TestTriggerManager, addTriggerWithoutIdTwice)
211 {
212 addTrigger(TriggerParams().id(""));
213
214 auto [ec, path] = addTrigger(TriggerParams().id(""));
215 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
216 EXPECT_THAT(path, Not(Eq("")));
217 }
218
TEST_F(TestTriggerManager,addTriggerWithoutIdAndWithLongNameTwice)219 TEST_F(TestTriggerManager, addTriggerWithoutIdAndWithLongNameTwice)
220 {
221 std::string longName = utils::string_utils::getMaxName();
222 addTrigger(TriggerParams().id("").name(longName));
223
224 auto [ec, path] = addTrigger(TriggerParams().id("").name(longName));
225 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
226 EXPECT_THAT(path, Not(Eq("")));
227 }
228
TEST_F(TestTriggerManager,addTriggerWithMaxLengthId)229 TEST_F(TestTriggerManager, addTriggerWithMaxLengthId)
230 {
231 std::string reportId = utils::string_utils::getMaxId();
232 triggerParams.id(reportId);
233 triggerFactoryMock.expectMake(triggerParams, Ref(*sut), Ref(storageMock));
234
235 auto [ec, path] = addTrigger(triggerParams);
236
237 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
238 EXPECT_THAT(path, Eq("/"s + reportId));
239 }
240
TEST_F(TestTriggerManager,addTriggerWithMaxLengthPrefix)241 TEST_F(TestTriggerManager, addTriggerWithMaxLengthPrefix)
242 {
243 std::string reportId = utils::string_utils::getMaxPrefix() + "/MyId";
244 triggerParams.id(reportId);
245 triggerFactoryMock.expectMake(triggerParams, Ref(*sut), Ref(storageMock));
246
247 auto [ec, path] = addTrigger(triggerParams);
248
249 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
250 EXPECT_THAT(path, Eq("/"s + reportId));
251 }
252
TEST_F(TestTriggerManager,addTriggerWithMaxLengthName)253 TEST_F(TestTriggerManager, addTriggerWithMaxLengthName)
254 {
255 triggerParams.name(utils::string_utils::getMaxName());
256 triggerFactoryMock.expectMake(triggerParams, Ref(*sut), Ref(storageMock));
257
258 auto [ec, path] = addTrigger(triggerParams);
259
260 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
261 EXPECT_THAT(path, Eq("/"s + triggerParams.id()));
262 }
263
TEST_F(TestTriggerManager,addTriggerWithMaxLengthDiscreteThresholdName)264 TEST_F(TestTriggerManager, addTriggerWithMaxLengthDiscreteThresholdName)
265 {
266 namespace ts = utils::tstring;
267
268 triggerParams =
269 TriggerParams()
270 .id("DiscreteTrigger")
271 .name("My Discrete Trigger")
272 .thresholdParams(std::vector<discrete::LabeledThresholdParam>{
273 discrete::LabeledThresholdParam{
274 utils::string_utils::getMaxName(),
275 discrete::Severity::warning, Milliseconds(10).count(),
276 "15.2"}});
277
278 triggerFactoryMock.expectMake(triggerParams, Ref(*sut), Ref(storageMock));
279
280 auto [ec, path] = addTrigger(triggerParams);
281
282 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
283 EXPECT_THAT(path, Eq("/"s + triggerParams.id()));
284 }
285
TEST_F(TestTriggerManager,failToAddTriggerWithTooLongFullId)286 TEST_F(TestTriggerManager, failToAddTriggerWithTooLongFullId)
287 {
288 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
289 .Times(0);
290
291 triggerParams.id(
292 std::string(utils::constants::maxReportFullIdLength + 1, 'z'));
293
294 auto [ec, path] = addTrigger(triggerParams);
295
296 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
297 EXPECT_THAT(path, Eq(std::string()));
298 }
299
TEST_F(TestTriggerManager,failToAddTriggerWithTooLongId)300 TEST_F(TestTriggerManager, failToAddTriggerWithTooLongId)
301 {
302 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
303 .Times(0);
304
305 triggerParams.id(utils::string_utils::getTooLongId());
306
307 auto [ec, path] = addTrigger(triggerParams);
308
309 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
310 EXPECT_THAT(path, Eq(std::string()));
311 }
312
TEST_F(TestTriggerManager,failToAddTriggerWithTooLongPrefix)313 TEST_F(TestTriggerManager, failToAddTriggerWithTooLongPrefix)
314 {
315 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
316 .Times(0);
317
318 triggerParams.id(utils::string_utils::getTooLongPrefix() + "/MyId");
319
320 auto [ec, path] = addTrigger(triggerParams);
321
322 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
323 EXPECT_THAT(path, Eq(std::string()));
324 }
325
TEST_F(TestTriggerManager,failToAddTriggerWithTooManyPrefixes)326 TEST_F(TestTriggerManager, failToAddTriggerWithTooManyPrefixes)
327 {
328 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
329 .Times(0);
330
331 std::string reportId;
332 for (size_t i = 0; i < utils::constants::maxPrefixesInId + 1; i++)
333 {
334 reportId += "prefix/";
335 }
336 reportId += "MyId";
337
338 triggerParams.id(reportId);
339
340 auto [ec, path] = addTrigger(triggerParams);
341
342 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
343 EXPECT_THAT(path, Eq(std::string()));
344 }
345
TEST_F(TestTriggerManager,failToAddTriggerWithTooLongName)346 TEST_F(TestTriggerManager, failToAddTriggerWithTooLongName)
347 {
348 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
349 .Times(0);
350
351 triggerParams.name(utils::string_utils::getTooLongName());
352
353 auto [ec, path] = addTrigger(triggerParams);
354
355 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
356 EXPECT_THAT(path, Eq(std::string()));
357 }
358
TEST_F(TestTriggerManager,failToAddTriggerWithTooLongMetricId)359 TEST_F(TestTriggerManager, failToAddTriggerWithTooLongMetricId)
360 {
361 namespace ts = utils::tstring;
362
363 triggerParams =
364 TriggerParams()
365 .id("DiscreteTrigger")
366 .name("My Discrete Trigger")
367 .thresholdParams(std::vector<discrete::LabeledThresholdParam>{
368 discrete::LabeledThresholdParam{
369 utils::string_utils::getTooLongName(),
370 discrete::Severity::warning, Milliseconds(10).count(),
371 "15.2"}});
372
373 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
374 .Times(0);
375
376 auto [ec, path] = addTrigger(triggerParams);
377
378 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
379 EXPECT_THAT(path, Eq(std::string()));
380 }
381
TEST_F(TestTriggerManager,failToAddTriggerWhenMaxTriggerIsReached)382 TEST_F(TestTriggerManager, failToAddTriggerWhenMaxTriggerIsReached)
383 {
384 auto triggerParams = TriggerParams();
385
386 triggerFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
387 .Times(TriggerManager::maxTriggers);
388
389 for (size_t i = 0; i < TriggerManager::maxTriggers; i++)
390 {
391 triggerParams.id(TriggerParams().id() + std::to_string(i));
392
393 auto [ec, path] = addTrigger(triggerParams);
394 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
395 }
396
397 triggerParams.id(
398 TriggerParams().id() + std::to_string(TriggerManager::maxTriggers));
399 auto [ec, path] = addTrigger(triggerParams);
400 EXPECT_THAT(ec.value(), Eq(boost::system::errc::too_many_files_open));
401 EXPECT_THAT(path, Eq(std::string()));
402 }
403
TEST_F(TestTriggerManager,removeTrigger)404 TEST_F(TestTriggerManager, removeTrigger)
405 {
406 {
407 InSequence seq;
408 triggerFactoryMock
409 .expectMake(TriggerParams(), Ref(*sut), Ref(storageMock))
410 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
411 EXPECT_CALL(triggerMock, Die());
412 EXPECT_CALL(checkPoint, Call("end"));
413 }
414
415 addTrigger(TriggerParams());
416 sut->removeTrigger(&triggerMock);
417 checkPoint.Call("end");
418 }
419
TEST_F(TestTriggerManager,removingTriggerThatIsNotInContainerHasNoEffect)420 TEST_F(TestTriggerManager, removingTriggerThatIsNotInContainerHasNoEffect)
421 {
422 {
423 InSequence seq;
424 EXPECT_CALL(checkPoint, Call("end"));
425 EXPECT_CALL(triggerMock, Die());
426 }
427
428 sut->removeTrigger(&triggerMock);
429 checkPoint.Call("end");
430 }
431
TEST_F(TestTriggerManager,removingSameTriggerTwiceHasNoSideEffect)432 TEST_F(TestTriggerManager, removingSameTriggerTwiceHasNoSideEffect)
433 {
434 {
435 InSequence seq;
436 triggerFactoryMock
437 .expectMake(TriggerParams(), Ref(*sut), Ref(storageMock))
438 .WillOnce(Return(ByMove(std::move(triggerMockPtr))));
439 EXPECT_CALL(triggerMock, Die());
440 EXPECT_CALL(checkPoint, Call("end"));
441 }
442
443 addTrigger(TriggerParams());
444 sut->removeTrigger(&triggerMock);
445 sut->removeTrigger(&triggerMock);
446 checkPoint.Call("end");
447 }
448 class TestTriggerManagerStorage : public TestTriggerManager
449 {
450 public:
451 using FilePath = interfaces::JsonStorage::FilePath;
452 using DirectoryPath = interfaces::JsonStorage::DirectoryPath;
453
SetUp()454 void SetUp() override
455 {
456 ON_CALL(storageMock, list())
457 .WillByDefault(Return(std::vector<FilePath>{
458 {FilePath("trigger1")}, {FilePath("trigger2")}}));
459
460 ON_CALL(storageMock, load(FilePath("trigger1")))
461 .WillByDefault(InvokeWithoutArgs([this] { return data1; }));
462
463 data2["Id"] = "Trigger2";
464 data2["Name"] = "Second Trigger";
465 ON_CALL(storageMock, load(FilePath("trigger2")))
466 .WillByDefault(InvokeWithoutArgs([this] { return data2; }));
467 }
468
469 nlohmann::json data1 = nlohmann::json{
470 {"Version", Trigger::triggerVersion},
471 {"Id", TriggerParams().id()},
472 {"Name", TriggerParams().name()},
473 {"ThresholdParamsDiscriminator",
474 TriggerParams().thresholdParams().index()},
475 {"TriggerActions", utils::transform(TriggerParams().triggerActions(),
__anon9b6542d30502(const auto& action) 476 [](const auto& action) {
477 return actionToString(action);
478 })},
479 {"ThresholdParams", utils::labeledThresholdParamsToJson(
480 TriggerParams().thresholdParams())},
481 {"ReportIds", TriggerParams().reportIds()},
482 {"Sensors", TriggerParams().sensors()}};
483
484 nlohmann::json data2 = data1;
485 };
486
TEST_F(TestTriggerManagerStorage,triggerManagerCtorAddTriggerFromStorage)487 TEST_F(TestTriggerManagerStorage, triggerManagerCtorAddTriggerFromStorage)
488 {
489 triggerFactoryMock.expectMake(TriggerParams(), _, Ref(storageMock));
490 triggerFactoryMock.expectMake(
491 TriggerParams().id("Trigger2").name("Second Trigger"), _,
492 Ref(storageMock));
493 EXPECT_CALL(storageMock, remove(_)).Times(0);
494
495 sut = makeTriggerManager();
496 }
497
TEST_F(TestTriggerManagerStorage,triggerManagerCtorRemoveDiscreteTriggerFromStorage)498 TEST_F(TestTriggerManagerStorage,
499 triggerManagerCtorRemoveDiscreteTriggerFromStorage)
500 {
501 LabeledTriggerThresholdParams thresholdParams =
502 std::vector<discrete::LabeledThresholdParam>{
503 {"userId1", discrete::Severity::warning, 15, "10.0"},
504 {"userId2", discrete::Severity::critical, 5, "20.0"}};
505
506 data1["ThresholdParamsDiscriminator"] = thresholdParams.index();
507
508 data1["ThresholdParams"] =
509 utils::labeledThresholdParamsToJson(thresholdParams);
510
511 EXPECT_CALL(storageMock, remove(FilePath("trigger1"))).Times(0);
512
513 sut = makeTriggerManager();
514 }
515
TEST_F(TestTriggerManagerStorage,triggerManagerCtorRemoveDiscreteTriggerFromStorage2)516 TEST_F(TestTriggerManagerStorage,
517 triggerManagerCtorRemoveDiscreteTriggerFromStorage2)
518 {
519 data1["IsDiscrete"] = true;
520
521 EXPECT_CALL(storageMock, remove(FilePath("trigger1"))).Times(0);
522
523 sut = makeTriggerManager();
524 }
525
TEST_F(TestTriggerManagerStorage,triggerManagerCtorAddProperRemoveInvalidTriggerFromStorage)526 TEST_F(TestTriggerManagerStorage,
527 triggerManagerCtorAddProperRemoveInvalidTriggerFromStorage)
528 {
529 data1["Version"] = Trigger::triggerVersion - 1;
530
531 triggerFactoryMock.expectMake(
532 TriggerParams().id("Trigger2").name("Second Trigger"), _,
533 Ref(storageMock));
534 EXPECT_CALL(storageMock, remove(FilePath("trigger1")));
535
536 sut = makeTriggerManager();
537 }
538