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