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