diff --git a/.gitignore b/.gitignore
index 5fc91fd..1ee5855 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 build/
-telemetry
 xyz.openbmc_project.Telemetry.service
+telemetry
 
 # Created by https://www.toptal.com/developers/gitignore/api/vim,intellij,meson,visualstudiocode
 # Edit at https://www.toptal.com/developers/gitignore?templates=vim,intellij,meson,visualstudiocode
diff --git a/meson.build b/meson.build
index d3472da..165eb2d 100644
--- a/meson.build
+++ b/meson.build
@@ -74,6 +74,7 @@
         'src/main.cpp',
         'src/persistent_json_storage.cpp',
         'src/report.cpp',
+        'src/report_factory.cpp',
         'src/report_manager.cpp',
         'src/sensor.cpp',
         'src/sensor_cache.cpp',
diff --git a/src/interfaces/report.hpp b/src/interfaces/report.hpp
new file mode 100644
index 0000000..98421be
--- /dev/null
+++ b/src/interfaces/report.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+namespace interfaces
+{
+
+class Report
+{
+  public:
+    virtual ~Report() = default;
+
+    virtual std::string getName() const = 0;
+    virtual std::string getPath() const = 0;
+};
+} // namespace interfaces
diff --git a/src/interfaces/report_factory.hpp b/src/interfaces/report_factory.hpp
new file mode 100644
index 0000000..9273d03
--- /dev/null
+++ b/src/interfaces/report_factory.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "interfaces/report.hpp"
+#include "interfaces/report_manager.hpp"
+#include "interfaces/types.hpp"
+
+#include <chrono>
+#include <memory>
+
+class ReportManager;
+
+namespace interfaces
+{
+
+class ReportFactory
+{
+  public:
+    virtual ~ReportFactory() = default;
+
+    virtual 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,
+             ReportManager& reportManager) const = 0;
+};
+
+} // namespace interfaces
diff --git a/src/interfaces/report_manager.hpp b/src/interfaces/report_manager.hpp
new file mode 100644
index 0000000..80e0c82
--- /dev/null
+++ b/src/interfaces/report_manager.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "interfaces/report.hpp"
+
+namespace interfaces
+{
+
+class ReportManager
+{
+  public:
+    virtual ~ReportManager() = default;
+
+    virtual void removeReport(const interfaces::Report* report) = 0;
+};
+
+} // namespace interfaces
diff --git a/src/interfaces/types.hpp b/src/interfaces/types.hpp
new file mode 100644
index 0000000..09a75cd
--- /dev/null
+++ b/src/interfaces/types.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <sdbusplus/message/types.hpp>
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+using ReadingParameters =
+    std::vector<std::tuple<std::vector<sdbusplus::message::object_path>,
+                           std::string, std::string, std::string>>;
diff --git a/src/report.cpp b/src/report.cpp
index 45639aa..81e3b05 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -2,9 +2,9 @@
 
 #include "report_manager.hpp"
 
-constexpr const char* reportIfaceName = "xyz.openbmc_project.Telemetry.Report";
-constexpr const char* reportPath = "/xyz/openbmc_project/Telemetry/Reports/";
-constexpr const char* deleteIfaceName = "xyz.openbmc_project.Object.Delete";
+using Readings = std::tuple<
+    uint64_t,
+    std::vector<std::tuple<std::string, std::string, double, uint64_t>>>;
 
 Report::Report(boost::asio::io_context& ioc,
                const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
@@ -13,9 +13,9 @@
                const bool logToMetricReportsCollection,
                const std::chrono::milliseconds period,
                const ReadingParameters& metricParams,
-               ReportManager& reportManager) :
+               interfaces::ReportManager& reportManager) :
     name{reportName},
-    path{reportPath + name}, interval{period}, objServer(objServer)
+    path{reportDir + name}, interval{period}, objServer(objServer)
 {
     reportIface = objServer->add_unique_interface(
         path, reportIfaceName,
diff --git a/src/report.hpp b/src/report.hpp
index 7f74d49..fb40614 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -1,30 +1,26 @@
 #pragma once
 
+#include "interfaces/report.hpp"
+#include "interfaces/report_manager.hpp"
+#include "interfaces/types.hpp"
+
 #include <boost/asio/io_context.hpp>
 #include <sdbusplus/asio/object_server.hpp>
 
 #include <chrono>
 #include <memory>
 
-using Readings = std::tuple<
-    uint64_t,
-    std::vector<std::tuple<std::string, std::string, double, uint64_t>>>;
-using ReadingParameters =
-    std::vector<std::tuple<std::vector<sdbusplus::message::object_path>,
-                           std::string, std::string, std::string>>;
-
-class ReportManager;
-
-class Report
+class Report : public interfaces::Report
 {
   public:
     Report(boost::asio::io_context& ioc,
            const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
-           const std::string& name, const std::string& reportingType,
+           const std::string& reportName, const std::string& reportingType,
            const bool emitsReadingsSignal,
            const bool logToMetricReportsCollection,
            const std::chrono::milliseconds period,
-           const ReadingParameters& metricParams, ReportManager& reportManager);
+           const ReadingParameters& metricParams,
+           interfaces::ReportManager& reportManager);
     ~Report() = default;
 
     Report(Report&) = delete;
@@ -32,12 +28,29 @@
     Report& operator=(Report&) = delete;
     Report& operator=(Report&&) = delete;
 
-    const std::string name;
-    const std::string path;
+    std::string getName() const override
+    {
+        return name;
+    }
+
+    std::string getPath() const override
+    {
+        return path;
+    }
 
   private:
+    const std::string name;
+    const std::string path;
     std::chrono::milliseconds interval;
     std::shared_ptr<sdbusplus::asio::object_server> objServer;
     std::unique_ptr<sdbusplus::asio::dbus_interface> reportIface;
     std::unique_ptr<sdbusplus::asio::dbus_interface> deleteIface;
+
+  public:
+    static constexpr const char* reportIfaceName =
+        "xyz.openbmc_project.Telemetry.Report";
+    static constexpr const char* reportDir =
+        "/xyz/openbmc_project/Telemetry/Reports/";
+    static constexpr const char* deleteIfaceName =
+        "xyz.openbmc_project.Object.Delete";
 };
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
new file mode 100644
index 0000000..9f51db5
--- /dev/null
+++ b/src/report_factory.cpp
@@ -0,0 +1,21 @@
+#include "report_factory.hpp"
+
+#include "report.hpp"
+
+ReportFactory::ReportFactory(
+    boost::asio::io_context& ioc,
+    const std::shared_ptr<sdbusplus::asio::object_server>& objServer) :
+    ioc(ioc),
+    objServer(objServer)
+{}
+
+std::unique_ptr<interfaces::Report> ReportFactory::make(
+    const std::string& name, const std::string& reportingType,
+    bool emitsReadingsSignal, bool logToMetricReportsCollection,
+    std::chrono::milliseconds period, const ReadingParameters& metricParams,
+    interfaces::ReportManager& reportManager) const
+{
+    return std::make_unique<Report>(
+        ioc, objServer, name, reportingType, emitsReadingsSignal,
+        logToMetricReportsCollection, period, metricParams, reportManager);
+}
diff --git a/src/report_factory.hpp b/src/report_factory.hpp
new file mode 100644
index 0000000..775ea45
--- /dev/null
+++ b/src/report_factory.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "interfaces/report_factory.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+
+class ReportFactory : public interfaces::ReportFactory
+{
+  public:
+    ReportFactory(
+        boost::asio::io_context& ioc,
+        const std::shared_ptr<sdbusplus::asio::object_server>& objServer);
+
+    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;
+
+  private:
+    boost::asio::io_context& ioc;
+    std::shared_ptr<sdbusplus::asio::object_server> objServer;
+};
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index f2cbe94..5944fa9 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -4,21 +4,16 @@
 
 #include <system_error>
 
-constexpr const char* reportManagerIfaceName =
-    "xyz.openbmc_project.Telemetry.ReportManager";
-constexpr const char* reportManagerPath =
-    "/xyz/openbmc_project/Telemetry/Reports";
-
 ReportManager::ReportManager(
-    const std::shared_ptr<sdbusplus::asio::connection>& bus,
+    std::unique_ptr<interfaces::ReportFactory> reportFactoryIn,
     const std::shared_ptr<sdbusplus::asio::object_server>& objServerIn) :
+    reportFactory(std::move(reportFactoryIn)),
     objServer(objServerIn)
 {
     reports.reserve(maxReports);
 
     reportManagerIface = objServer->add_unique_interface(
-        reportManagerPath, reportManagerIfaceName,
-        [this, &ioc = bus->get_io_context()](auto& dbusIface) {
+        reportManagerPath, reportManagerIfaceName, [this](auto& dbusIface) {
             dbusIface.register_property_r(
                 "MaxReports", uint32_t{}, sdbusplus::vtable::property_::const_,
                 [](const auto&) { return maxReports; });
@@ -27,13 +22,12 @@
                 [](const auto&) -> uint64_t { return minInterval.count(); });
 
             dbusIface.register_method(
-                "AddReport",
-                [this, &ioc](const std::string& reportName,
-                             const std::string& reportingType,
-                             const bool emitsReadingsUpdate,
-                             const bool logToMetricReportsCollection,
-                             const uint64_t interval,
-                             const ReadingParameters& metricParams) {
+                "AddReport", [this](const std::string& reportName,
+                                    const std::string& reportingType,
+                                    const bool emitsReadingsUpdate,
+                                    const bool logToMetricReportsCollection,
+                                    const uint64_t interval,
+                                    const ReadingParameters& metricParams) {
                     if (reports.size() >= maxReports)
                     {
                         throw sdbusplus::exception::SdBusError(
@@ -43,7 +37,7 @@
 
                     for (const auto& report : reports)
                     {
-                        if (report->name == reportName)
+                        if (report->getName() == reportName)
                         {
                             throw sdbusplus::exception::SdBusError(
                                 static_cast<int>(std::errc::file_exists),
@@ -59,16 +53,16 @@
                             "Invalid interval");
                     }
 
-                    reports.emplace_back(std::make_unique<Report>(
-                        ioc, objServer, reportName, reportingType,
-                        emitsReadingsUpdate, logToMetricReportsCollection,
-                        std::move(reportInterval), metricParams, *this));
-                    return reports.back()->path;
+                    reports.emplace_back(reportFactory->make(
+                        reportName, reportingType, emitsReadingsUpdate,
+                        logToMetricReportsCollection, std::move(reportInterval),
+                        metricParams, *this));
+                    return reports.back()->getPath();
                 });
         });
 }
 
-void ReportManager::removeReport(const Report* report)
+void ReportManager::removeReport(const interfaces::Report* report)
 {
     reports.erase(
         std::remove_if(reports.begin(), reports.end(),
diff --git a/src/report_manager.hpp b/src/report_manager.hpp
index 177a03c..2427b76 100644
--- a/src/report_manager.hpp
+++ b/src/report_manager.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
-#include "report.hpp"
+#include "interfaces/report.hpp"
+#include "interfaces/report_factory.hpp"
+#include "interfaces/report_manager.hpp"
 
 #include <sdbusplus/asio/object_server.hpp>
 
@@ -8,11 +10,11 @@
 #include <memory>
 #include <vector>
 
-class ReportManager
+class ReportManager : public interfaces::ReportManager
 {
   public:
     ReportManager(
-        const std::shared_ptr<sdbusplus::asio::connection>& bus,
+        std::unique_ptr<interfaces::ReportFactory> reportFactory,
         const std::shared_ptr<sdbusplus::asio::object_server>& objServer);
     ~ReportManager() = default;
 
@@ -21,15 +23,20 @@
     ReportManager& operator=(ReportManager&) = delete;
     ReportManager& operator=(ReportManager&&) = delete;
 
+    void removeReport(const interfaces::Report* report) override;
     static bool verifyScanPeriod(const uint64_t scanPeriod);
-    void removeReport(const Report* report);
 
   private:
+    std::unique_ptr<interfaces::ReportFactory> reportFactory;
     std::shared_ptr<sdbusplus::asio::object_server> objServer;
     std::unique_ptr<sdbusplus::asio::dbus_interface> reportManagerIface;
-    std::vector<std::unique_ptr<Report>> reports;
+    std::vector<std::unique_ptr<interfaces::Report>> reports;
 
   public:
     static constexpr uint32_t maxReports{20};
     static constexpr std::chrono::milliseconds minInterval{1000};
+    static constexpr const char* reportManagerIfaceName =
+        "xyz.openbmc_project.Telemetry.ReportManager";
+    static constexpr const char* reportManagerPath =
+        "/xyz/openbmc_project/Telemetry/Reports";
 };
diff --git a/src/telemetry.hpp b/src/telemetry.hpp
index efdebaa..bfcc99a 100644
--- a/src/telemetry.hpp
+++ b/src/telemetry.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "report_factory.hpp"
 #include "report_manager.hpp"
 
 #include <sdbusplus/asio/connection.hpp>
@@ -12,7 +13,9 @@
   public:
     Telemetry(std::shared_ptr<sdbusplus::asio::connection> bus) :
         objServer(std::make_shared<sdbusplus::asio::object_server>(bus)),
-        reportManager(bus, objServer)
+        reportManager(
+            std::make_unique<ReportFactory>(bus->get_io_context(), objServer),
+            objServer)
     {}
 
   private:
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");
+}