Add testcases for property watches

Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>
Change-Id: I9e9266901414c71a34d9686f2a45bc4764602d53

1 files changed, 225 insertions, 0 deletions

diff --git a/src/test/propertywatchtest.cpp b/src/test/propertywatchtest.cpp
new file mode 100644
index 0000000..b92dbec
--- /dev/null
+++ b/src/test/propertywatchtest.cpp
@@ -0,0 +1,225 @@
+#include <array>
+#include "propertywatchimpl.hpp"
+#include "propertywatchtest.hpp"
+
+using namespace std::string_literals;
+using namespace phosphor::dbus::monitoring;
+
+const std::array<std::string, 4> paths =
+{
+    "/xyz/openbmc_project/testing/inst1"s,
+    "/xyz/openbmc_project/testing/inst2"s,
+    "/xyz/openbmc_project/testing/inst3"s,
+    "/xyz/openbmc_project/testing/inst4"s,
+};
+
+const std::array<std::string, 2> interfaces =
+{
+    "xyz.openbmc_project.Iface1"s,
+    "xyz.openbmc_project.Iface2"s,
+};
+
+const std::array<std::string, 2> properties =
+{
+    "Value1"s,
+    "Value2"s,
+};
+
+const std::string meta;
+
+std::array<any_ns::any, 8> storage = { };
+
+const PropertyIndex watchIndex =
+{
+    {
+        {
+            PropertyIndex::key_type{paths[0], interfaces[0], properties[0]},
+            PropertyIndex::mapped_type{meta, meta, storage[0]}
+        },
+        {
+            PropertyIndex::key_type{paths[0], interfaces[1], properties[1]},
+            PropertyIndex::mapped_type{meta, meta, storage[1]}
+        },
+        {
+            PropertyIndex::key_type{paths[1], interfaces[0], properties[0]},
+            PropertyIndex::mapped_type{meta, meta, storage[2]}
+        },
+        {
+            PropertyIndex::key_type{paths[1], interfaces[1], properties[1]},
+            PropertyIndex::mapped_type{meta, meta, storage[3]}
+        },
+        {
+            PropertyIndex::key_type{paths[2], interfaces[0], properties[0]},
+            PropertyIndex::mapped_type{meta, meta, storage[4]}
+        },
+        {
+            PropertyIndex::key_type{paths[2], interfaces[1], properties[1]},
+            PropertyIndex::mapped_type{meta, meta, storage[5]}
+        },
+        {
+            PropertyIndex::key_type{paths[3], interfaces[0], properties[0]},
+            PropertyIndex::mapped_type{meta, meta, storage[6]}
+        },
+        {
+            PropertyIndex::key_type{paths[3], interfaces[1], properties[1]},
+            PropertyIndex::mapped_type{meta, meta, storage[7]}
+        },
+    },
+};
+
+template <typename T> struct ExpectedValues {};
+template <> struct ExpectedValues<uint8_t>
+{
+    static auto& get(size_t i)
+    {
+        static const std::array<uint8_t, 8> values =
+        {
+            {0, 1, 2, 3, 4, 5, 6, 7},
+        };
+        return values[i];
+    }
+};
+
+template <> struct ExpectedValues<uint16_t>
+{
+    static auto& get(size_t i)
+    {
+        static const std::array<uint16_t, 8> values =
+        {
+            {88, 77, 66, 55, 44, 33, 22, 11},
+        };
+        return values[i];
+    }
+};
+
+template <> struct ExpectedValues<uint32_t>
+{
+    static auto& get(size_t i)
+    {
+        static const std::array<uint32_t, 8> values =
+        {
+            {0xffffffff, 1, 3, 0, 5, 7, 9, 0xffffffff},
+        };
+        return values[i];
+    }
+};
+
+template <> struct ExpectedValues<uint64_t>
+{
+    static auto& get(size_t i)
+    {
+        static const std::array<uint64_t, 8> values =
+        {
+            {0xffffffffffffffff, 3, 7, 12234, 0, 3, 9, 0xffffffff},
+        };
+        return values[i];
+    }
+};
+
+template <> struct ExpectedValues<std::string>
+{
+    static auto& get(size_t i)
+    {
+        static const std::array<std::string, 8> values =
+        {
+            {""s, "foo"s, "bar"s, "baz"s, "hello"s, "string", "\x2\x3", "\\"},
+        };
+        return values[i];
+    }
+};
+
+template <typename T>
+void testStart()
+{
+    using ::testing::Return;
+    using ::testing::_;
+
+    MockDBusInterface dbus;
+    MockDBusInterface::instance(dbus);
+
+    const std::vector<std::string> expectedMapperInterfaces;
+    PropertyWatchOfType<T, MockDBusInterface> watch(watchIndex);
+
+    auto ndx = static_cast<size_t>(0);
+    for (const auto& o : convert(watchIndex))
+    {
+        const auto& path = o.first.get();
+        const auto& interfaces = o.second;
+        std::vector<std::string> mapperResponse;
+        std::transform(
+            interfaces.begin(),
+            interfaces.end(),
+            std::back_inserter(mapperResponse),
+        // *INDENT-OFF*
+            [](const auto & item)
+            {
+                return item.first;
+            });
+        // *INDENT-ON*
+        EXPECT_CALL(
+            dbus,
+            mapperGetObject(
+                MAPPER_BUSNAME,
+                MAPPER_PATH,
+                MAPPER_INTERFACE,
+                "GetObject",
+                path,
+                expectedMapperInterfaces))
+        .WillOnce(Return(GetObject({{"", mapperResponse}})));
+        EXPECT_CALL(
+            dbus,
+            fwdAddMatch(
+                sdbusplus::bus::match::rules::member("InterfacesAdded") +
+                sdbusplus::bus::match::rules::path(path) +
+                sdbusplus::bus::match::rules::interface(
+                    "org.freedesktop.DBus.ObjectManager"),
+                _));
+        for (const auto& i : interfaces)
+        {
+            const auto& interface = i.first.get();
+            const auto& properties = i.second;
+            EXPECT_CALL(
+                dbus,
+                fwdAddMatch(
+                    sdbusplus::bus::match::rules::member("PropertiesChanged") +
+                    sdbusplus::bus::match::rules::path(path) +
+                    sdbusplus::bus::match::rules::argN(0, interface) +
+                    sdbusplus::bus::match::rules::interface(
+                        "org.freedesktop.DBus.Properties"),
+                    _));
+
+            PropertiesChanged<T> serviceResponse;
+            for (const auto& p : properties)
+            {
+                serviceResponse[p] = ExpectedValues<T>::get(ndx);
+                ++ndx;
+            }
+            Expect<T>::getProperties(dbus, path, interface)
+            .WillOnce(Return(serviceResponse));
+        }
+    }
+
+    watch.start();
+
+    ndx = 0;
+    for (auto s : storage)
+    {
+        ASSERT_EQ(s.empty(), false);
+        ASSERT_EQ(any_ns::any_cast<T>(s), ExpectedValues<T>::get(ndx));
+        ++ndx;
+    }
+
+    // Make sure start logic only runs the first time.
+    watch.start();
+}
+
+TEST(PropertyWatchTest, TestStart)
+{
+    testStart<uint8_t>();
+    testStart<uint16_t>();
+    testStart<uint32_t>();
+    testStart<uint64_t>();
+    testStart<std::string>();
+}
+
+MockDBusInterface* MockDBusInterface::ptr = nullptr;