1 #include "dbus_environment.hpp"
2 #include "helpers.hpp"
3 #include "interfaces/trigger_manager.hpp"
4 #include "mocks/json_storage_mock.hpp"
5 #include "mocks/report_factory_mock.hpp"
6 #include "mocks/trigger_manager_mock.hpp"
7 #include "params/report_params.hpp"
8 #include "report.hpp"
9 #include "report_manager.hpp"
10 #include "utils/conversion.hpp"
11 #include "utils/dbus_path_utils.hpp"
12 #include "utils/string_utils.hpp"
13 #include "utils/transform.hpp"
14 #include "utils/tstring.hpp"
15 #include "utils/variant_utils.hpp"
16
17 #include <xyz/openbmc_project/Telemetry/Report/common.hpp>
18 #include <xyz/openbmc_project/Telemetry/ReportManager/common.hpp>
19
20 using namespace testing;
21 using namespace std::string_literals;
22 using namespace std::chrono_literals;
23
24 using AddReportVariantForSet = utils::WithoutMonostate<AddReportVariant>;
25
26 using TelemetryReport =
27 sdbusplus::common::xyz::openbmc_project::telemetry::Report;
28 using TelemetryReportManager =
29 sdbusplus::common::xyz::openbmc_project::telemetry::ReportManager;
30
31 class TestReportManager : public Test
32 {
33 public:
34 ReportParams reportParams;
35
36 std::unique_ptr<ReportFactoryMock> reportFactoryMockPtr =
37 std::make_unique<StrictMock<ReportFactoryMock>>();
38 ReportFactoryMock& reportFactoryMock = *reportFactoryMockPtr;
39
40 std::unique_ptr<StorageMock> storageMockPtr =
41 std::make_unique<NiceMock<StorageMock>>();
42 StorageMock& storageMock = *storageMockPtr;
43
44 std::unique_ptr<ReportMock> reportMockPtr =
45 std::make_unique<NiceMock<ReportMock>>(reportParams.reportId());
46 ReportMock& reportMock = *reportMockPtr;
47
48 std::unique_ptr<ReportManager> sut;
49
50 MockFunction<void(std::string)> checkPoint;
51
SetUp()52 void SetUp() override
53 {
54 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _))
55 .Times(AnyNumber());
56
57 sut = std::make_unique<ReportManager>(
58 std::move(reportFactoryMockPtr), std::move(storageMockPtr),
59 DbusEnvironment::getObjServer());
60 }
61
TearDown()62 void TearDown() override
63 {
64 DbusEnvironment::synchronizeIoc();
65 }
66
67 template <class... Args>
68 requires(sizeof...(Args) > 1)
addReport(Args &&...args)69 std::pair<boost::system::error_code, std::string> addReport(Args&&... args)
70 {
71 std::promise<std::pair<boost::system::error_code, std::string>>
72 addReportPromise;
73 DbusEnvironment::getBus()->async_method_call(
74 [&addReportPromise](boost::system::error_code ec,
75 const std::string& path) {
76 addReportPromise.set_value({ec, path});
77 },
78 DbusEnvironment::serviceName(), TelemetryReport::namespace_path,
79 TelemetryReportManager::interface,
80 TelemetryReportManager::method_names::add_report,
81 std::forward<Args>(args)...);
82 return DbusEnvironment::waitForFuture(addReportPromise.get_future());
83 }
84
addReport(const ReportParams & params)85 auto addReport(const ReportParams& params)
86 {
87 return addReport(
88 params.reportId(), params.reportName(),
89 utils::enumToString(params.reportingType()),
90 utils::enumToString(params.reportUpdates()), params.appendLimit(),
91 utils::transform(params.reportActions(),
92 [](const auto v) {
93 return utils::enumToString(v);
94 }),
95 params.interval().count(),
96 toReadingParameters(params.metricParameters()), params.enabled());
97 }
98
99 template <class T>
getProperty(const std::string & property)100 static T getProperty(const std::string& property)
101 {
102 return DbusEnvironment::getProperty<T>(
103 TelemetryReport::namespace_path, TelemetryReportManager::interface,
104 property);
105 }
106 };
107
TEST_F(TestReportManager,minInterval)108 TEST_F(TestReportManager, minInterval)
109 {
110 EXPECT_THAT(getProperty<uint64_t>(
111 TelemetryReportManager::property_names::min_interval),
112 Eq(ReportManager::minInterval.count()));
113 }
114
TEST_F(TestReportManager,maxReports)115 TEST_F(TestReportManager, maxReports)
116 {
117 EXPECT_THAT(getProperty<size_t>(
118 TelemetryReportManager::property_names::max_reports),
119 Eq(ReportManager::maxReports));
120 }
121
TEST_F(TestReportManager,returnsPropertySupportedOperationTypes)122 TEST_F(TestReportManager, returnsPropertySupportedOperationTypes)
123 {
124 EXPECT_THAT(
125 getProperty<std::vector<std::string>>(
126 TelemetryReportManager::property_names::supported_operation_types),
127 UnorderedElementsAre(utils::enumToString(OperationType::max),
128 utils::enumToString(OperationType::min),
129 utils::enumToString(OperationType::avg),
130 utils::enumToString(OperationType::sum)));
131 }
132
TEST_F(TestReportManager,addReport)133 TEST_F(TestReportManager, addReport)
134 {
135 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
136 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
137 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
138
139 auto [ec, path] = addReport(reportParams);
140 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
141 EXPECT_THAT(path, Eq(reportMock.getPath()));
142 }
143
TEST_F(TestReportManager,addDisabledReport)144 TEST_F(TestReportManager, addDisabledReport)
145 {
146 reportParams.enabled(false);
147
148 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
149 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
150 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
151
152 auto [ec, path] = addReport(reportParams);
153 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
154 EXPECT_THAT(path, Eq(reportMock.getPath()));
155 }
156
TEST_F(TestReportManager,addReportWithOnlyDefaultParams)157 TEST_F(TestReportManager, addReportWithOnlyDefaultParams)
158 {
159 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
160 EXPECT_CALL(reportFactoryMock,
161 make("Report"s, "Report"s, ReportingType::onRequest,
162 std::vector<ReportAction>{}, Milliseconds{}, 256,
163 ReportUpdates::overwrite, _, _,
164 std::vector<LabeledMetricParameters>{}, true, Readings{}))
165 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
166
167 auto [ec, path] = addReport(
168 "", "", "", "", std::numeric_limits<uint64_t>::max(),
169 std::vector<std::string>(), std::numeric_limits<uint64_t>::max(),
170 ReadingParameters(), true);
171
172 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
173 EXPECT_THAT(path, Eq(reportMock.getPath()));
174 }
175
TEST_F(TestReportManager,addOnChangeReport)176 TEST_F(TestReportManager, addOnChangeReport)
177 {
178 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
179 reportFactoryMock
180 .expectMake(reportParams.reportingType(ReportingType::onChange),
181 Ref(*sut), Ref(storageMock))
182 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
183
184 auto [ec, path] = addReport(reportParams);
185 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
186 EXPECT_THAT(path, Eq(reportMock.getPath()));
187 }
188
TEST_F(TestReportManager,nameIsUsedToGenerateIdWhenIdIsEmptyInAddReport)189 TEST_F(TestReportManager, nameIsUsedToGenerateIdWhenIdIsEmptyInAddReport)
190 {
191 reportParams.reportId("ReportName");
192 reportParams.reportName("ReportName");
193
194 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock));
195
196 auto [ec, path] = addReport(reportParams.reportId(""));
197
198 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
199 EXPECT_THAT(path, Eq("/ReportName"));
200 }
201
TEST_F(TestReportManager,nameIsUsedToGenerateIdWhenIdIsNamespace)202 TEST_F(TestReportManager, nameIsUsedToGenerateIdWhenIdIsNamespace)
203 {
204 reportParams.reportId("Prefix/ReportName");
205 reportParams.reportName("ReportName");
206
207 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock));
208
209 auto [ec, path] = addReport(reportParams.reportId("Prefix/"));
210
211 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
212 EXPECT_THAT(path, Eq("/Prefix/ReportName"));
213 }
214
TEST_F(TestReportManager,addReportWithMaxLengthId)215 TEST_F(TestReportManager, addReportWithMaxLengthId)
216 {
217 std::string reportId = utils::string_utils::getMaxId();
218 reportParams.reportId(reportId);
219 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock));
220
221 auto [ec, path] = addReport(reportParams);
222
223 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
224 EXPECT_THAT(path, Eq("/"s + reportId));
225 }
226
TEST_F(TestReportManager,addReportWithMaxLengthPrefix)227 TEST_F(TestReportManager, addReportWithMaxLengthPrefix)
228 {
229 std::string reportId = utils::string_utils::getMaxPrefix() + "/MyId";
230 reportParams.reportId(reportId);
231 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock));
232
233 auto [ec, path] = addReport(reportParams);
234
235 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
236 EXPECT_THAT(path, Eq("/"s + reportId));
237 }
238
TEST_F(TestReportManager,addReportWithMaxLengthName)239 TEST_F(TestReportManager, addReportWithMaxLengthName)
240 {
241 reportParams.reportName(utils::string_utils::getMaxName());
242 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock));
243
244 auto [ec, path] = addReport(reportParams);
245
246 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
247 EXPECT_THAT(path, Eq("/"s + reportParams.reportId()));
248 }
249
TEST_F(TestReportManager,failToAddReportWithTooLongFullId)250 TEST_F(TestReportManager, failToAddReportWithTooLongFullId)
251 {
252 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
253 .Times(0);
254
255 reportParams.reportId(
256 std::string(utils::constants::maxReportFullIdLength + 1, 'z'));
257
258 auto [ec, path] = addReport(reportParams);
259
260 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
261 EXPECT_THAT(path, Eq(std::string()));
262 }
263
TEST_F(TestReportManager,failToAddReportWithTooLongId)264 TEST_F(TestReportManager, failToAddReportWithTooLongId)
265 {
266 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
267 .Times(0);
268
269 reportParams.reportId(utils::string_utils::getTooLongId());
270
271 auto [ec, path] = addReport(reportParams);
272
273 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
274 EXPECT_THAT(path, Eq(std::string()));
275 }
276
TEST_F(TestReportManager,failToAddReportWithTooLongPrefix)277 TEST_F(TestReportManager, failToAddReportWithTooLongPrefix)
278 {
279 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
280 .Times(0);
281
282 reportParams.reportId(utils::string_utils::getTooLongPrefix() + "/MyId");
283
284 auto [ec, path] = addReport(reportParams);
285
286 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
287 EXPECT_THAT(path, Eq(std::string()));
288 }
289
TEST_F(TestReportManager,failToAddReportWithTooManyPrefixes)290 TEST_F(TestReportManager, failToAddReportWithTooManyPrefixes)
291 {
292 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
293 .Times(0);
294
295 std::string reportId;
296 for (size_t i = 0; i < utils::constants::maxPrefixesInId + 1; i++)
297 {
298 reportId += "prefix/";
299 }
300 reportId += "MyId";
301
302 reportParams.reportId(reportId);
303
304 auto [ec, path] = addReport(reportParams);
305
306 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
307 EXPECT_THAT(path, Eq(std::string()));
308 }
309
TEST_F(TestReportManager,failToAddReportWithTooLongName)310 TEST_F(TestReportManager, failToAddReportWithTooLongName)
311 {
312 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
313 .Times(0);
314
315 reportParams.reportName(utils::string_utils::getTooLongName());
316
317 auto [ec, path] = addReport(reportParams);
318
319 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
320 EXPECT_THAT(path, Eq(std::string()));
321 }
322
TEST_F(TestReportManager,failToAddReportTwice)323 TEST_F(TestReportManager, failToAddReportTwice)
324 {
325 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
326 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
327
328 addReport(reportParams);
329
330 auto [ec, path] = addReport(reportParams);
331
332 EXPECT_THAT(ec.value(), Eq(boost::system::errc::file_exists));
333 EXPECT_THAT(path, Eq(std::string()));
334 }
335
TEST_F(TestReportManager,failToAddReportWithInvalidInterval)336 TEST_F(TestReportManager, failToAddReportWithInvalidInterval)
337 {
338 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
339 .Times(0);
340
341 reportParams.reportingType(ReportingType::periodic);
342 reportParams.interval(ReportManager::minInterval - 1ms);
343
344 auto [ec, path] = addReport(reportParams);
345
346 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
347 EXPECT_THAT(path, Eq(std::string()));
348 }
349
TEST_F(TestReportManager,failToAddReportWithInvalidReportingType)350 TEST_F(TestReportManager, failToAddReportWithInvalidReportingType)
351 {
352 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
353 .Times(0);
354
355 auto [ec, path] = addReport(
356 "", "", "InvalidReportingType", "",
357 std::numeric_limits<uint64_t>::max(), std::vector<std::string>(),
358 std::numeric_limits<uint64_t>::max(), ReadingParameters(), false);
359
360 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
361 EXPECT_THAT(path, Eq(std::string()));
362 }
363
TEST_F(TestReportManager,failToAddReportWithMoreMetricPropertiesThanExpected)364 TEST_F(TestReportManager, failToAddReportWithMoreMetricPropertiesThanExpected)
365 {
366 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
367 .Times(0);
368
369 reportParams.metricParameters(
370 std::vector<LabeledMetricParameters>{{LabeledMetricParameters{
371 {LabeledSensorInfo{"Service",
372 "/xyz/openbmc_project/sensors/power/p1",
373 "Metadata1"}},
374 OperationType::avg,
375 CollectionTimeScope::point,
376 CollectionDuration(Milliseconds(0u))}}});
377
378 auto metricParams = reportParams.metricParameters();
379 auto& metricParamsVec =
380 metricParams[0].at_label<utils::tstring::SensorPath>();
381
382 for (size_t i = 0; i < ReportManager::maxNumberMetrics; i++)
383 {
384 metricParamsVec.emplace_back(LabeledSensorInfo{
385 "Service", "/xyz/openbmc_project/sensors/power/p1", "Metadata1"});
386 }
387
388 reportParams.metricParameters(std::move(metricParams));
389
390 auto [ec, path] = addReport(reportParams);
391
392 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
393 EXPECT_THAT(path, Eq(std::string()));
394 }
395
TEST_F(TestReportManager,failToAddReportWithMoreMetricsThanExpected)396 TEST_F(TestReportManager, failToAddReportWithMoreMetricsThanExpected)
397 {
398 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
399 .Times(0);
400
401 auto metricParams = std::vector<LabeledMetricParameters>{};
402
403 for (size_t i = 0; i < ReportManager::maxNumberMetrics + 1; i++)
404 {
405 metricParams.emplace_back(LabeledMetricParameters{
406 {},
407 OperationType::avg,
408 CollectionTimeScope::point,
409 CollectionDuration(Milliseconds(0u))});
410 }
411
412 reportParams.metricParameters(std::move(metricParams));
413
414 auto [ec, path] = addReport(reportParams);
415
416 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
417 EXPECT_THAT(path, Eq(std::string()));
418 }
419
TEST_F(TestReportManager,failToAddReportWithAppendLimitGreaterThanMax)420 TEST_F(TestReportManager, failToAddReportWithAppendLimitGreaterThanMax)
421 {
422 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
423 .Times(0);
424
425 reportParams.appendLimit(ReportManager::maxAppendLimit + 1);
426
427 auto [ec, path] = addReport(reportParams);
428
429 EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
430 EXPECT_THAT(path, Eq(std::string()));
431 }
432
TEST_F(TestReportManager,addReportWithAppendLimitEqualToUint64MaxIsAllowed)433 TEST_F(TestReportManager, addReportWithAppendLimitEqualToUint64MaxIsAllowed)
434 {
435 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
436 reportFactoryMock
437 .expectMake(reportParams.appendLimit(ReportManager::maxAppendLimit),
438 Ref(*sut), Ref(storageMock))
439 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
440
441 auto [ec, path] = addReport(
442 reportParams.appendLimit(std::numeric_limits<uint64_t>::max()));
443 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
444 EXPECT_THAT(path, Eq(reportMock.getPath()));
445 }
446
TEST_F(TestReportManager,failToAddReportWhenMaxReportIsReached)447 TEST_F(TestReportManager, failToAddReportWhenMaxReportIsReached)
448 {
449 reportFactoryMock.expectMake(std::nullopt, Ref(*sut), Ref(storageMock))
450 .Times(ReportManager::maxReports);
451
452 for (size_t i = 0; i < ReportManager::maxReports; i++)
453 {
454 reportParams.reportId(reportParams.reportName() + std::to_string(i));
455
456 auto [ec, path] = addReport(reportParams);
457 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
458 }
459
460 reportParams.reportId(
461 reportParams.reportName() + std::to_string(ReportManager::maxReports));
462 auto [ec, path] = addReport(reportParams);
463
464 EXPECT_THAT(ec.value(), Eq(boost::system::errc::too_many_files_open));
465 EXPECT_THAT(path, Eq(std::string()));
466 }
467
TEST_F(TestReportManager,removeReport)468 TEST_F(TestReportManager, removeReport)
469 {
470 {
471 InSequence seq;
472 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
473 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
474 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
475 EXPECT_CALL(reportMock, Die());
476 EXPECT_CALL(checkPoint, Call("end"));
477 }
478
479 addReport(reportParams);
480 sut->removeReport(&reportMock);
481 checkPoint.Call("end");
482 }
483
TEST_F(TestReportManager,removingReportThatIsNotInContainerHasNoEffect)484 TEST_F(TestReportManager, removingReportThatIsNotInContainerHasNoEffect)
485 {
486 {
487 InSequence seq;
488 EXPECT_CALL(checkPoint, Call("end"));
489 EXPECT_CALL(reportMock, Die());
490 }
491
492 sut->removeReport(&reportMock);
493 checkPoint.Call("end");
494 }
495
TEST_F(TestReportManager,removingSameReportTwiceHasNoSideEffect)496 TEST_F(TestReportManager, removingSameReportTwiceHasNoSideEffect)
497 {
498 {
499 InSequence seq;
500 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
501 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
502 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
503 EXPECT_CALL(reportMock, Die());
504 EXPECT_CALL(checkPoint, Call("end"));
505 }
506
507 addReport(reportParams);
508 sut->removeReport(&reportMock);
509 sut->removeReport(&reportMock);
510 checkPoint.Call("end");
511 }
512
513 class TestReportManagerWithAggregationOperationType :
514 public TestReportManager,
515 public WithParamInterface<OperationType>
516 {
517 public:
518 OperationType operationType = GetParam();
519 };
520
521 INSTANTIATE_TEST_SUITE_P(_, TestReportManagerWithAggregationOperationType,
522 Values(OperationType::max, OperationType::min,
523 OperationType::avg, OperationType::sum));
524
TEST_P(TestReportManagerWithAggregationOperationType,addReportWithDifferentOperationTypes)525 TEST_P(TestReportManagerWithAggregationOperationType,
526 addReportWithDifferentOperationTypes)
527 {
528 reportParams.metricParameters(
529 std::vector<LabeledMetricParameters>{{LabeledMetricParameters{
530 {LabeledSensorInfo{"Service",
531 "/xyz/openbmc_project/sensors/power/p1",
532 "Metadata1"}},
533 operationType,
534 CollectionTimeScope::point,
535 CollectionDuration(Milliseconds(0u))}}});
536
537 reportFactoryMock.expectMake(reportParams, Ref(*sut), Ref(storageMock))
538 .WillOnce(Return(ByMove(std::move(reportMockPtr))));
539
540 auto [ec, path] = addReport(reportParams);
541
542 EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
543 EXPECT_THAT(path, Eq("/"s + reportParams.reportId()));
544 }
545
546 class TestReportManagerStorage : public TestReportManager
547 {
548 public:
549 using FilePath = interfaces::JsonStorage::FilePath;
550 using DirectoryPath = interfaces::JsonStorage::DirectoryPath;
551
SetUp()552 void SetUp() override
553 {
554 EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _)).Times(0);
555
556 ON_CALL(storageMock, list())
557 .WillByDefault(Return(std::vector<FilePath>{FilePath("report1")}));
558 ON_CALL(storageMock, load(FilePath("report1")))
559 .WillByDefault(InvokeWithoutArgs([this] { return data; }));
560 }
561
makeReportManager()562 void makeReportManager()
563 {
564 sut = std::make_unique<ReportManager>(
565 std::move(reportFactoryMockPtr), std::move(storageMockPtr),
566 DbusEnvironment::getObjServer());
567 }
568
569 nlohmann::json data = nlohmann::json{
570 {"Enabled", reportParams.enabled()},
571 {"Version", Report::reportVersion},
572 {"Id", reportParams.reportId()},
573 {"Name", reportParams.reportName()},
574 {"ReportingType", utils::toUnderlying(reportParams.reportingType())},
575 {"ReportActions", reportParams.reportActions()},
576 {"Interval", reportParams.interval().count()},
577 {"ReportUpdates", utils::toUnderlying(reportParams.reportUpdates())},
578 {"AppendLimit", reportParams.appendLimit()},
579 {"ReadingParameters", reportParams.metricParameters()}};
580 };
581
TEST_F(TestReportManagerStorage,reportManagerCtorAddReportFromStorage)582 TEST_F(TestReportManagerStorage, reportManagerCtorAddReportFromStorage)
583 {
584 reportFactoryMock.expectMake(reportParams, _, Ref(storageMock));
585
586 makeReportManager();
587 }
588
TEST_F(TestReportManagerStorage,reportManagerCtorRemoveFileIfVersionDoesNotMatch)589 TEST_F(TestReportManagerStorage,
590 reportManagerCtorRemoveFileIfVersionDoesNotMatch)
591 {
592 data["Version"] = Report::reportVersion - 1;
593
594 EXPECT_CALL(storageMock, remove(FilePath("report1")));
595
596 makeReportManager();
597 }
598
TEST_F(TestReportManagerStorage,reportManagerCtorRemoveFileIfIntervalHasWrongType)599 TEST_F(TestReportManagerStorage,
600 reportManagerCtorRemoveFileIfIntervalHasWrongType)
601 {
602 data["Interval"] = "1000";
603
604 EXPECT_CALL(storageMock, remove(FilePath("report1")));
605
606 makeReportManager();
607 }
608