blob: 9989e0dc06b89de5983fd2ae752a97f9ab580b9a [file] [log] [blame]
James Feist75eb7692019-02-25 12:50:02 -08001#include "conf.hpp"
Patrick Venture0ef1faf2018-06-13 12:50:53 -07002#include "dbus/dbuspassive.hpp"
James Zheng6df8bb52024-11-27 23:38:47 +00003#include "failsafeloggers/builder.hpp"
4#include "failsafeloggers/failsafe_logger.hpp"
5#include "failsafeloggers/failsafe_logger_utility.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -07006#include "test/dbushelper_mock.hpp"
Patrick Venture0ef1faf2018-06-13 12:50:53 -07007
Patrick Venture0ef1faf2018-06-13 12:50:53 -07008#include <sdbusplus/test/sdbus_mock.hpp>
Patrick Venturea83a3ec2020-08-04 09:52:05 -07009
10#include <functional>
Patrick Venture8729eb92020-08-10 10:38:44 -070011#include <memory>
Patrick Venture0ef1faf2018-06-13 12:50:53 -070012#include <string>
James Feist1f802f52019-02-08 13:51:43 -080013#include <variant>
Patrick Venture0ef1faf2018-06-13 12:50:53 -070014
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070015#include <gmock/gmock.h>
16#include <gtest/gtest.h>
Patrick Venture0ef1faf2018-06-13 12:50:53 -070017
Patrick Venturea0764872020-08-08 07:48:43 -070018namespace pid_control
19{
20namespace
21{
22
Patrick Venture0ef1faf2018-06-13 12:50:53 -070023using ::testing::Invoke;
24using ::testing::IsNull;
25using ::testing::NotNull;
26using ::testing::Return;
27using ::testing::StrEq;
Patrick Venture0ef1faf2018-06-13 12:50:53 -070028
29std::string SensorIntf = "xyz.openbmc_project.Sensor.Value";
30
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070031TEST(DbusPassiveTest, FactoryFailsWithInvalidType)
32{
Patrick Venture0ef1faf2018-06-13 12:50:53 -070033 // Verify the type is checked by the factory.
34
35 sdbusplus::SdBusMock sdbus_mock;
36 auto bus_mock = sdbusplus::get_mocked_new(&sdbus_mock);
37 std::string type = "invalid";
38 std::string id = "id";
39
Patrick Venture8729eb92020-08-10 10:38:44 -070040 auto helper = std::make_unique<DbusHelperMock>();
James Feistf81f2882019-02-26 11:26:36 -080041 auto info = conf::SensorConfig();
Patrick Venture0ef1faf2018-06-13 12:50:53 -070042
James Feist98b704e2019-06-03 16:24:53 -070043 std::unique_ptr<ReadInterface> ri = DbusPassive::createDbusPassive(
Patrick Venture8729eb92020-08-10 10:38:44 -070044 bus_mock, type, id, std::move(helper), &info, nullptr);
Patrick Venture0ef1faf2018-06-13 12:50:53 -070045
46 EXPECT_EQ(ri, nullptr);
47}
48
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070049TEST(DbusPassiveTest, BoringConstructorTest)
50{
Patrick Venturef8cb4642018-10-30 12:02:53 -070051 // Simply build the object, does no error checking.
Patrick Venture0ef1faf2018-06-13 12:50:53 -070052
53 sdbusplus::SdBusMock sdbus_mock;
54 auto bus_mock = sdbusplus::get_mocked_new(&sdbus_mock);
55 std::string type = "invalid";
56 std::string id = "id";
57 std::string path = "/xyz/openbmc_project/sensors/unknown/id";
58
Patrick Venture8729eb92020-08-10 10:38:44 -070059 auto helper = std::make_unique<DbusHelperMock>();
Patrick Venture1df9e872020-10-08 15:35:01 -070060 SensorProperties properties;
Patrick Venture0ef1faf2018-06-13 12:50:53 -070061
Patrick Venture8729eb92020-08-10 10:38:44 -070062 DbusPassive(bus_mock, type, id, std::move(helper), properties, false, path,
63 nullptr);
Patrick Venture0ef1faf2018-06-13 12:50:53 -070064 // Success
65}
66
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070067class DbusPassiveTestObj : public ::testing::Test
68{
69 protected:
70 DbusPassiveTestObj() :
Jayanth Othayoth2922eeb2024-12-08 07:47:37 -060071 sdbus_mock(), bus_mock(sdbusplus::get_mocked_new(&sdbus_mock)),
Patrick Venture8729eb92020-08-10 10:38:44 -070072 helper(std::make_unique<DbusHelperMock>())
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070073 {
Patrick Venture9b936922020-08-10 11:28:39 -070074 EXPECT_CALL(*helper, getService(StrEq(SensorIntf), StrEq(path)))
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070075 .WillOnce(Return("asdf"));
Patrick Venture0ef1faf2018-06-13 12:50:53 -070076
Patrick Venture8729eb92020-08-10 10:38:44 -070077 EXPECT_CALL(*helper,
Patrick Venture9b936922020-08-10 11:28:39 -070078 getProperties(StrEq("asdf"), StrEq(path), NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +080079 .WillOnce(Invoke([&]([[maybe_unused]] const std::string& service,
80 [[maybe_unused]] const std::string& path,
81 SensorProperties* prop) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -040082 prop->scale = _scale;
83 prop->value = _value;
84 prop->unit = "x";
85 prop->min = 0;
86 prop->max = 0;
87 prop->available = true;
88 }));
Patrick Venture9b936922020-08-10 11:28:39 -070089 EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
James Feist36b7d8e2018-10-05 15:39:01 -070090 .WillOnce(Return(false));
Patrick Venture0ef1faf2018-06-13 12:50:53 -070091
James Feistf81f2882019-02-26 11:26:36 -080092 auto info = conf::SensorConfig();
Alex.Song8f73ad72021-10-07 00:18:27 +080093 info.unavailableAsFailed = true;
Patrick Venture8729eb92020-08-10 10:38:44 -070094 ri = DbusPassive::createDbusPassive(bus_mock, type, id,
95 std::move(helper), &info, nullptr);
Patrick Venturee2ec0f62018-09-04 12:30:27 -070096 passive = reinterpret_cast<DbusPassive*>(ri.get());
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070097 EXPECT_FALSE(passive == nullptr);
98 }
Patrick Venture0ef1faf2018-06-13 12:50:53 -070099
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700100 sdbusplus::SdBusMock sdbus_mock;
Patrick Williamsb228bc32022-07-22 19:26:56 -0500101 sdbusplus::bus_t bus_mock;
Patrick Venture8729eb92020-08-10 10:38:44 -0700102 std::unique_ptr<DbusHelperMock> helper;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700103 std::string type = "temp";
104 std::string id = "id";
105 std::string path = "/xyz/openbmc_project/sensors/temperature/id";
106 int64_t _scale = -3;
107 int64_t _value = 10;
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700108
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700109 std::unique_ptr<ReadInterface> ri;
Patrick Venturee2ec0f62018-09-04 12:30:27 -0700110 DbusPassive* passive;
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700111};
112
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700113TEST_F(DbusPassiveTestObj, ReadReturnsExpectedValues)
114{
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700115 // Verify read is returning the values.
116 ReadReturn v;
117 v.value = 0.01;
118 // TODO: updated is set when the value is created, so we can range check
119 // it.
120 ReadReturn r = passive->read();
121 EXPECT_EQ(v.value, r.value);
122}
123
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700124TEST_F(DbusPassiveTestObj, SetValueUpdatesValue)
125{
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700126 // Verify setvalue does as advertised.
127
128 double value = 0.01;
129 passive->setValue(value);
130
131 // TODO: updated is set when the value is set, so we can range check it.
132 ReadReturn r = passive->read();
133 EXPECT_EQ(value, r.value);
134}
135
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700136TEST_F(DbusPassiveTestObj, GetScaleReturnsExpectedValue)
137{
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700138 // Verify the scale is returned as expected.
139 EXPECT_EQ(_scale, passive->getScale());
140}
141
Patrick Venture563a3562018-10-30 09:31:26 -0700142TEST_F(DbusPassiveTestObj, getIDReturnsExpectedValue)
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700143{
Patrick Venture563a3562018-10-30 09:31:26 -0700144 // Verify getID returns the expected value.
145 EXPECT_EQ(id, passive->getID());
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700146}
147
Patrick Venture6b9f5992019-09-10 09:18:28 -0700148TEST_F(DbusPassiveTestObj, GetMinValueReturnsExpectedValue)
149{
150 EXPECT_DOUBLE_EQ(0, passive->getMin());
151}
152
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700153TEST_F(DbusPassiveTestObj, VerifyHandlesDbusSignal)
154{
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700155 // The dbus passive sensor listens for updates and if it's the Value
156 // property, it needs to handle it.
157
158 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
159 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500160 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700161
Patrick Venturee2ec0f62018-09-04 12:30:27 -0700162 const char* Value = "Value";
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700163 int64_t xValue = 10000;
Patrick Venturee2ec0f62018-09-04 12:30:27 -0700164 const char* intf = "xyz.openbmc_project.Sensor.Value";
James Feist1f802f52019-02-08 13:51:43 -0800165 // string, std::map<std::string, std::variant<int64_t>>
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700166 // msg.read(msgSensor, msgData);
167
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700168 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800169 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
170 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400171 const char** s = static_cast<const char**>(p);
172 // Read the first parameter, the string.
173 *s = intf;
174 return 0;
175 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800176 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
177 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400178 const char** s = static_cast<const char**>(p);
179 *s = Value;
180 // Read the string in the pair (dictionary).
181 return 0;
182 }));
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700183
184 // std::map
185 EXPECT_CALL(sdbus_mock,
186 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
187 .WillOnce(Return(0));
188
189 // while !at_end()
190 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
191 .WillOnce(Return(0))
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700192 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700193
194 // std::pair
195 EXPECT_CALL(sdbus_mock,
196 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
197 .WillOnce(Return(0));
198
199 EXPECT_CALL(sdbus_mock,
200 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
201 .WillOnce(Return(1));
202 EXPECT_CALL(sdbus_mock,
203 sd_bus_message_enter_container(IsNull(), 'v', StrEq("x")))
204 .WillOnce(Return(0));
205
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700206 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800207 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
208 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400209 int64_t* s = static_cast<int64_t*>(p);
210 *s = xValue;
211 return 0;
212 }));
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700213
214 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
215 .WillOnce(Return(0)) /* variant. */
216 .WillOnce(Return(0)) /* std::pair */
217 .WillOnce(Return(0)); /* std::map */
218
Patrick Venture7af157b2018-10-30 11:24:40 -0700219 int rv = handleSensorValue(msg, passive);
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700220 EXPECT_EQ(rv, 0); // It's always 0.
221
222 ReadReturn r = passive->read();
223 EXPECT_EQ(10, r.value);
224}
225
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700226TEST_F(DbusPassiveTestObj, VerifyIgnoresOtherPropertySignal)
227{
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700228 // The dbus passive sensor listens for updates and if it's the Value
229 // property, it needs to handle it. In this case, it won't be.
230
231 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
232 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500233 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700234
Patrick Venturee2ec0f62018-09-04 12:30:27 -0700235 const char* Scale = "Scale";
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700236 int64_t xScale = -6;
Patrick Venturee2ec0f62018-09-04 12:30:27 -0700237 const char* intf = "xyz.openbmc_project.Sensor.Value";
James Feist1f802f52019-02-08 13:51:43 -0800238 // string, std::map<std::string, std::variant<int64_t>>
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700239 // msg.read(msgSensor, msgData);
240
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700241 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800242 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
243 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400244 const char** s = static_cast<const char**>(p);
245 // Read the first parameter, the string.
246 *s = intf;
247 return 0;
248 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800249 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
250 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400251 const char** s = static_cast<const char**>(p);
252 *s = Scale;
253 // Read the string in the pair (dictionary).
254 return 0;
255 }));
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700256
257 // std::map
258 EXPECT_CALL(sdbus_mock,
259 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
260 .WillOnce(Return(0));
261
262 // while !at_end()
263 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
264 .WillOnce(Return(0))
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700265 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700266
267 // std::pair
268 EXPECT_CALL(sdbus_mock,
269 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
270 .WillOnce(Return(0));
271
272 EXPECT_CALL(sdbus_mock,
273 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
274 .WillOnce(Return(1));
275 EXPECT_CALL(sdbus_mock,
276 sd_bus_message_enter_container(IsNull(), 'v', StrEq("x")))
277 .WillOnce(Return(0));
278
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700279 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800280 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
281 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400282 int64_t* s = static_cast<int64_t*>(p);
283 *s = xScale;
284 return 0;
285 }));
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700286
287 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
288 .WillOnce(Return(0)) /* variant. */
289 .WillOnce(Return(0)) /* std::pair */
290 .WillOnce(Return(0)); /* std::map */
291
Patrick Venture7af157b2018-10-30 11:24:40 -0700292 int rv = handleSensorValue(msg, passive);
Patrick Venture0ef1faf2018-06-13 12:50:53 -0700293 EXPECT_EQ(rv, 0); // It's always 0.
294
295 ReadReturn r = passive->read();
296 EXPECT_EQ(0.01, r.value);
297}
Alex.Song8f73ad72021-10-07 00:18:27 +0800298
James Feist36b7d8e2018-10-05 15:39:01 -0700299TEST_F(DbusPassiveTestObj, VerifyCriticalThresholdAssert)
300{
James Feist36b7d8e2018-10-05 15:39:01 -0700301 // Verifies when a threshold is crossed the sensor goes into error state
302 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
303 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500304 sdbusplus::message_t msg(nullptr, &sdbus_mock);
James Feist36b7d8e2018-10-05 15:39:01 -0700305
306 const char* criticalAlarm = "CriticalAlarmHigh";
307 bool alarm = true;
308 const char* intf = "xyz.openbmc_project.Sensor.Threshold.Critical";
309
310 passive->setFailed(false);
311
312 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800313 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
314 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400315 const char** s = static_cast<const char**>(p);
316 // Read the first parameter, the string.
317 *s = intf;
318 return 0;
319 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800320 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
321 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400322 const char** s = static_cast<const char**>(p);
323 *s = criticalAlarm;
324 // Read the string in the pair (dictionary).
325 return 0;
326 }));
James Feist36b7d8e2018-10-05 15:39:01 -0700327
328 // std::map
329 EXPECT_CALL(sdbus_mock,
330 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
331 .WillOnce(Return(0));
332
333 // while !at_end()
334 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
335 .WillOnce(Return(0))
336 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
337
338 // std::pair
339 EXPECT_CALL(sdbus_mock,
340 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
341 .WillOnce(Return(0));
342
343 EXPECT_CALL(sdbus_mock,
344 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
345 .WillOnce(Return(0));
346 EXPECT_CALL(sdbus_mock,
347 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
348 .WillOnce(Return(0));
349 EXPECT_CALL(sdbus_mock,
350 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
351 .WillOnce(Return(1));
352 EXPECT_CALL(sdbus_mock,
353 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
354 .WillOnce(Return(0));
355
356 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800357 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
358 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400359 bool* s = static_cast<bool*>(p);
360 *s = alarm;
361 return 0;
362 }));
James Feist36b7d8e2018-10-05 15:39:01 -0700363
364 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
365 .WillOnce(Return(0)) /* variant. */
366 .WillOnce(Return(0)) /* std::pair */
367 .WillOnce(Return(0)); /* std::map */
368
Patrick Venture7af157b2018-10-30 11:24:40 -0700369 int rv = handleSensorValue(msg, passive);
James Feist36b7d8e2018-10-05 15:39:01 -0700370 EXPECT_EQ(rv, 0); // It's always 0.
371 bool failed = passive->getFailed();
372 EXPECT_EQ(failed, true);
373}
374
375TEST_F(DbusPassiveTestObj, VerifyCriticalThresholdDeassert)
376{
James Feist36b7d8e2018-10-05 15:39:01 -0700377 // Verifies when a threshold is deasserted a failed sensor goes back into
378 // the normal state
379 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
380 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500381 sdbusplus::message_t msg(nullptr, &sdbus_mock);
James Feist36b7d8e2018-10-05 15:39:01 -0700382
383 const char* criticalAlarm = "CriticalAlarmHigh";
384 bool alarm = false;
385 const char* intf = "xyz.openbmc_project.Sensor.Threshold.Critical";
386
387 passive->setFailed(true);
388
389 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800390 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
391 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400392 const char** s = static_cast<const char**>(p);
393 // Read the first parameter, the string.
394 *s = intf;
395 return 0;
396 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800397 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
398 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400399 const char** s = static_cast<const char**>(p);
400 *s = criticalAlarm;
401 // Read the string in the pair (dictionary).
402 return 0;
403 }));
James Feist36b7d8e2018-10-05 15:39:01 -0700404
405 // std::map
406 EXPECT_CALL(sdbus_mock,
407 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
408 .WillOnce(Return(0));
409
410 // while !at_end()
411 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
412 .WillOnce(Return(0))
413 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
414
415 // std::pair
416 EXPECT_CALL(sdbus_mock,
417 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
418 .WillOnce(Return(0));
419
420 EXPECT_CALL(sdbus_mock,
421 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
422 .WillOnce(Return(0));
423 EXPECT_CALL(sdbus_mock,
424 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
425 .WillOnce(Return(0));
426 EXPECT_CALL(sdbus_mock,
427 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
428 .WillOnce(Return(1));
429 EXPECT_CALL(sdbus_mock,
430 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
431 .WillOnce(Return(0));
432
433 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800434 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
435 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400436 bool* s = static_cast<bool*>(p);
437 *s = alarm;
438 return 0;
439 }));
James Feist36b7d8e2018-10-05 15:39:01 -0700440
441 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
442 .WillOnce(Return(0)) /* variant. */
443 .WillOnce(Return(0)) /* std::pair */
444 .WillOnce(Return(0)); /* std::map */
445
Patrick Venture7af157b2018-10-30 11:24:40 -0700446 int rv = handleSensorValue(msg, passive);
James Feist36b7d8e2018-10-05 15:39:01 -0700447 EXPECT_EQ(rv, 0); // It's always 0.
448 bool failed = passive->getFailed();
449 EXPECT_EQ(failed, false);
Patrick Venture563a3562018-10-30 09:31:26 -0700450}
Patrick Venture6b9f5992019-09-10 09:18:28 -0700451
Alex.Song8f73ad72021-10-07 00:18:27 +0800452TEST_F(DbusPassiveTestObj, VerifyAvailableDeassert)
453{
Manojkiran Eda7ca88872024-06-17 11:55:48 +0530454 // Verifies when Available is deasserted && unavailableAsFailed == true,
Alex.Song8f73ad72021-10-07 00:18:27 +0800455 // the sensor goes into error state
456 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
457 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500458 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Alex.Song8f73ad72021-10-07 00:18:27 +0800459
460 const char* property = "Available";
461 bool asserted = false;
462 const char* intf = "xyz.openbmc_project.State.Decorator.Availability";
463
464 passive->setAvailable(true);
465
466 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800467 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
468 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400469 const char** s = static_cast<const char**>(p);
470 // Read the first parameter, the string.
471 *s = intf;
472 return 0;
473 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800474 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
475 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400476 const char** s = static_cast<const char**>(p);
477 *s = property;
478 // Read the string in the pair (dictionary).
479 return 0;
480 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800481
482 // std::map
483 EXPECT_CALL(sdbus_mock,
484 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
485 .WillOnce(Return(0));
486
487 // while !at_end()
488 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
489 .WillOnce(Return(0))
490 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
491
492 // std::pair
493 EXPECT_CALL(sdbus_mock,
494 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
495 .WillOnce(Return(0));
496
497 EXPECT_CALL(sdbus_mock,
498 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
499 .WillOnce(Return(0));
500 EXPECT_CALL(sdbus_mock,
501 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
502 .WillOnce(Return(0));
503 EXPECT_CALL(sdbus_mock,
504 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
505 .WillOnce(Return(1));
506 EXPECT_CALL(sdbus_mock,
507 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
508 .WillOnce(Return(0));
509
510 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800511 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
512 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400513 bool* s = static_cast<bool*>(p);
514 *s = asserted;
515 return 0;
516 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800517
518 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
519 .WillOnce(Return(0)) /* variant. */
520 .WillOnce(Return(0)) /* std::pair */
521 .WillOnce(Return(0)); /* std::map */
522
523 int rv = handleSensorValue(msg, passive);
524 EXPECT_EQ(rv, 0); // It's always 0.
525 bool failed = passive->getFailed();
526 EXPECT_EQ(failed, true);
527}
528
529TEST_F(DbusPassiveTestObj, VerifyAvailableAssert)
530{
Manojkiran Eda7ca88872024-06-17 11:55:48 +0530531 // Verifies when Available is asserted && unavailableAsFailed == true,
Alex.Song8f73ad72021-10-07 00:18:27 +0800532 // an error sensor goes back to normal state
533 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
534 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500535 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Alex.Song8f73ad72021-10-07 00:18:27 +0800536
537 const char* property = "Available";
538 bool asserted = true;
539 const char* intf = "xyz.openbmc_project.State.Decorator.Availability";
540
541 passive->setAvailable(false);
542 bool failed = passive->getFailed();
543 EXPECT_EQ(failed, true);
544
545 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800546 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
547 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400548 const char** s = static_cast<const char**>(p);
549 // Read the first parameter, the string.
550 *s = intf;
551 return 0;
552 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800553 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
554 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400555 const char** s = static_cast<const char**>(p);
556 *s = property;
557 // Read the string in the pair (dictionary).
558 return 0;
559 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800560
561 // std::map
562 EXPECT_CALL(sdbus_mock,
563 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
564 .WillOnce(Return(0));
565
566 // while !at_end()
567 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
568 .WillOnce(Return(0))
569 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
570
571 // std::pair
572 EXPECT_CALL(sdbus_mock,
573 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
574 .WillOnce(Return(0));
575
576 EXPECT_CALL(sdbus_mock,
577 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
578 .WillOnce(Return(0));
579 EXPECT_CALL(sdbus_mock,
580 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
581 .WillOnce(Return(0));
582 EXPECT_CALL(sdbus_mock,
583 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
584 .WillOnce(Return(1));
585 EXPECT_CALL(sdbus_mock,
586 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
587 .WillOnce(Return(0));
588
589 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800590 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
591 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400592 bool* s = static_cast<bool*>(p);
593 *s = asserted;
594 return 0;
595 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800596
597 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
598 .WillOnce(Return(0)) /* variant. */
599 .WillOnce(Return(0)) /* std::pair */
600 .WillOnce(Return(0)); /* std::map */
601
602 int rv = handleSensorValue(msg, passive);
603 EXPECT_EQ(rv, 0); // It's always 0.
604 failed = passive->getFailed();
605 EXPECT_EQ(failed, false);
606}
607
608class DbusPassiveTestUnaSensorNotAsFailedObj : public ::testing::Test
609{
610 protected:
611 DbusPassiveTestUnaSensorNotAsFailedObj() :
Jayanth Othayoth2922eeb2024-12-08 07:47:37 -0600612 sdbus_mock(), bus_mock(sdbusplus::get_mocked_new(&sdbus_mock)),
Alex.Song8f73ad72021-10-07 00:18:27 +0800613 helper(std::make_unique<DbusHelperMock>())
614 {
615 EXPECT_CALL(*helper, getService(StrEq(SensorIntf), StrEq(path)))
616 .WillOnce(Return("asdf"));
617
618 EXPECT_CALL(*helper,
619 getProperties(StrEq("asdf"), StrEq(path), NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800620 .WillOnce(Invoke([&]([[maybe_unused]] const std::string& service,
621 [[maybe_unused]] const std::string& path,
622 SensorProperties* prop) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400623 prop->scale = _scale;
624 prop->value = _value;
625 prop->unit = "x";
626 prop->min = 0;
627 prop->max = 0;
628 prop->available = true;
629 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800630 EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
631 .WillOnce(Return(false));
632
633 auto info = conf::SensorConfig();
634 info.unavailableAsFailed = false;
635 ri = DbusPassive::createDbusPassive(bus_mock, type, id,
636 std::move(helper), &info, nullptr);
637 passive = reinterpret_cast<DbusPassive*>(ri.get());
638 EXPECT_FALSE(passive == nullptr);
639 }
640
641 sdbusplus::SdBusMock sdbus_mock;
Patrick Williamsb228bc32022-07-22 19:26:56 -0500642 sdbusplus::bus_t bus_mock;
Alex.Song8f73ad72021-10-07 00:18:27 +0800643 std::unique_ptr<DbusHelperMock> helper;
644 std::string type = "temp";
645 std::string id = "id";
646 std::string path = "/xyz/openbmc_project/sensors/temperature/id";
647 int64_t _scale = -3;
648 int64_t _value = 10;
649
650 std::unique_ptr<ReadInterface> ri;
651 DbusPassive* passive;
652};
653
654TEST_F(DbusPassiveTestUnaSensorNotAsFailedObj, VerifyAvailableDeassert)
655{
Manojkiran Eda7ca88872024-06-17 11:55:48 +0530656 // Verifies when Available is deasserted && unavailableAsFailed == false,
Alex.Song8f73ad72021-10-07 00:18:27 +0800657 // the sensor remains at OK state but reading goes to NaN.
658 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
659 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500660 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Alex.Song8f73ad72021-10-07 00:18:27 +0800661
662 const char* property = "Available";
663 bool asserted = false;
664 const char* intf = "xyz.openbmc_project.State.Decorator.Availability";
665
666 passive->setAvailable(true);
667
668 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800669 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
670 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400671 const char** s = static_cast<const char**>(p);
672 // Read the first parameter, the string.
673 *s = intf;
674 return 0;
675 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800676 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
677 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400678 const char** s = static_cast<const char**>(p);
679 *s = property;
680 // Read the string in the pair (dictionary).
681 return 0;
682 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800683
684 // std::map
685 EXPECT_CALL(sdbus_mock,
686 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
687 .WillOnce(Return(0));
688
689 // while !at_end()
690 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
691 .WillOnce(Return(0))
692 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
693
694 // std::pair
695 EXPECT_CALL(sdbus_mock,
696 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
697 .WillOnce(Return(0));
698
699 EXPECT_CALL(sdbus_mock,
700 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
701 .WillOnce(Return(0));
702 EXPECT_CALL(sdbus_mock,
703 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
704 .WillOnce(Return(0));
705 EXPECT_CALL(sdbus_mock,
706 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
707 .WillOnce(Return(1));
708 EXPECT_CALL(sdbus_mock,
709 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
710 .WillOnce(Return(0));
711
712 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800713 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
714 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400715 bool* s = static_cast<bool*>(p);
716 *s = asserted;
717 return 0;
718 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800719
720 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
721 .WillOnce(Return(0)) /* variant. */
722 .WillOnce(Return(0)) /* std::pair */
723 .WillOnce(Return(0)); /* std::map */
724
725 int rv = handleSensorValue(msg, passive);
726 EXPECT_EQ(rv, 0); // It's always 0.
727 bool failed = passive->getFailed();
728 EXPECT_EQ(failed, false);
729 ReadReturn r = passive->read();
730 EXPECT_FALSE(std::isfinite(r.value));
731}
732
733TEST_F(DbusPassiveTestUnaSensorNotAsFailedObj, VerifyAvailableAssert)
734{
Manojkiran Eda7ca88872024-06-17 11:55:48 +0530735 // Verifies when a sensor's state goes from unavailable to available
Alex.Song8f73ad72021-10-07 00:18:27 +0800736 // && unavailableAsFailed == false, this sensor remains at OK state.
737 EXPECT_CALL(sdbus_mock, sd_bus_message_ref(IsNull()))
738 .WillOnce(Return(nullptr));
Patrick Williamsb228bc32022-07-22 19:26:56 -0500739 sdbusplus::message_t msg(nullptr, &sdbus_mock);
Alex.Song8f73ad72021-10-07 00:18:27 +0800740
741 const char* property = "Available";
742 bool asserted = true;
743 const char* intf = "xyz.openbmc_project.State.Decorator.Availability";
744
745 passive->setAvailable(false);
746 bool failed = passive->getFailed();
747 EXPECT_EQ(failed, false);
748
749 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800750 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
751 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400752 const char** s = static_cast<const char**>(p);
753 // Read the first parameter, the string.
754 *s = intf;
755 return 0;
756 }))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800757 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
758 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400759 const char** s = static_cast<const char**>(p);
760 *s = property;
761 // Read the string in the pair (dictionary).
762 return 0;
763 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800764
765 // std::map
766 EXPECT_CALL(sdbus_mock,
767 sd_bus_message_enter_container(IsNull(), 'a', StrEq("{sv}")))
768 .WillOnce(Return(0));
769
770 // while !at_end()
771 EXPECT_CALL(sdbus_mock, sd_bus_message_at_end(IsNull(), 0))
772 .WillOnce(Return(0))
773 .WillOnce(Return(1)); // So it exits the loop after reading one pair.
774
775 // std::pair
776 EXPECT_CALL(sdbus_mock,
777 sd_bus_message_enter_container(IsNull(), 'e', StrEq("sv")))
778 .WillOnce(Return(0));
779
780 EXPECT_CALL(sdbus_mock,
781 sd_bus_message_verify_type(IsNull(), 'v', StrEq("x")))
782 .WillOnce(Return(0));
783 EXPECT_CALL(sdbus_mock,
784 sd_bus_message_verify_type(IsNull(), 'v', StrEq("d")))
785 .WillOnce(Return(0));
786 EXPECT_CALL(sdbus_mock,
787 sd_bus_message_verify_type(IsNull(), 'v', StrEq("b")))
788 .WillOnce(Return(1));
789 EXPECT_CALL(sdbus_mock,
790 sd_bus_message_enter_container(IsNull(), 'v', StrEq("b")))
791 .WillOnce(Return(0));
792
793 EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800794 .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
795 [[maybe_unused]] char type, void* p) {
Patrick Williamsbd63bca2024-08-16 15:21:10 -0400796 bool* s = static_cast<bool*>(p);
797 *s = asserted;
798 return 0;
799 }));
Alex.Song8f73ad72021-10-07 00:18:27 +0800800
801 EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
802 .WillOnce(Return(0)) /* variant. */
803 .WillOnce(Return(0)) /* std::pair */
804 .WillOnce(Return(0)); /* std::map */
805
806 int rv = handleSensorValue(msg, passive);
807 EXPECT_EQ(rv, 0); // It's always 0.
808 failed = passive->getFailed();
809 EXPECT_EQ(failed, false);
810}
811
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800812void GetPropertiesMax3k([[maybe_unused]] const std::string& service,
813 [[maybe_unused]] const std::string& path,
Patrick Venture9b936922020-08-10 11:28:39 -0700814 SensorProperties* prop)
Patrick Venture6b9f5992019-09-10 09:18:28 -0700815{
816 prop->scale = -3;
817 prop->value = 10;
818 prop->unit = "x";
819 prop->min = 0;
820 prop->max = 3000;
821}
822
Patrick Venture9b936922020-08-10 11:28:39 -0700823using GetPropertiesFunction = std::function<void(
824 const std::string&, const std::string&, SensorProperties*)>;
Patrick Venture6b9f5992019-09-10 09:18:28 -0700825
826// TODO: There is definitely a cleaner way to do this.
827class DbusPassiveTest3kMaxObj : public ::testing::Test
828{
829 protected:
830 DbusPassiveTest3kMaxObj() :
Jayanth Othayoth2922eeb2024-12-08 07:47:37 -0600831 sdbus_mock(), bus_mock(sdbusplus::get_mocked_new(&sdbus_mock)),
Patrick Venture8729eb92020-08-10 10:38:44 -0700832 helper(std::make_unique<DbusHelperMock>())
Patrick Venture6b9f5992019-09-10 09:18:28 -0700833 {
Patrick Venture9b936922020-08-10 11:28:39 -0700834 EXPECT_CALL(*helper, getService(StrEq(SensorIntf), StrEq(path)))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700835 .WillOnce(Return("asdf"));
836
Patrick Venture8729eb92020-08-10 10:38:44 -0700837 EXPECT_CALL(*helper,
Patrick Venture9b936922020-08-10 11:28:39 -0700838 getProperties(StrEq("asdf"), StrEq(path), NotNull()))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700839 .WillOnce(_getProps);
Patrick Venture9b936922020-08-10 11:28:39 -0700840 EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700841 .WillOnce(Return(false));
842
843 auto info = conf::SensorConfig();
Patrick Venture8729eb92020-08-10 10:38:44 -0700844 ri = DbusPassive::createDbusPassive(bus_mock, type, id,
845 std::move(helper), &info, nullptr);
Patrick Venture6b9f5992019-09-10 09:18:28 -0700846 passive = reinterpret_cast<DbusPassive*>(ri.get());
847 EXPECT_FALSE(passive == nullptr);
848 }
849
850 sdbusplus::SdBusMock sdbus_mock;
Patrick Williamsb228bc32022-07-22 19:26:56 -0500851 sdbusplus::bus_t bus_mock;
Patrick Venture8729eb92020-08-10 10:38:44 -0700852 std::unique_ptr<DbusHelperMock> helper;
Patrick Venture6b9f5992019-09-10 09:18:28 -0700853 std::string type = "temp";
854 std::string id = "id";
855 std::string path = "/xyz/openbmc_project/sensors/temperature/id";
856 int64_t _scale = -3;
857 int64_t _value = 10;
858
859 std::unique_ptr<ReadInterface> ri;
860 DbusPassive* passive;
861 GetPropertiesFunction _getProps = &GetPropertiesMax3k;
862};
863
864TEST_F(DbusPassiveTest3kMaxObj, ReadMinAndMaxReturnsExpected)
865{
866 EXPECT_DOUBLE_EQ(0, passive->getMin());
867 EXPECT_DOUBLE_EQ(3, passive->getMax());
868}
869
870class DbusPassiveTest3kMaxIgnoredObj : public ::testing::Test
871{
872 protected:
873 DbusPassiveTest3kMaxIgnoredObj() :
Jayanth Othayoth2922eeb2024-12-08 07:47:37 -0600874 sdbus_mock(), bus_mock(sdbusplus::get_mocked_new(&sdbus_mock)),
Patrick Venture8729eb92020-08-10 10:38:44 -0700875 helper(std::make_unique<DbusHelperMock>())
Patrick Venture6b9f5992019-09-10 09:18:28 -0700876 {
Patrick Venture9b936922020-08-10 11:28:39 -0700877 EXPECT_CALL(*helper, getService(StrEq(SensorIntf), StrEq(path)))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700878 .WillOnce(Return("asdf"));
879
Patrick Venture8729eb92020-08-10 10:38:44 -0700880 EXPECT_CALL(*helper,
Patrick Venture9b936922020-08-10 11:28:39 -0700881 getProperties(StrEq("asdf"), StrEq(path), NotNull()))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700882 .WillOnce(_getProps);
Patrick Venture9b936922020-08-10 11:28:39 -0700883 EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
Patrick Venture6b9f5992019-09-10 09:18:28 -0700884 .WillOnce(Return(false));
885
886 auto info = conf::SensorConfig();
887 info.ignoreDbusMinMax = true;
Patrick Venture8729eb92020-08-10 10:38:44 -0700888 ri = DbusPassive::createDbusPassive(bus_mock, type, id,
889 std::move(helper), &info, nullptr);
Patrick Venture6b9f5992019-09-10 09:18:28 -0700890 passive = reinterpret_cast<DbusPassive*>(ri.get());
891 EXPECT_FALSE(passive == nullptr);
892 }
893
894 sdbusplus::SdBusMock sdbus_mock;
Patrick Williamsb228bc32022-07-22 19:26:56 -0500895 sdbusplus::bus_t bus_mock;
Patrick Venture8729eb92020-08-10 10:38:44 -0700896 std::unique_ptr<DbusHelperMock> helper;
Patrick Venture6b9f5992019-09-10 09:18:28 -0700897 std::string type = "temp";
898 std::string id = "id";
899 std::string path = "/xyz/openbmc_project/sensors/temperature/id";
900 int64_t _scale = -3;
901 int64_t _value = 10;
902
903 std::unique_ptr<ReadInterface> ri;
904 DbusPassive* passive;
905 GetPropertiesFunction _getProps = &GetPropertiesMax3k;
906};
907
908TEST_F(DbusPassiveTest3kMaxIgnoredObj, ReadMinAndMaxReturnsExpected)
909{
910 EXPECT_DOUBLE_EQ(0, passive->getMin());
911 EXPECT_DOUBLE_EQ(0, passive->getMax());
912}
Patrick Venturea0764872020-08-08 07:48:43 -0700913
914} // namespace
915} // namespace pid_control