added support for onChange report
Report is now notified when metric changes and updates reading values.
Tested:
- Added new unit tests
- OnChange report updates Readings when metric values changes
Change-Id: I3be9ef7aa0486cb15bac627aa1de5cc632613b3b
Signed-off-by: Krzysztof Grobelny <krzysztof.grobelny@intel.com>
diff --git a/tests/meson.build b/tests/meson.build
index 89c6a00..5c21d88 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -11,9 +11,10 @@
executable(
'telemetry-ut',
[
- '../src/details/collection_function.cpp',
'../src/discrete_threshold.cpp',
'../src/metric.cpp',
+ '../src/metrics/collection_data.cpp',
+ '../src/metrics/collection_function.cpp',
'../src/numeric_threshold.cpp',
'../src/on_change_threshold.cpp',
'../src/persistent_json_storage.cpp',
@@ -36,6 +37,7 @@
'src/test_conversion.cpp',
'src/test_detached_timer.cpp',
'src/test_discrete_threshold.cpp',
+ 'src/test_ensure.cpp',
'src/test_generate_id.cpp',
'src/test_metric.cpp',
'src/test_numeric_threshold.cpp',
diff --git a/tests/src/mocks/metric_listener_mock.hpp b/tests/src/mocks/metric_listener_mock.hpp
new file mode 100644
index 0000000..2e3daf9
--- /dev/null
+++ b/tests/src/mocks/metric_listener_mock.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "interfaces/metric_listener.hpp"
+
+#include <gmock/gmock.h>
+
+class MetricListenerMock : public interfaces::MetricListener
+{
+ public:
+ MOCK_METHOD(void, metricUpdated, (), (override));
+};
diff --git a/tests/src/mocks/metric_mock.hpp b/tests/src/mocks/metric_mock.hpp
index 268b681..a223734 100644
--- a/tests/src/mocks/metric_mock.hpp
+++ b/tests/src/mocks/metric_mock.hpp
@@ -13,6 +13,9 @@
ON_CALL(*this, getReadings())
.WillByDefault(Return(std::vector<MetricValue>()));
+ ON_CALL(*this, sensorCount).WillByDefault(InvokeWithoutArgs([this] {
+ return getReadings().size();
+ }));
}
MOCK_METHOD(void, initialize, (), (override));
@@ -20,9 +23,11 @@
MOCK_METHOD(std::vector<MetricValue>, getReadings, (), (const, override));
MOCK_METHOD(LabeledMetricParameters, dumpConfiguration, (),
(const, override));
-
- uint64_t sensorCount() const override
- {
- return getReadings().size();
- }
+ MOCK_METHOD(uint64_t, sensorCount, (), (const, override));
+ MOCK_METHOD(void, registerForUpdates, (interfaces::MetricListener&),
+ (override));
+ MOCK_METHOD(void, unregisterFromUpdates, (interfaces::MetricListener&),
+ (override));
+ MOCK_METHOD(void, updateReadings, (Milliseconds), (override));
+ MOCK_METHOD(bool, isTimerRequired, (), (const, override));
};
diff --git a/tests/src/mocks/sensor_listener_mock.hpp b/tests/src/mocks/sensor_listener_mock.hpp
index a5c0331..d23e349 100644
--- a/tests/src/mocks/sensor_listener_mock.hpp
+++ b/tests/src/mocks/sensor_listener_mock.hpp
@@ -7,21 +7,6 @@
class SensorListenerMock : public interfaces::SensorListener
{
public:
- void delegateIgnoringArgs()
- {
- using namespace testing;
-
- ON_CALL(*this, sensorUpdated(_, _))
- .WillByDefault(InvokeWithoutArgs([this] { sensorUpdated(); }));
-
- ON_CALL(*this, sensorUpdated(_, _, _))
- .WillByDefault(InvokeWithoutArgs([this] { sensorUpdated(); }));
- }
-
- MOCK_METHOD(void, sensorUpdated, (interfaces::Sensor&, Milliseconds),
- (override));
MOCK_METHOD(void, sensorUpdated,
(interfaces::Sensor&, Milliseconds, double), (override));
-
- MOCK_METHOD(void, sensorUpdated, (), ());
};
diff --git a/tests/src/params/metric_params.hpp b/tests/src/params/metric_params.hpp
index 90db484..cc5519d 100644
--- a/tests/src/params/metric_params.hpp
+++ b/tests/src/params/metric_params.hpp
@@ -79,6 +79,17 @@
return expectedReadingProperty;
}
+ bool expectedIsTimerRequired() const
+ {
+ return expectedIsTimerRequiredProperty;
+ }
+
+ MetricParams& expectedIsTimerRequired(bool value)
+ {
+ expectedIsTimerRequiredProperty = value;
+ return *this;
+ }
+
private:
OperationType operationTypeProperty = {};
std::string idProperty = "MetricId";
@@ -87,6 +98,7 @@
CollectionDuration(Milliseconds(0u));
std::vector<std::pair<Milliseconds, double>> readingsProperty = {};
std::pair<Milliseconds, double> expectedReadingProperty = {};
+ bool expectedIsTimerRequiredProperty = true;
};
inline std::ostream& operator<<(std::ostream& os, const MetricParams& mp)
@@ -103,6 +115,8 @@
}
auto [timestamp, reading] = mp.expectedReading();
- os << " }, expected: " << reading << "(" << timestamp.count() << "ms) }";
+ os << " }, expectedReading: " << reading << "(" << timestamp.count()
+ << "ms), expectedIsTimerRequired: " << std::boolalpha
+ << mp.expectedIsTimerRequired() << " }";
return os;
}
diff --git a/tests/src/test_ensure.cpp b/tests/src/test_ensure.cpp
new file mode 100644
index 0000000..b604538
--- /dev/null
+++ b/tests/src/test_ensure.cpp
@@ -0,0 +1,52 @@
+#include "utils/ensure.hpp"
+
+#include <gmock/gmock.h>
+
+using namespace testing;
+
+class TestEnsure : public Test
+{
+ public:
+ utils::Ensure<std::function<void()>> makeEnsure()
+ {
+ return [this] { ++executed; };
+ }
+
+ utils::Ensure<std::function<void()>> sut;
+ size_t executed = 0u;
+};
+
+TEST_F(TestEnsure, executesCallbackOnceWhenDestroyed)
+{
+ sut = makeEnsure();
+ sut = nullptr;
+
+ EXPECT_THAT(executed, Eq(1u));
+}
+
+TEST_F(TestEnsure, executesCallbackOnceWhenMoved)
+{
+ sut = makeEnsure();
+ auto copy = std::move(sut);
+ copy = nullptr;
+
+ EXPECT_THAT(executed, Eq(1u));
+}
+
+TEST_F(TestEnsure, executesCallbackTwiceWhenReplaced)
+{
+ sut = makeEnsure();
+ sut = makeEnsure();
+ sut = nullptr;
+
+ EXPECT_THAT(executed, Eq(2u));
+}
+
+TEST_F(TestEnsure, executesCallbackTwiceWhenNewCallbackAssigned)
+{
+ sut = makeEnsure();
+ sut = [this] { executed += 10; };
+ sut = nullptr;
+
+ EXPECT_THAT(executed, Eq(11u));
+}
diff --git a/tests/src/test_metric.cpp b/tests/src/test_metric.cpp
index 31eabc6..f30b4f3 100644
--- a/tests/src/test_metric.cpp
+++ b/tests/src/test_metric.cpp
@@ -1,6 +1,7 @@
#include "fakes/clock_fake.hpp"
#include "helpers.hpp"
#include "metric.hpp"
+#include "mocks/metric_listener_mock.hpp"
#include "mocks/sensor_mock.hpp"
#include "params/metric_params.hpp"
#include "utils/conv_container.hpp"
@@ -55,6 +56,7 @@
std::vector<std::shared_ptr<SensorMock>> sensorMocks = makeSensorMocks(1u);
std::unique_ptr<ClockFake> clockFakePtr = std::make_unique<ClockFake>();
ClockFake& clockFake = *clockFakePtr;
+ NiceMock<MetricListenerMock> listenerMock;
std::shared_ptr<Metric> sut;
};
@@ -90,6 +92,34 @@
ElementsAre(MetricValue({"id", "metadata", 0., 0u})));
}
+TEST_F(TestMetric,
+ notifiesRegisteredListenersOnManualUpdateWhenMetricValueChanges)
+{
+ sut = makeSut(params.collectionTimeScope(CollectionTimeScope::startup));
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{18}, 31.2);
+ sut->registerForUpdates(listenerMock);
+
+ EXPECT_CALL(listenerMock, metricUpdated()).Times(2);
+
+ sut->updateReadings(Milliseconds{50u});
+ sut->updateReadings(Milliseconds{100u});
+}
+
+TEST_F(TestMetric,
+ doesntNotifyRegisteredListenersOnManualUpdateWhenMetricValueDoesntChange)
+{
+ sut = makeSut(params.collectionTimeScope(CollectionTimeScope::startup)
+ .operationType(OperationType::max));
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{18}, 31.2);
+ sut->registerForUpdates(listenerMock);
+
+ EXPECT_CALL(listenerMock, metricUpdated()).Times(0);
+
+ sut->updateReadings(Milliseconds{50u});
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{180}, 11.);
+ sut->updateReadings(Milliseconds{100u});
+}
+
class TestMetricAfterInitialization : public TestMetric
{
public:
@@ -122,8 +152,6 @@
throwsWhenUpdateIsPerformedOnUnknownSensor)
{
auto sensor = std::make_shared<StrictMock<SensorMock>>();
- EXPECT_THROW(sut->sensorUpdated(*sensor, Milliseconds{10}),
- std::out_of_range);
EXPECT_THROW(sut->sensorUpdated(*sensor, Milliseconds{10}, 20.0),
std::out_of_range);
}
@@ -150,6 +178,33 @@
EXPECT_THAT(conf, Eq(expected));
}
+TEST_F(TestMetricAfterInitialization, notifiesRegisteredListeners)
+{
+ EXPECT_CALL(listenerMock, metricUpdated());
+
+ sut->registerForUpdates(listenerMock);
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{18}, 31.2);
+}
+
+TEST_F(TestMetricAfterInitialization,
+ doesntNotifyRegisteredListenersWhenValueDoesntChange)
+{
+ EXPECT_CALL(listenerMock, metricUpdated());
+
+ sut->registerForUpdates(listenerMock);
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{18}, 31.2);
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{70}, 31.2);
+}
+
+TEST_F(TestMetricAfterInitialization, doesntNotifyAfterUnRegisterListener)
+{
+ EXPECT_CALL(listenerMock, metricUpdated()).Times(0);
+
+ sut->registerForUpdates(listenerMock);
+ sut->unregisterFromUpdates(listenerMock);
+ sut->sensorUpdated(*sensorMocks.front(), Milliseconds{18}, 31.2);
+}
+
class TestMetricCalculationFunctions :
public TestMetric,
public WithParamInterface<MetricParams>
@@ -182,8 +237,9 @@
MetricParams defaultPointParams()
{
- return defaultCollectionFunctionParams().collectionTimeScope(
- CollectionTimeScope::point);
+ return defaultCollectionFunctionParams()
+ .collectionTimeScope(CollectionTimeScope::point)
+ .expectedIsTimerRequired(false);
}
INSTANTIATE_TEST_SUITE_P(
@@ -210,7 +266,8 @@
.expectedReading(systemTimestamp + 16ms, 7.0),
defaultMinParams()
.collectionTimeScope(CollectionTimeScope::startup)
- .expectedReading(systemTimestamp + 16ms, 3.0)));
+ .expectedReading(systemTimestamp + 16ms, 3.0)
+ .expectedIsTimerRequired(false)));
MetricParams defaultMaxParams()
{
@@ -233,7 +290,8 @@
.expectedReading(systemTimestamp + 16ms, 7.0),
defaultMaxParams()
.collectionTimeScope(CollectionTimeScope::startup)
- .expectedReading(systemTimestamp + 16ms, 14.0)));
+ .expectedReading(systemTimestamp + 16ms, 14.0)
+ .expectedIsTimerRequired(false)));
MetricParams defaultSumParams()
{
@@ -324,3 +382,9 @@
ElementsAre(MetricValue{"id", "metadata", expectedReading,
expectedTimestamp.count()}));
}
+
+TEST_P(TestMetricCalculationFunctions, returnsIsTimerRequired)
+{
+ EXPECT_THAT(sut->isTimerRequired(),
+ Eq(GetParam().expectedIsTimerRequired()));
+}
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
index 9afa421..7646230 100644
--- a/tests/src/test_report.cpp
+++ b/tests/src/test_report.cpp
@@ -27,11 +27,24 @@
constexpr Milliseconds systemTimestamp = 55ms;
+namespace
+{
+
+ReportParams defaultParams()
+{
+ return ReportParams();
+}
+
+ReportParams defaultOnChangeParams()
+{
+ return defaultParams().reportingType(ReportingType::onChange);
+}
+
+} // namespace
+
class TestReport : public Test
{
public:
- ReportParams defaultParams;
-
std::unique_ptr<ReportManagerMock> reportManagerMock =
std::make_unique<NiceMock<ReportManagerMock>>();
std::unique_ptr<ReportFactoryMock> reportFactoryMock =
@@ -92,7 +105,7 @@
void SetUp() override
{
- sut = makeReport(ReportParams());
+ sut = makeReport(defaultParams());
}
static interfaces::JsonStorage::FilePath to_file_path(std::string id)
@@ -157,39 +170,39 @@
TEST_F(TestReport, returnsId)
{
- EXPECT_THAT(sut->getId(), Eq(defaultParams.reportId()));
+ EXPECT_THAT(sut->getId(), Eq(defaultParams().reportId()));
}
TEST_F(TestReport, verifyIfPropertiesHaveValidValue)
{
EXPECT_THAT(getProperty<bool>(sut->getPath(), "Enabled"),
- Eq(defaultParams.enabled()));
+ Eq(defaultParams().enabled()));
EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "Interval"),
- Eq(defaultParams.interval().count()));
+ Eq(defaultParams().interval().count()));
EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistency"), Eq(true));
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "ReportActions"),
- Eq(utils::transform(defaultParams.reportActions(), [](const auto v) {
+ Eq(utils::transform(defaultParams().reportActions(), [](const auto v) {
return utils::enumToString(v);
})));
EXPECT_THAT(getProperty<bool>(sut->getPath(), "EmitsReadingsUpdate"),
- Eq(utils::contains(defaultParams.reportActions(),
+ Eq(utils::contains(defaultParams().reportActions(),
ReportAction::emitsReadingsUpdate)));
EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "AppendLimit"),
- Eq(defaultParams.appendLimit()));
+ Eq(defaultParams().appendLimit()));
EXPECT_THAT(getProperty<std::string>(sut->getPath(), "ReportingType"),
- Eq(utils::enumToString(defaultParams.reportingType())));
+ Eq(utils::enumToString(defaultParams().reportingType())));
EXPECT_THAT(getProperty<std::string>(sut->getPath(), "ReportUpdates"),
- Eq(utils::enumToString(defaultParams.reportUpdates())));
+ Eq(utils::enumToString(defaultParams().reportUpdates())));
EXPECT_THAT(
getProperty<bool>(sut->getPath(), "LogToMetricReportsCollection"),
- Eq(utils::contains(defaultParams.reportActions(),
+ Eq(utils::contains(defaultParams().reportActions(),
ReportAction::logToMetricReportsCollection)));
EXPECT_THAT(getProperty<ReadingParameters>(
sut->getPath(), "ReadingParametersFutureVersion"),
- Eq(toReadingParameters(defaultParams.metricParameters())));
+ Eq(toReadingParameters(defaultParams().metricParameters())));
EXPECT_THAT(getProperty<std::string>(sut->getPath(), "Name"),
- Eq(defaultParams.reportName()));
+ Eq(defaultParams().reportName()));
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
Eq(std::vector<std::string>()));
@@ -228,7 +241,7 @@
TEST_F(TestReport, setReportingTypeWithValidNewType)
{
std::string newType = "Periodic";
- std::string currType = utils::enumToString(defaultParams.reportingType());
+ std::string currType = utils::enumToString(defaultParams().reportingType());
EXPECT_THAT(newType, Ne(currType));
EXPECT_THAT(setProperty(sut->getPath(), "ReportingType", newType).value(),
@@ -240,7 +253,7 @@
TEST_F(TestReport, setReportingTypeWithInvalidType)
{
std::string newType = "Periodic_ABC";
- std::string prevType = utils::enumToString(defaultParams.reportingType());
+ std::string prevType = utils::enumToString(defaultParams().reportingType());
EXPECT_THAT(setProperty(sut->getPath(), "ReportingType", newType).value(),
Eq(boost::system::errc::invalid_argument));
@@ -252,7 +265,7 @@
{
std::vector<std::string> newActions = {"EmitsReadingsUpdate"};
std::vector<std::string> currActions =
- utils::transform(defaultParams.reportActions(),
+ utils::transform(defaultParams().reportActions(),
[](const auto v) { return utils::enumToString(v); });
EXPECT_THAT(newActions, Ne(currActions));
@@ -272,7 +285,7 @@
std::vector<std::string> expectedActions = {"EmitsReadingsUpdate",
"LogToMetricReportsCollection"};
std::vector<std::string> currActions =
- utils::transform(defaultParams.reportActions(),
+ utils::transform(defaultParams().reportActions(),
[](const auto v) { return utils::enumToString(v); });
EXPECT_THAT(newActions, Ne(currActions));
@@ -289,7 +302,7 @@
std::vector<std::string> newActions = {};
std::vector<std::string> expectedActions = {"LogToMetricReportsCollection"};
std::vector<std::string> currActions =
- utils::transform(defaultParams.reportActions(),
+ utils::transform(defaultParams().reportActions(),
[](const auto v) { return utils::enumToString(v); });
EXPECT_THAT(newActions, Ne(currActions));
@@ -309,7 +322,7 @@
Eq(boost::system::errc::invalid_argument));
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "ReportActions"),
- Eq(utils::transform(defaultParams.reportActions(), [](const auto v) {
+ Eq(utils::transform(defaultParams().reportActions(), [](const auto v) {
return utils::enumToString(v);
})));
}
@@ -344,7 +357,7 @@
TEST_F(TestReport, setEnabledWithNewValue)
{
- bool newValue = !defaultParams.enabled();
+ bool newValue = !defaultParams().enabled();
EXPECT_THAT(setProperty(sut->getPath(), "Enabled", newValue).value(),
Eq(boost::system::errc::success));
EXPECT_THAT(getProperty<bool>(sut->getPath(), "Enabled"), Eq(newValue));
@@ -352,7 +365,7 @@
TEST_F(TestReport, setIntervalWithValidValue)
{
- uint64_t newValue = defaultParams.interval().count() + 1;
+ uint64_t newValue = defaultParams().interval().count() + 1;
EXPECT_THAT(setProperty(sut->getPath(), "Interval", newValue).value(),
Eq(boost::system::errc::success));
EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "Interval"),
@@ -363,11 +376,11 @@
TestReport,
settingIntervalWithInvalidValueDoesNotChangePropertyAndReturnsInvalidArgument)
{
- uint64_t newValue = defaultParams.interval().count() - 1;
+ uint64_t newValue = defaultParams().interval().count() - 1;
EXPECT_THAT(setProperty(sut->getPath(), "Interval", newValue).value(),
Eq(boost::system::errc::invalid_argument));
EXPECT_THAT(getProperty<uint64_t>(sut->getPath(), "Interval"),
- Eq(defaultParams.interval().count()));
+ Eq(defaultParams().interval().count()));
}
TEST_F(TestReport, settingEmitsReadingsUpdateHaveNoEffect)
@@ -376,7 +389,7 @@
setProperty(sut->getPath(), "EmitsReadingsUpdate", true).value(),
Eq(boost::system::errc::read_only_file_system));
EXPECT_THAT(getProperty<bool>(sut->getPath(), "EmitsReadingsUpdate"),
- Eq(utils::contains(defaultParams.reportActions(),
+ Eq(utils::contains(defaultParams().reportActions(),
ReportAction::emitsReadingsUpdate)));
}
@@ -388,7 +401,7 @@
Eq(boost::system::errc::read_only_file_system));
EXPECT_THAT(
getProperty<bool>(sut->getPath(), "LogToMetricReportsCollection"),
- Eq(utils::contains(defaultParams.reportActions(),
+ Eq(utils::contains(defaultParams().reportActions(),
ReportAction::logToMetricReportsCollection)));
}
@@ -428,15 +441,15 @@
utils::Messanger messanger(DbusEnvironment::getIoc());
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Exist, "trigger2", {"someOtherReport"}});
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Exist,
"trigger3",
- {"someOtherReport", defaultParams.reportId()}});
+ {"someOtherReport", defaultParams().reportId()}});
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
@@ -448,18 +461,18 @@
utils::Messanger messanger(DbusEnvironment::getIoc());
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger2", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger2", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger3", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Removed, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Removed, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Removed, "trigger2", {}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Removed, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Removed, "trigger1", {defaultParams().reportId()}});
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
@@ -471,18 +484,18 @@
utils::Messanger messanger(DbusEnvironment::getIoc());
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger2", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger2", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger3", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger1", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger1", {defaultParams().reportId()}});
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Exist, "trigger2", {}});
messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, "trigger3", {defaultParams.reportId()}});
+ messages::Presence::Exist, "trigger3", {defaultParams().reportId()}});
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
@@ -502,49 +515,49 @@
INSTANTIATE_TEST_SUITE_P(
_, TestReportStore,
- Values(std::make_pair("Enabled"s, nlohmann::json(ReportParams().enabled())),
- std::make_pair("Version"s, nlohmann::json(6)),
- std::make_pair("Id"s, nlohmann::json(ReportParams().reportId())),
- std::make_pair("Name"s, nlohmann::json(ReportParams().reportName())),
- std::make_pair("ReportingType",
- nlohmann::json(ReportParams().reportingType())),
- std::make_pair("ReportActions", nlohmann::json(utils::transform(
- ReportParams().reportActions(),
- [](const auto v) {
- return utils::toUnderlying(
- v);
- }))),
- std::make_pair("Interval",
- nlohmann::json(ReportParams().interval().count())),
- std::make_pair("AppendLimit",
- nlohmann::json(ReportParams().appendLimit())),
- std::make_pair(
- "ReadingParameters",
- nlohmann::json(
- {{{tstring::SensorPath::str(),
- {{{tstring::Service::str(), "Service"},
- {tstring::Path::str(),
- "/xyz/openbmc_project/sensors/power/p1"},
- {tstring::Metadata::str(), "metadata1"}}}},
- {tstring::OperationType::str(), OperationType::avg},
- {tstring::Id::str(), "MetricId1"},
- {tstring::CollectionTimeScope::str(),
- CollectionTimeScope::point},
- {tstring::CollectionDuration::str(), 0}},
- {{tstring::SensorPath::str(),
- {{{tstring::Service::str(), "Service"},
- {tstring::Path::str(),
- "/xyz/openbmc_project/sensors/power/p2"},
- {tstring::Metadata::str(), "metadata2"}}}},
- {tstring::OperationType::str(), OperationType::avg},
- {tstring::Id::str(), "MetricId2"},
- {tstring::CollectionTimeScope::str(),
- CollectionTimeScope::point},
- {tstring::CollectionDuration::str(), 0}}}))));
+ Values(
+ std::make_pair("Enabled"s, nlohmann::json(defaultParams().enabled())),
+ std::make_pair("Version"s, nlohmann::json(6)),
+ std::make_pair("Id"s, nlohmann::json(defaultParams().reportId())),
+ std::make_pair("Name"s, nlohmann::json(defaultParams().reportName())),
+ std::make_pair("ReportingType",
+ nlohmann::json(defaultParams().reportingType())),
+ std::make_pair("ReportActions", nlohmann::json(utils::transform(
+ defaultParams().reportActions(),
+ [](const auto v) {
+ return utils::toUnderlying(v);
+ }))),
+ std::make_pair("Interval",
+ nlohmann::json(defaultParams().interval().count())),
+ std::make_pair("AppendLimit",
+ nlohmann::json(ReportParams().appendLimit())),
+ std::make_pair(
+ "ReadingParameters",
+ nlohmann::json(
+ {{{tstring::SensorPath::str(),
+ {{{tstring::Service::str(), "Service"},
+ {tstring::Path::str(),
+ "/xyz/openbmc_project/sensors/power/p1"},
+ {tstring::Metadata::str(), "metadata1"}}}},
+ {tstring::OperationType::str(), OperationType::avg},
+ {tstring::Id::str(), "MetricId1"},
+ {tstring::CollectionTimeScope::str(),
+ CollectionTimeScope::point},
+ {tstring::CollectionDuration::str(), 0}},
+ {{tstring::SensorPath::str(),
+ {{{tstring::Service::str(), "Service"},
+ {tstring::Path::str(),
+ "/xyz/openbmc_project/sensors/power/p2"},
+ {tstring::Metadata::str(), "metadata2"}}}},
+ {tstring::OperationType::str(), OperationType::avg},
+ {tstring::Id::str(), "MetricId2"},
+ {tstring::CollectionTimeScope::str(),
+ CollectionTimeScope::point},
+ {tstring::CollectionDuration::str(), 0}}}))));
TEST_P(TestReportStore, settingPersistencyToTrueStoresReport)
{
- sut = makeReport(ReportParams());
+ sut = makeReport(defaultParams());
{
InSequence seq;
@@ -565,10 +578,10 @@
TEST_P(TestReportStore, reportIsSavedToStorageAfterCreated)
{
- EXPECT_CALL(storageMock, store(to_file_path(ReportParams().reportId()), _))
+ EXPECT_CALL(storageMock, store(to_file_path(defaultParams().reportId()), _))
.WillOnce(SaveArg<1>(&storedConfiguration));
- sut = makeReport(ReportParams());
+ sut = makeReport(defaultParams());
const auto& [key, value] = GetParam();
@@ -586,9 +599,9 @@
INSTANTIATE_TEST_SUITE_P(
ValidNames, TestReportValidNames,
- Values(ReportParams().reportName("Valid_1"),
- ReportParams().reportName("Valid_1/Valid_2"),
- ReportParams().reportName("Valid_1/Valid_2/Valid_3")));
+ Values(defaultParams().reportName("Valid_1"),
+ defaultParams().reportName("Valid_1/Valid_2"),
+ defaultParams().reportName("Valid_1/Valid_2/Valid_3")));
TEST_P(TestReportValidNames, reportCtorDoesNotThrowOnValidName)
{
@@ -605,11 +618,11 @@
};
INSTANTIATE_TEST_SUITE_P(InvalidNames, TestReportInvalidIds,
- Values(ReportParams().reportId("/"),
- ReportParams().reportId("/Invalid"),
- ReportParams().reportId("Invalid/"),
- ReportParams().reportId("Invalid/Invalid/"),
- ReportParams().reportId("Invalid?")));
+ Values(defaultParams().reportId("/"),
+ defaultParams().reportId("/Invalid"),
+ defaultParams().reportId("Invalid/"),
+ defaultParams().reportId("Invalid/Invalid/"),
+ defaultParams().reportId("Invalid?")));
TEST_P(TestReportInvalidIds, failsToCreateReportWithInvalidName)
{
@@ -631,9 +644,9 @@
INSTANTIATE_TEST_SUITE_P(
_, TestReportAllReportTypes,
- Values(ReportParams().reportingType(ReportingType::onRequest),
- ReportParams().reportingType(ReportingType::onChange),
- ReportParams().reportingType(ReportingType::periodic)));
+ Values(defaultParams().reportingType(ReportingType::onRequest),
+ defaultParams().reportingType(ReportingType::onChange),
+ defaultParams().reportingType(ReportingType::periodic)));
TEST_P(TestReportAllReportTypes, returnPropertValueOfReportType)
{
@@ -681,7 +694,7 @@
void SetUp() override
{
sut =
- makeReport(ReportParams().reportingType(ReportingType::onRequest));
+ makeReport(defaultParams().reportingType(ReportingType::onRequest));
}
};
@@ -721,8 +734,8 @@
INSTANTIATE_TEST_SUITE_P(
_, TestReportNonOnRequestType,
- Values(ReportParams().reportingType(ReportingType::periodic),
- ReportParams().reportingType(ReportingType::onChange)));
+ Values(defaultParams().reportingType(ReportingType::periodic),
+ defaultParams().reportingType(ReportingType::onChange)));
TEST_P(TestReportNonOnRequestType, readingsAreNotUpdateOnUpdateCall)
{
@@ -745,8 +758,8 @@
INSTANTIATE_TEST_SUITE_P(
_, TestReportNonPeriodicReport,
- Values(ReportParams().reportingType(ReportingType::onRequest),
- ReportParams().reportingType(ReportingType::onChange)));
+ Values(defaultParams().reportingType(ReportingType::onRequest),
+ defaultParams().reportingType(ReportingType::onChange)));
TEST_P(TestReportNonPeriodicReport, readingsAreNotUpdatedAfterIntervalExpires)
{
@@ -760,7 +773,8 @@
{
void SetUp() override
{
- sut = makeReport(ReportParams().reportingType(ReportingType::periodic));
+ sut =
+ makeReport(defaultParams().reportingType(ReportingType::periodic));
}
};
@@ -810,7 +824,7 @@
_, TestReportWithReportUpdatesAndLimit,
Values(
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendWrapsWhenFull)
.appendLimit(5),
std::vector<ReadingData>{{std::make_tuple("aa"s, "bb"s, 42.0, 74u),
@@ -820,7 +834,7 @@
std::make_tuple("a"s, "b"s, 17.1, 114u)}},
true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendWrapsWhenFull)
.appendLimit(4),
std::vector<ReadingData>{
@@ -830,12 +844,12 @@
std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendWrapsWhenFull)
.appendLimit(0),
std::vector<ReadingData>{}, true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendStopsWhenFull)
.appendLimit(10),
std::vector<ReadingData>{
@@ -849,7 +863,7 @@
std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendStopsWhenFull)
.appendLimit(5),
std::vector<ReadingData>{{std::make_tuple("a"s, "b"s, 17.1, 114u),
@@ -859,7 +873,7 @@
std::make_tuple("a"s, "b"s, 17.1, 114u)}},
false},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendStopsWhenFull)
.appendLimit(4),
std::vector<ReadingData>{
@@ -869,12 +883,12 @@
std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
false},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::appendStopsWhenFull)
.appendLimit(0),
std::vector<ReadingData>{}, false},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::overwrite)
.appendLimit(500),
std::vector<ReadingData>{
@@ -882,7 +896,7 @@
std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::overwrite)
.appendLimit(1),
std::vector<ReadingData>{
@@ -890,7 +904,7 @@
std::make_tuple("aa"s, "bb"s, 42.0, 74u)}},
true},
ReportUpdatesReportParams{
- ReportParams()
+ defaultParams()
.reportUpdates(ReportUpdates::overwrite)
.appendLimit(0),
std::vector<ReadingData>{
@@ -918,7 +932,9 @@
{
public:
void SetUp() override
- {}
+ {
+ initMetricMocks(defaultParams().metricParameters());
+ }
void monitorProc(sdbusplus::message::message& msg)
{
@@ -955,25 +971,60 @@
};
TEST_F(TestReportInitialization,
- metricsAreInitializedWhenEnabledReportConstructed)
+ registersForMetricUpdatesWhenOnChangeReportCreated)
{
- initMetricMocks(defaultParams.metricParameters());
+ std::vector<const interfaces::MetricListener*> args;
for (auto& metric : metricMocks)
{
- EXPECT_CALL(*metric, initialize()).Times(1);
+ EXPECT_CALL(*metric, registerForUpdates(_))
+ .WillOnce(Invoke([&args](const interfaces::MetricListener& report) {
+ args.emplace_back(&report);
+ }));
+ ;
}
- sut = makeReport(defaultParams.enabled(true));
+
+ sut = makeReport(defaultParams().reportingType(ReportingType::onChange));
+
+ EXPECT_THAT(args, SizeIs(metricMocks.size()));
+ for (const auto* reportPtr : args)
+ {
+ EXPECT_THAT(reportPtr, Eq(sut.get()));
+ }
+}
+
+TEST_F(TestReportInitialization,
+ deregistersForMetricUpdatesWhenOnChangeReportDestroyed)
+{
+ sut = makeReport(defaultParams().reportingType(ReportingType::onChange));
+
+ for (auto& metric : metricMocks)
+ {
+ EXPECT_CALL(*metric,
+ unregisterFromUpdates(Ref(
+ static_cast<interfaces::MetricListener&>(*sut.get()))));
+ }
+
+ sut = nullptr;
+}
+
+TEST_F(TestReportInitialization,
+ metricsAreInitializedWhenEnabledReportConstructed)
+{
+ for (auto& metric : metricMocks)
+ {
+ EXPECT_CALL(*metric, initialize());
+ }
+ sut = makeReport(defaultParams().enabled(true));
}
TEST_F(TestReportInitialization,
metricsAreNotInitializedWhenDisabledReportConstructed)
{
- initMetricMocks(defaultParams.metricParameters());
for (auto& metric : metricMocks)
{
EXPECT_CALL(*metric, initialize()).Times(0);
}
- sut = makeReport(defaultParams.enabled(false));
+ sut = makeReport(defaultParams().enabled(false));
}
TEST_F(TestReportInitialization,
@@ -985,14 +1036,15 @@
const auto elapsed = DbusEnvironment::measureTime([this] {
sut =
- makeReport(defaultParams.reportingType(ReportingType::periodic)
+ makeReport(defaultParams()
+ .reportingType(ReportingType::periodic)
.reportActions({ReportAction::emitsReadingsUpdate}));
makeMonitor();
EXPECT_TRUE(DbusEnvironment::waitForFuture("readingsUpdated"));
});
- EXPECT_THAT(elapsed, AllOf(Ge(defaultParams.interval()),
- Lt(defaultParams.interval() * 2)));
+ EXPECT_THAT(elapsed, AllOf(Ge(defaultParams().interval()),
+ Lt(defaultParams().interval() * 2)));
}
TEST_F(TestReportInitialization,
@@ -1000,16 +1052,17 @@
{
EXPECT_CALL(readingsUpdated, Call()).Times(0);
- sut = makeReport(
- defaultParams.reportingType(ReportingType::periodic).reportActions({}));
+ sut = makeReport(defaultParams()
+ .reportingType(ReportingType::periodic)
+ .reportActions({}));
makeMonitor();
- DbusEnvironment::sleepFor(defaultParams.interval() * 2);
+ DbusEnvironment::sleepFor(defaultParams().interval() * 2);
}
TEST_F(TestReportInitialization, appendLimitDeducedProperly)
{
sut = makeReport(
- ReportParams().appendLimit(std::numeric_limits<uint64_t>::max()));
+ defaultParams().appendLimit(std::numeric_limits<uint64_t>::max()));
auto appendLimit = getProperty<uint64_t>(sut->getPath(), "AppendLimit");
EXPECT_EQ(appendLimit, 2ull);
}
@@ -1044,3 +1097,41 @@
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerIds"),
UnorderedElementsAre("trigger1", "trigger2"));
}
+
+class TestReportInitializationOnChangeReport : public TestReportInitialization
+{
+ public:
+ void SetUp() override
+ {
+ initMetricMocks(params.metricParameters());
+ }
+
+ ReportParams params = defaultOnChangeParams();
+};
+
+TEST_F(TestReportInitializationOnChangeReport,
+ doesntUpdateReadingsWhenNotRequired)
+{
+ EXPECT_CALL(*metricMocks[0], updateReadings(_)).Times(0);
+
+ ON_CALL(*metricMocks[0], isTimerRequired()).WillByDefault(Return(false));
+
+ sut = makeReport(params);
+
+ DbusEnvironment::sleepFor(500ms);
+}
+
+TEST_F(TestReportInitializationOnChangeReport, updatesReadingsWhenRequired)
+{
+ EXPECT_CALL(*metricMocks[0], updateReadings(_))
+ .WillOnce(Return())
+ .WillOnce(
+ InvokeWithoutArgs(DbusEnvironment::setPromise("readingsUpdated")))
+ .WillRepeatedly(Return());
+
+ ON_CALL(*metricMocks[0], isTimerRequired()).WillByDefault(Return(true));
+
+ sut = makeReport(params);
+
+ DbusEnvironment::waitForFuture("readingsUpdated");
+}
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index f4ce184..55b5a3c 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -121,6 +121,19 @@
EXPECT_THAT(path, Eq(reportMock.getPath()));
}
+TEST_F(TestReportManager, addOnChangeReport)
+{
+ EXPECT_CALL(reportFactoryMock, convertMetricParams(_, _));
+ reportFactoryMock
+ .expectMake(reportParams.reportingType(ReportingType::onChange),
+ Ref(*sut), Ref(storageMock))
+ .WillOnce(Return(ByMove(std::move(reportMockPtr))));
+
+ auto [ec, path] = addReport(reportParams);
+ EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
+ EXPECT_THAT(path, Eq(reportMock.getPath()));
+}
+
TEST_F(TestReportManager, nameIsUsedToGenerateIdWhenIdIsEmptyInAddReport)
{
reportParams.reportId("ReportName");
diff --git a/tests/src/test_sensor.cpp b/tests/src/test_sensor.cpp
index c073ee7..8738bde 100644
--- a/tests/src/test_sensor.cpp
+++ b/tests/src/test_sensor.cpp
@@ -147,12 +147,9 @@
ASSERT_TRUE(DbusEnvironment::waitForFuture("notify"));
}
-TEST_F(TestSensorNotification, notifiesListenerWithValueWhenNoChangeOccurs)
+TEST_F(TestSensorNotification, doesntNotifyListenerWhenNoChangeOccurs)
{
- InSequence seq;
-
- EXPECT_CALL(*listenerMock, sensorUpdated(Ref(*sut), Ge(timestamp), 42.7));
- EXPECT_CALL(*listenerMock, sensorUpdated(Ref(*sut), Ge(timestamp)))
+ EXPECT_CALL(*listenerMock, sensorUpdated(Ref(*sut), Ge(timestamp), 42.7))
.WillOnce(InvokeWithoutArgs(DbusEnvironment::setPromise("notify")));
sensorObject->setValue(42.7);