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