diff --git a/tests/meson.build b/tests/meson.build
index 89e5088..fbee253 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -25,6 +25,7 @@
         [
             '../src/persistent_json_storage.cpp',
             '../src/report.cpp',
+            '../src/report_factory.cpp',
             '../src/report_manager.cpp',
             '../src/sensor.cpp',
             '../src/sensor_cache.cpp',
@@ -33,6 +34,8 @@
             'src/stubs/dbus_sensor_object.cpp',
             'src/test_detached_timer.cpp',
             'src/test_persistent_json_storage.cpp',
+            'src/test_report.cpp',
+            'src/test_report_manager.cpp',
             'src/test_sensor.cpp',
             'src/test_sensor_cache.cpp',
             'src/test_unique_call.cpp',
diff --git a/tests/src/dbus_environment.hpp b/tests/src/dbus_environment.hpp
index d039922..e483fe7 100644
--- a/tests/src/dbus_environment.hpp
+++ b/tests/src/dbus_environment.hpp
@@ -1,4 +1,5 @@
 #include <sdbusplus/asio/object_server.hpp>
+#include <sdbusplus/asio/property.hpp>
 
 #include <future>
 #include <thread>
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
new file mode 100644
index 0000000..24cc23e
--- /dev/null
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "interfaces/report_factory.hpp"
+#include "mocks/report_mock.hpp"
+
+#include <gmock/gmock.h>
+
+class ReportFactoryMock : public interfaces::ReportFactory
+{
+  public:
+    ReportFactoryMock()
+    {
+        using namespace testing;
+
+        ON_CALL(*this, make)
+            .WillByDefault(WithArgs<0>(Invoke([](const std::string& name) {
+                return std::make_unique<NiceMock<ReportMock>>(name);
+            })));
+    }
+
+    MOCK_METHOD(std::unique_ptr<interfaces::Report>, make,
+                (const std::string& name, const std::string& reportingType,
+                 bool emitsReadingsSignal, bool logToMetricReportsCollection,
+                 std::chrono::milliseconds period,
+                 const ReadingParameters& metricParams,
+                 interfaces::ReportManager& reportManager),
+                (const, override));
+};
diff --git a/tests/src/mocks/report_manager_mock.hpp b/tests/src/mocks/report_manager_mock.hpp
new file mode 100644
index 0000000..17d0a06
--- /dev/null
+++ b/tests/src/mocks/report_manager_mock.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "interfaces/report_manager.hpp"
+
+#include <gmock/gmock.h>
+
+class ReportManagerMock : public interfaces::ReportManager
+{
+  public:
+    ReportManagerMock()
+    {}
+
+    MOCK_METHOD(void, removeReport, (const interfaces::Report*), (override));
+};
diff --git a/tests/src/mocks/report_mock.hpp b/tests/src/mocks/report_mock.hpp
new file mode 100644
index 0000000..4943421
--- /dev/null
+++ b/tests/src/mocks/report_mock.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "interfaces/report.hpp"
+
+#include <gmock/gmock.h>
+
+class ReportMock : public interfaces::Report
+{
+  public:
+    ReportMock(std::string reportName)
+    {
+        using namespace testing;
+
+        ON_CALL(*this, getName).WillByDefault([reportName] {
+            return reportName;
+        });
+        ON_CALL(*this, getPath).WillByDefault([reportName] {
+            return "/" + reportName;
+        });
+
+        EXPECT_CALL(*this, getPath).Times(AnyNumber());
+        EXPECT_CALL(*this, getName).Times(AnyNumber());
+        EXPECT_CALL(*this, Die).Times(AnyNumber());
+    }
+
+    virtual ~ReportMock()
+    {
+        Die();
+    }
+
+    MOCK_METHOD(std::string, getName, (), (override, const));
+    MOCK_METHOD(std::string, getPath, (), (override, const));
+    MOCK_METHOD(void, Die, ());
+};
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
new file mode 100644
index 0000000..dea453d
--- /dev/null
+++ b/tests/src/test_report.cpp
@@ -0,0 +1,169 @@
+#include "dbus_environment.hpp"
+#include "mocks/report_manager_mock.hpp"
+#include "report.hpp"
+#include "report_manager.hpp"
+
+#include <sdbusplus/exception.hpp>
+
+using namespace testing;
+using namespace std::literals::string_literals;
+
+class TestReport : public Test
+{
+  public:
+    std::string defaultReportName = "TestReport";
+    std::string defaultReportType = "Periodic";
+    bool defaultEmitReadingSignal = true;
+    bool defaultLogToMetricReportCollection = true;
+    uint64_t defaultInterval = ReportManager::minInterval.count();
+    ReadingParameters defaultReadingParams = {};
+
+    std::unique_ptr<ReportManagerMock> reportManagerMock =
+        std::make_unique<StrictMock<ReportManagerMock>>();
+    Report sut =
+        Report(DbusEnvironment::getIoc(), DbusEnvironment::getObjServer(),
+               defaultReportName, defaultReportType, defaultEmitReadingSignal,
+               defaultLogToMetricReportCollection,
+               std::chrono::milliseconds{defaultInterval}, defaultReadingParams,
+               *reportManagerMock);
+
+    template <class T>
+    static T getProperty(const std::string& path, const std::string& property)
+    {
+        std::promise<T> propertyPromise;
+        sdbusplus::asio::getProperty<T>(
+            *DbusEnvironment::getBus(), DbusEnvironment::serviceName(), path,
+            Report::reportIfaceName, property,
+            [&propertyPromise](boost::system::error_code ec) {
+                EXPECT_THAT(static_cast<bool>(ec), ::testing::Eq(false));
+                propertyPromise.set_value(T{});
+            },
+            [&propertyPromise](T t) { propertyPromise.set_value(t); });
+        return DbusEnvironment::waitForFuture(propertyPromise.get_future())
+            .value_or(T{});
+    }
+
+    template <class T>
+    static boost::system::error_code setProperty(const std::string& path,
+                                                 const std::string& property,
+                                                 const T& newValue)
+    {
+        std::promise<boost::system::error_code> setPromise;
+        sdbusplus::asio::setProperty(
+            *DbusEnvironment::getBus(), DbusEnvironment::serviceName(), path,
+            Report::reportIfaceName, property, std::move(newValue),
+            [&setPromise](boost::system::error_code ec) {
+                setPromise.set_value(ec);
+            },
+            [&setPromise]() {
+                setPromise.set_value(boost::system::error_code{});
+            });
+        return DbusEnvironment::waitForFuture(setPromise.get_future())
+            .value_or(boost::system::error_code{});
+    }
+
+    boost::system::error_code deleteReport(const std::string& path)
+    {
+        std::promise<boost::system::error_code> deleteReportPromise;
+        DbusEnvironment::getBus()->async_method_call(
+            [&deleteReportPromise](boost::system::error_code ec) {
+                deleteReportPromise.set_value(ec);
+            },
+            DbusEnvironment::serviceName(), path, Report::deleteIfaceName,
+            "Delete");
+        return DbusEnvironment::waitForFuture(deleteReportPromise.get_future())
+            .value_or(boost::system::error_code{});
+    }
+};
+
+TEST_F(TestReport, verifyIfPropertiesHaveValidValue)
+{
+    EXPECT_THAT(getProperty<uint64_t>(sut.getPath(), "Interval"),
+                Eq(defaultInterval));
+    EXPECT_THAT(getProperty<bool>(sut.getPath(), "Persistency"), Eq(false));
+    EXPECT_THAT(getProperty<std::string>(sut.getPath(), "ReportingType"),
+                Eq(defaultReportType));
+    EXPECT_THAT(getProperty<bool>(sut.getPath(), "EmitsReadingsUpdate"),
+                Eq(defaultEmitReadingSignal));
+    EXPECT_THAT(
+        getProperty<bool>(sut.getPath(), "LogToMetricReportsCollection"),
+        Eq(defaultLogToMetricReportCollection));
+    EXPECT_THAT(
+        getProperty<ReadingParameters>(sut.getPath(), "ReadingParameters"),
+        Eq(defaultReadingParams));
+}
+
+TEST_F(TestReport, setIntervalWithValidValue)
+{
+    uint64_t newValue = defaultInterval + 1;
+    EXPECT_THAT(setProperty(sut.getPath(), "Interval", newValue).value(),
+                Eq(boost::system::errc::success));
+    EXPECT_THAT(getProperty<uint64_t>(sut.getPath(), "Interval"), Eq(newValue));
+}
+
+TEST_F(TestReport, settingIntervalWithInvalidValueDoesNotChangeProperty)
+{
+    uint64_t newValue = defaultInterval - 1;
+    EXPECT_THAT(setProperty(sut.getPath(), "Interval", newValue).value(),
+                Eq(boost::system::errc::success));
+    EXPECT_THAT(getProperty<uint64_t>(sut.getPath(), "Interval"),
+                Eq(defaultInterval));
+}
+
+TEST_F(TestReport, deleteReport)
+{
+    EXPECT_CALL(*reportManagerMock, removeReport(&sut));
+    auto ec = deleteReport(sut.getPath());
+    EXPECT_THAT(ec, Eq(boost::system::errc::success));
+}
+
+TEST_F(TestReport, deletingNonExistingReportReturnInvalidRequestDescriptor)
+{
+    auto ec = deleteReport(Report::reportDir + "NonExisting"s);
+    EXPECT_THAT(ec.value(), Eq(EBADR));
+}
+
+class TestReportCreation : public Test
+{
+  public:
+    std::unique_ptr<ReportManagerMock> reportManagerMock =
+        std::make_unique<StrictMock<ReportManagerMock>>();
+
+    std::unique_ptr<Report> createReportWithName(std::string name)
+    {
+        return std::make_unique<Report>(
+            DbusEnvironment::getIoc(), DbusEnvironment::getObjServer(), name,
+            "", true, true,
+            std::chrono::milliseconds{ReportManager::minInterval.count()},
+            ReadingParameters{}, *reportManagerMock);
+    }
+};
+
+class TestReportValidNames :
+    public TestReportCreation,
+    public WithParamInterface<const char*>
+{};
+
+INSTANTIATE_TEST_SUITE_P(ValidNames, TestReportValidNames,
+                         ValuesIn({"Valid_1", "Valid_1/Valid_2",
+                                   "Valid_1/Valid_2/Valid_3"}));
+
+TEST_P(TestReportValidNames, reportCtorDoesNotThrowOnValidName)
+{
+    EXPECT_NO_THROW(createReportWithName(GetParam()));
+}
+
+class TestReportInvalidNames :
+    public TestReportCreation,
+    public WithParamInterface<const char*>
+{};
+
+INSTANTIATE_TEST_SUITE_P(InvalidNames, TestReportInvalidNames,
+                         ValuesIn({"/", "/Invalid", "Invalid/",
+                                   "Invalid/Invalid/", "Invalid?"}));
+
+TEST_P(TestReportInvalidNames, reportCtorThrowOnInvalidName)
+{
+    EXPECT_THROW(createReportWithName(GetParam()),
+                 sdbusplus::exception::SdBusError);
+}
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
new file mode 100644
index 0000000..561b4c8
--- /dev/null
+++ b/tests/src/test_report_manager.cpp
@@ -0,0 +1,194 @@
+#include "dbus_environment.hpp"
+#include "mocks/report_factory_mock.hpp"
+#include "report_manager.hpp"
+
+using namespace testing;
+
+class TestReportManager : public Test
+{
+  public:
+    std::string defaultReportName = "TestReport";
+    std::string defaultReportType = "Periodic";
+    bool defaultEmitReadingSignal = true;
+    bool defaultLogToMetricReportCollection = true;
+    uint64_t defaultInterval = ReportManager::minInterval.count();
+    ReadingParameters defaultReadingParams = {};
+
+    std::unique_ptr<ReportFactoryMock> reportFactoryMockPtr =
+        std::make_unique<StrictMock<ReportFactoryMock>>();
+    ReportFactoryMock& reportFactoryMock = *reportFactoryMockPtr;
+    ReportManager sut = ReportManager(std::move(reportFactoryMockPtr),
+                                      DbusEnvironment::getObjServer());
+
+    MockFunction<void(std::string)> checkPoint;
+
+    void TearDown() override
+    {
+        DbusEnvironment::synchronizeIoc();
+    }
+
+    std::pair<boost::system::error_code, std::string>
+        addReport(const std::string& reportName,
+                  uint64_t interval = ReportManager::minInterval.count())
+    {
+        std::promise<std::pair<boost::system::error_code, std::string>>
+            addReportPromise;
+        DbusEnvironment::getBus()->async_method_call(
+            [&addReportPromise](boost::system::error_code ec,
+                                const std::string& path) {
+                addReportPromise.set_value({ec, path});
+            },
+            DbusEnvironment::serviceName(), ReportManager::reportManagerPath,
+            ReportManager::reportManagerIfaceName, "AddReport", reportName,
+            defaultReportType, defaultEmitReadingSignal,
+            defaultLogToMetricReportCollection, interval, defaultReadingParams);
+        return DbusEnvironment::waitForFuture(addReportPromise.get_future())
+            .value_or(std::pair<boost::system::error_code, std::string>{});
+    }
+
+    template <class T>
+    static T getProperty(std::string property)
+    {
+        std::promise<T> propertyPromise;
+        sdbusplus::asio::getProperty<T>(
+            *DbusEnvironment::getBus(), DbusEnvironment::serviceName(),
+            ReportManager::reportManagerPath,
+            ReportManager::reportManagerIfaceName, property,
+            [&propertyPromise](boost::system::error_code ec) {
+                EXPECT_THAT(static_cast<bool>(ec), ::testing::Eq(false));
+                propertyPromise.set_value(T{});
+            },
+            [&propertyPromise](T t) { propertyPromise.set_value(t); });
+        return DbusEnvironment::waitForFuture(propertyPromise.get_future())
+            .value_or(T{});
+    }
+};
+
+TEST_F(TestReportManager, minInterval)
+{
+    EXPECT_THAT(getProperty<uint64_t>("MinInterval"),
+                Eq(static_cast<uint64_t>(ReportManager::minInterval.count())));
+}
+
+TEST_F(TestReportManager, maxReports)
+{
+    EXPECT_THAT(getProperty<uint32_t>("MaxReports"),
+                Eq(ReportManager::maxReports));
+}
+
+TEST_F(TestReportManager, addReport)
+{
+    auto reportMockPtr =
+        std::make_unique<NiceMock<ReportMock>>(defaultReportName);
+    auto& reportMock = *reportMockPtr;
+
+    EXPECT_CALL(reportFactoryMock,
+                make(defaultReportName, defaultReportType,
+                     defaultEmitReadingSignal,
+                     defaultLogToMetricReportCollection,
+                     std::chrono::milliseconds{defaultInterval},
+                     defaultReadingParams, Ref(sut)))
+        .WillOnce(Return(ByMove(std::move(reportMockPtr))));
+
+    auto [ec, path] = addReport(defaultReportName);
+    EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
+    EXPECT_THAT(path, Eq(reportMock.getPath()));
+}
+
+TEST_F(TestReportManager, failToAddReportTwice)
+{
+    EXPECT_CALL(reportFactoryMock, make(_, _, _, _, _, _, _));
+
+    addReport(defaultReportName);
+
+    auto [ec, path] = addReport(defaultReportName);
+    EXPECT_THAT(ec.value(), Eq(boost::system::errc::file_exists));
+    EXPECT_THAT(path, Eq(std::string()));
+}
+
+TEST_F(TestReportManager, failToAddReportWithInvalidInterval)
+{
+    EXPECT_CALL(reportFactoryMock, make(_, _, _, _, _, _, _)).Times(0);
+
+    uint64_t interval = defaultInterval - 1;
+
+    auto [ec, path] = addReport(defaultReportName, interval);
+    EXPECT_THAT(ec.value(), Eq(boost::system::errc::invalid_argument));
+    EXPECT_THAT(path, Eq(std::string()));
+}
+
+TEST_F(TestReportManager, failToAddReportWhenMaxReportIsReached)
+{
+    EXPECT_CALL(reportFactoryMock, make(_, _, _, _, _, _, _))
+        .Times(ReportManager::maxReports);
+
+    for (size_t i = 0; i < ReportManager::maxReports; i++)
+    {
+        std::string reportName = defaultReportName + std::to_string(i);
+
+        auto [ec, path] = addReport(reportName);
+        EXPECT_THAT(ec.value(), Eq(boost::system::errc::success));
+    }
+
+    std::string reportName =
+        defaultReportName + std::to_string(ReportManager::maxReports);
+    auto [ec, path] = addReport(reportName);
+    EXPECT_THAT(ec.value(), Eq(boost::system::errc::too_many_files_open));
+    EXPECT_THAT(path, Eq(std::string()));
+}
+
+TEST_F(TestReportManager, removeReport)
+{
+    auto reportMockPtr =
+        std::make_unique<NiceMock<ReportMock>>(defaultReportName);
+    auto& reportMock = *reportMockPtr;
+
+    {
+        InSequence seq;
+        EXPECT_CALL(reportFactoryMock, make(_, _, _, _, _, _, _))
+            .WillOnce(Return(ByMove(std::move(reportMockPtr))));
+        EXPECT_CALL(reportMock, Die());
+        EXPECT_CALL(checkPoint, Call("end"));
+    }
+
+    addReport(defaultReportName);
+    sut.removeReport(&reportMock);
+    checkPoint.Call("end");
+}
+
+TEST_F(TestReportManager, removingReportThatIsNotInContainerHasNoEffect)
+{
+    auto reportMockPtr =
+        std::make_unique<NiceMock<ReportMock>>(defaultReportName);
+    auto& reportMock = *reportMockPtr;
+
+    {
+        InSequence seq;
+        EXPECT_CALL(checkPoint, Call("end"));
+        EXPECT_CALL(reportMock, Die());
+    }
+
+    sut.removeReport(&reportMock);
+    checkPoint.Call("end");
+}
+
+TEST_F(TestReportManager, removingSameReportTwiceHasNoSideEffect)
+{
+    auto reportMockPtr =
+        std::make_unique<NiceMock<ReportMock>>(defaultReportName);
+    auto& reportMock = *reportMockPtr;
+
+    {
+        InSequence seq;
+        EXPECT_CALL(reportFactoryMock,
+                    make(defaultReportName, _, _, _, _, _, _))
+            .WillOnce(Return(ByMove(std::move(reportMockPtr))));
+        EXPECT_CALL(reportMock, Die());
+        EXPECT_CALL(checkPoint, Call("end"));
+    }
+
+    addReport(defaultReportName);
+    sut.removeReport(&reportMock);
+    sut.removeReport(&reportMock);
+    checkPoint.Call("end");
+}