diff --git a/phosphor-regulators/test/device_tests.cpp b/phosphor-regulators/test/device_tests.cpp
index 49a8a8d..be353f3 100644
--- a/phosphor-regulators/test/device_tests.cpp
+++ b/phosphor-regulators/test/device_tests.cpp
@@ -53,24 +53,52 @@
 using ::testing::Throw;
 using ::testing::TypedEq;
 
-static const std::string chassisInvPath{
-    "/xyz/openbmc_project/inventory/system/chassis"};
+class DeviceTests : public ::testing::Test
+{
+  public:
+    /**
+     * Constructor.
+     *
+     * Creates the Chassis and System objects needed for calling some Device
+     * methods.
+     */
+    DeviceTests() : ::testing::Test{}
+    {
+        // Create Chassis
+        auto chassis = std::make_unique<Chassis>(1, chassisInvPath);
+        this->chassis = chassis.get();
 
-TEST(DeviceTests, Constructor)
+        // Create System
+        std::vector<std::unique_ptr<Rule>> rules{};
+        std::vector<std::unique_ptr<Chassis>> chassisVec{};
+        chassisVec.emplace_back(std::move(chassis));
+        this->system =
+            std::make_unique<System>(std::move(rules), std::move(chassisVec));
+    }
+
+  protected:
+    const std::string deviceInvPath{
+        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2"};
+    const std::string chassisInvPath{
+        "/xyz/openbmc_project/inventory/system/chassis"};
+
+    // Note: This pointer does NOT need to be explicitly deleted.  The Chassis
+    // object is owned by the System object and will be automatically deleted.
+    Chassis* chassis{nullptr};
+
+    std::unique_ptr<System> system{};
+};
+
+TEST_F(DeviceTests, Constructor)
 {
     // Test where only required parameters are specified
     {
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
         i2c::I2CInterface* i2cInterfacePtr = i2cInterface.get();
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(i2cInterface)};
+        Device device{"vdd_reg", true, deviceInvPath, std::move(i2cInterface)};
         EXPECT_EQ(device.getID(), "vdd_reg");
         EXPECT_EQ(device.isRegulator(), true);
-        EXPECT_EQ(
-            device.getFRU(),
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2");
+        EXPECT_EQ(device.getFRU(), deviceInvPath);
         EXPECT_EQ(&(device.getI2CInterface()), i2cInterfacePtr);
         EXPECT_EQ(device.getPresenceDetection(), nullptr);
         EXPECT_EQ(device.getConfiguration(), nullptr);
@@ -87,7 +115,7 @@
         // Create PresenceDetection
         std::vector<std::unique_ptr<Action>> actions{};
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<PresenceDetection> presenceDetection =
+        auto presenceDetection =
             std::make_unique<PresenceDetection>(std::move(actions));
 
         // Create Configuration
@@ -95,7 +123,7 @@
         actions.clear();
         actions.push_back(std::make_unique<MockAction>());
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<Configuration> configuration =
+        auto configuration =
             std::make_unique<Configuration>(volts, std::move(actions));
 
         // Create PhaseFaultDetection
@@ -103,7 +131,7 @@
         actions.push_back(std::make_unique<MockAction>());
         actions.push_back(std::make_unique<MockAction>());
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<PhaseFaultDetection> phaseFaultDetection =
+        auto phaseFaultDetection =
             std::make_unique<PhaseFaultDetection>(std::move(actions));
 
         // Create vector of Rail objects
@@ -112,20 +140,17 @@
         rails.push_back(std::make_unique<Rail>("vdd1"));
 
         // Create Device
-        Device device{
-            "vdd_reg",
-            false,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface),
-            std::move(presenceDetection),
-            std::move(configuration),
-            std::move(phaseFaultDetection),
-            std::move(rails)};
+        Device device{"vdd_reg",
+                      false,
+                      deviceInvPath,
+                      std::move(i2cInterface),
+                      std::move(presenceDetection),
+                      std::move(configuration),
+                      std::move(phaseFaultDetection),
+                      std::move(rails)};
         EXPECT_EQ(device.getID(), "vdd_reg");
         EXPECT_EQ(device.isRegulator(), false);
-        EXPECT_EQ(
-            device.getFRU(),
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1");
+        EXPECT_EQ(device.getFRU(), deviceInvPath);
         EXPECT_EQ(&(device.getI2CInterface()), i2cInterfacePtr);
         EXPECT_NE(device.getPresenceDetection(), nullptr);
         EXPECT_EQ(device.getPresenceDetection()->getActions().size(), 1);
@@ -138,7 +163,7 @@
     }
 }
 
-TEST(DeviceTests, AddToIDMap)
+TEST_F(DeviceTests, AddToIDMap)
 {
     std::unique_ptr<PresenceDetection> presenceDetection{};
     std::unique_ptr<Configuration> configuration{};
@@ -150,15 +175,14 @@
     rails.push_back(std::make_unique<Rail>("vdd1"));
 
     // Create Device
-    Device device{
-        "vdd_reg",
-        false,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-        std::move(createI2CInterface()),
-        std::move(presenceDetection),
-        std::move(configuration),
-        std::move(phaseFaultDetection),
-        std::move(rails)};
+    Device device{"vdd_reg",
+                  false,
+                  deviceInvPath,
+                  std::move(createI2CInterface()),
+                  std::move(presenceDetection),
+                  std::move(configuration),
+                  std::move(phaseFaultDetection),
+                  std::move(rails)};
 
     // Add Device and Rail objects to an IDMap
     IDMap idMap{};
@@ -174,15 +198,13 @@
     EXPECT_THROW(idMap.getRail("vdd2"), std::invalid_argument);
 }
 
-TEST(DeviceTests, ClearCache)
+TEST_F(DeviceTests, ClearCache)
 {
     // Test where Device does not contain a PresenceDetection object
     try
     {
-        Device device{
-            "vdd_reg", false,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface())};
+        Device device{"vdd_reg", false, deviceInvPath,
+                      std::move(createI2CInterface())};
         device.clearCache();
     }
     catch (...)
@@ -194,89 +216,59 @@
     {
         // Create PresenceDetection
         std::vector<std::unique_ptr<Action>> actions{};
-        std::unique_ptr<PresenceDetection> presenceDetection =
+        auto presenceDetection =
             std::make_unique<PresenceDetection>(std::move(actions));
         PresenceDetection* presenceDetectionPtr = presenceDetection.get();
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface),
+                      std::move(presenceDetection)};
 
         // Cache presence value in PresenceDetection
         MockServices services{};
-        presenceDetectionPtr->execute(services, system, *chassisPtr,
-                                      *devicePtr);
+        presenceDetectionPtr->execute(services, *system, *chassis, device);
         EXPECT_TRUE(presenceDetectionPtr->getCachedPresence().has_value());
 
         // Clear cached data in Device
-        devicePtr->clearCache();
+        device.clearCache();
 
         // Verify presence value no longer cached in PresenceDetection
         EXPECT_FALSE(presenceDetectionPtr->getCachedPresence().has_value());
     }
 }
 
-TEST(DeviceTests, ClearErrorHistory)
+TEST_F(DeviceTests, ClearErrorHistory)
 {
     // Create SensorMonitoring.  Will fail with a DBus exception.
-    std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+    auto action = std::make_unique<MockAction>();
     EXPECT_CALL(*action, execute)
         .WillRepeatedly(Throw(TestSDBusError{"Unable to set sensor value"}));
     std::vector<std::unique_ptr<Action>> actions{};
     actions.emplace_back(std::move(action));
-    std::unique_ptr<SensorMonitoring> sensorMonitoring =
+    auto sensorMonitoring =
         std::make_unique<SensorMonitoring>(std::move(actions));
 
     // Create Rail
     std::unique_ptr<Configuration> configuration{};
-    std::unique_ptr<Rail> rail = std::make_unique<Rail>(
-        "vddr1", std::move(configuration), std::move(sensorMonitoring));
+    auto rail = std::make_unique<Rail>("vddr1", std::move(configuration),
+                                       std::move(sensorMonitoring));
 
     // Create Device that contains Rail
-    std::unique_ptr<i2c::MockedI2CInterface> i2cInterface =
-        std::make_unique<i2c::MockedI2CInterface>();
+    auto i2cInterface = std::make_unique<i2c::MockedI2CInterface>();
     std::unique_ptr<PresenceDetection> presenceDetection{};
     std::unique_ptr<Configuration> deviceConfiguration{};
     std::unique_ptr<PhaseFaultDetection> phaseFaultDetection{};
     std::vector<std::unique_ptr<Rail>> rails{};
     rails.emplace_back(std::move(rail));
-    std::unique_ptr<Device> device = std::make_unique<Device>(
-        "reg1", true,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-        std::move(i2cInterface), std::move(presenceDetection),
-        std::move(deviceConfiguration), std::move(phaseFaultDetection),
-        std::move(rails));
-    Device* devicePtr = device.get();
-
-    // Create Chassis that contains Device
-    std::vector<std::unique_ptr<Device>> devices{};
-    devices.emplace_back(std::move(device));
-    std::unique_ptr<Chassis> chassis =
-        std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-    Chassis* chassisPtr = chassis.get();
-
-    // Create System that contains Chassis
-    std::vector<std::unique_ptr<Rule>> rules{};
-    std::vector<std::unique_ptr<Chassis>> chassisVec{};
-    chassisVec.emplace_back(std::move(chassis));
-    System system{std::move(rules), std::move(chassisVec)};
+    Device device{"reg2",
+                  true,
+                  deviceInvPath,
+                  std::move(i2cInterface),
+                  std::move(presenceDetection),
+                  std::move(deviceConfiguration),
+                  std::move(phaseFaultDetection),
+                  std::move(rails)};
 
     // Create mock services
     MockServices services{};
@@ -301,27 +293,26 @@
     // times, and log one error.
     for (int i = 1; i <= 5; ++i)
     {
-        devicePtr->monitorSensors(services, system, *chassisPtr);
+        device.monitorSensors(services, *system, *chassis);
     }
 
     // Clear error history
-    devicePtr->clearErrorHistory();
+    device.clearErrorHistory();
 
     // Monitor sensors 5 times again.  Should fail every time, write to journal
     // 3 times, and log one error.
     for (int i = 1; i <= 5; ++i)
     {
-        devicePtr->monitorSensors(services, system, *chassisPtr);
+        device.monitorSensors(services, *system, *chassis);
     }
 }
 
-TEST(DeviceTests, Close)
+TEST_F(DeviceTests, Close)
 {
     // Test where works: I2C interface is not open
     {
         // Create mock I2CInterface
-        std::unique_ptr<i2c::MockedI2CInterface> i2cInterface =
-            std::make_unique<i2c::MockedI2CInterface>();
+        auto i2cInterface = std::make_unique<i2c::MockedI2CInterface>();
         EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(false));
         EXPECT_CALL(*i2cInterface, close).Times(0);
 
@@ -333,10 +324,7 @@
             .Times(0);
 
         // Create Device
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(i2cInterface)};
+        Device device{"vdd_reg", true, deviceInvPath, std::move(i2cInterface)};
 
         // Close Device
         device.close(services);
@@ -345,8 +333,7 @@
     // Test where works: I2C interface is open
     {
         // Create mock I2CInterface
-        std::unique_ptr<i2c::MockedI2CInterface> i2cInterface =
-            std::make_unique<i2c::MockedI2CInterface>();
+        auto i2cInterface = std::make_unique<i2c::MockedI2CInterface>();
         EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true));
         EXPECT_CALL(*i2cInterface, close).Times(1);
 
@@ -358,10 +345,7 @@
             .Times(0);
 
         // Create Device
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(i2cInterface)};
+        Device device{"vdd_reg", true, deviceInvPath, std::move(i2cInterface)};
 
         // Close Device
         device.close(services);
@@ -370,8 +354,7 @@
     // Test where fails: closing I2C interface fails
     {
         // Create mock I2CInterface
-        std::unique_ptr<i2c::MockedI2CInterface> i2cInterface =
-            std::make_unique<i2c::MockedI2CInterface>();
+        auto i2cInterface = std::make_unique<i2c::MockedI2CInterface>();
         EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true));
         EXPECT_CALL(*i2cInterface, close)
             .Times(1)
@@ -394,17 +377,14 @@
             .Times(1);
 
         // Create Device
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(i2cInterface)};
+        Device device{"vdd_reg", true, deviceInvPath, std::move(i2cInterface)};
 
         // Close Device
         device.close(services);
     }
 }
 
-TEST(DeviceTests, Configure)
+TEST_F(DeviceTests, Configure)
 {
     // Test where device is not present
     {
@@ -415,46 +395,39 @@
         EXPECT_CALL(journal, logError(A<const std::string&>())).Times(0);
 
         // Create PresenceDetection.  Indicates device is not present.
-        std::unique_ptr<MockAction> presAction = std::make_unique<MockAction>();
-        EXPECT_CALL(*presAction, execute).Times(1).WillOnce(Return(false));
-        std::vector<std::unique_ptr<Action>> presActions{};
-        presActions.emplace_back(std::move(presAction));
-        std::unique_ptr<PresenceDetection> presenceDetection =
-            std::make_unique<PresenceDetection>(std::move(presActions));
+        std::unique_ptr<PresenceDetection> presenceDetection{};
+        {
+            auto action = std::make_unique<MockAction>();
+            EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(false));
+            std::vector<std::unique_ptr<Action>> actions{};
+            actions.emplace_back(std::move(action));
+            presenceDetection =
+                std::make_unique<PresenceDetection>(std::move(actions));
+        }
 
         // Create Configuration.  Action inside it should not be executed.
-        std::optional<double> volts{};
-        std::unique_ptr<MockAction> confAction = std::make_unique<MockAction>();
-        EXPECT_CALL(*confAction, execute).Times(0);
-        std::vector<std::unique_ptr<Action>> confActions{};
-        confActions.emplace_back(std::move(confAction));
-        std::unique_ptr<Configuration> configuration =
-            std::make_unique<Configuration>(volts, std::move(confActions));
+        std::unique_ptr<Configuration> configuration{};
+        {
+            std::optional<double> volts{};
+            auto action = std::make_unique<MockAction>();
+            EXPECT_CALL(*action, execute).Times(0);
+            std::vector<std::unique_ptr<Action>> actions{};
+            actions.emplace_back(std::move(action));
+            configuration =
+                std::make_unique<Configuration>(volts, std::move(actions));
+        }
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection),
-            std::move(configuration));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2",
+                      true,
+                      deviceInvPath,
+                      std::move(i2cInterface),
+                      std::move(presenceDetection),
+                      std::move(configuration)};
 
         // Call configure().  Should do nothing.
-        devicePtr->configure(services, system, *chassisPtr);
+        device.configure(services, *system, *chassis);
     }
 
     // Test where Configuration and Rails were not specified in constructor
@@ -467,27 +440,10 @@
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface)};
 
         // Call configure().
-        devicePtr->configure(services, system, *chassisPtr);
+        device.configure(services, *system, *chassis);
     }
 
     // Test where Configuration and Rails were specified in constructor
@@ -499,7 +455,7 @@
         // and log a debug message.
         MockServices services{};
         MockJournal& journal = services.getMockJournal();
-        EXPECT_CALL(journal, logDebug("Configuring reg1")).Times(1);
+        EXPECT_CALL(journal, logDebug("Configuring reg2")).Times(1);
         EXPECT_CALL(journal, logDebug("Configuring vdd0: volts=1.300000"))
             .Times(1);
         EXPECT_CALL(journal, logDebug("Configuring vio0: volts=3.200000"))
@@ -510,15 +466,15 @@
         {
             // Create Configuration for Rail
             std::optional<double> volts{1.3};
-            std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+            auto action = std::make_unique<MockAction>();
             EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
             std::vector<std::unique_ptr<Action>> actions{};
             actions.emplace_back(std::move(action));
-            std::unique_ptr<Configuration> configuration =
+            auto configuration =
                 std::make_unique<Configuration>(volts, std::move(actions));
 
             // Create Rail
-            std::unique_ptr<Rail> rail =
+            auto rail =
                 std::make_unique<Rail>("vdd0", std::move(configuration));
             rails.emplace_back(std::move(rail));
         }
@@ -527,66 +483,52 @@
         {
             // Create Configuration for Rail
             std::optional<double> volts{3.2};
-            std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+            auto action = std::make_unique<MockAction>();
             EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
             std::vector<std::unique_ptr<Action>> actions{};
             actions.emplace_back(std::move(action));
-            std::unique_ptr<Configuration> configuration =
+            auto configuration =
                 std::make_unique<Configuration>(volts, std::move(actions));
 
             // Create Rail
-            std::unique_ptr<Rail> rail =
+            auto rail =
                 std::make_unique<Rail>("vio0", std::move(configuration));
             rails.emplace_back(std::move(rail));
         }
 
         // Create Configuration for Device
         std::optional<double> volts{};
-        std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+        auto action = std::make_unique<MockAction>();
         EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
         std::vector<std::unique_ptr<Action>> actions{};
         actions.emplace_back(std::move(action));
-        std::unique_ptr<Configuration> configuration =
+        auto configuration =
             std::make_unique<Configuration>(volts, std::move(actions));
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
         std::unique_ptr<PresenceDetection> presenceDetection{};
         std::unique_ptr<PhaseFaultDetection> phaseFaultDetection{};
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection),
-            std::move(configuration), std::move(phaseFaultDetection),
-            std::move(rails));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2",
+                      true,
+                      deviceInvPath,
+                      std::move(i2cInterface),
+                      std::move(presenceDetection),
+                      std::move(configuration),
+                      std::move(phaseFaultDetection),
+                      std::move(rails)};
 
         // Call configure().
-        devicePtr->configure(services, system, *chassisPtr);
+        device.configure(services, *system, *chassis);
     }
 }
 
-TEST(DeviceTests, GetConfiguration)
+TEST_F(DeviceTests, GetConfiguration)
 {
     // Test where Configuration was not specified in constructor
     {
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface())};
+        Device device{"vdd_reg", true, deviceInvPath,
+                      std::move(createI2CInterface())};
         EXPECT_EQ(device.getConfiguration(), nullptr);
     }
 
@@ -599,17 +541,16 @@
         std::vector<std::unique_ptr<Action>> actions{};
         actions.push_back(std::make_unique<MockAction>());
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<Configuration> configuration =
+        auto configuration =
             std::make_unique<Configuration>(volts, std::move(actions));
 
         // Create Device
-        Device device{
-            "vdd_reg",
-            true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface()),
-            std::move(presenceDetection),
-            std::move(configuration)};
+        Device device{"vdd_reg",
+                      true,
+                      deviceInvPath,
+                      std::move(createI2CInterface()),
+                      std::move(presenceDetection),
+                      std::move(configuration)};
         EXPECT_NE(device.getConfiguration(), nullptr);
         EXPECT_EQ(device.getConfiguration()->getVolts().has_value(), true);
         EXPECT_EQ(device.getConfiguration()->getVolts().value(), 3.2);
@@ -617,44 +558,34 @@
     }
 }
 
-TEST(DeviceTests, GetFRU)
+TEST_F(DeviceTests, GetFRU)
 {
-    Device device{
-        "vdd_reg", true,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-        std::move(createI2CInterface())};
-    EXPECT_EQ(device.getFRU(),
-              "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2");
+    Device device{"vdd_reg", true, deviceInvPath,
+                  std::move(createI2CInterface())};
+    EXPECT_EQ(device.getFRU(), deviceInvPath);
 }
 
-TEST(DeviceTests, GetI2CInterface)
+TEST_F(DeviceTests, GetI2CInterface)
 {
     std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
     i2c::I2CInterface* i2cInterfacePtr = i2cInterface.get();
-    Device device{
-        "vdd_reg", true,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-        std::move(i2cInterface)};
+    Device device{"vdd_reg", true, deviceInvPath, std::move(i2cInterface)};
     EXPECT_EQ(&(device.getI2CInterface()), i2cInterfacePtr);
 }
 
-TEST(DeviceTests, GetID)
+TEST_F(DeviceTests, GetID)
 {
-    Device device{
-        "vdd_reg", false,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-        std::move(createI2CInterface())};
+    Device device{"vdd_reg", false, deviceInvPath,
+                  std::move(createI2CInterface())};
     EXPECT_EQ(device.getID(), "vdd_reg");
 }
 
-TEST(DeviceTests, GetPhaseFaultDetection)
+TEST_F(DeviceTests, GetPhaseFaultDetection)
 {
     // Test where PhaseFaultDetection was not specified in constructor
     {
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface())};
+        Device device{"vdd_reg", true, deviceInvPath,
+                      std::move(createI2CInterface())};
         EXPECT_EQ(device.getPhaseFaultDetection(), nullptr);
     }
 
@@ -663,33 +594,30 @@
         // Create PhaseFaultDetection
         std::vector<std::unique_ptr<Action>> actions{};
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<PhaseFaultDetection> phaseFaultDetection =
+        auto phaseFaultDetection =
             std::make_unique<PhaseFaultDetection>(std::move(actions));
 
         // Create Device
         std::unique_ptr<PresenceDetection> presenceDetection{};
         std::unique_ptr<Configuration> configuration{};
-        Device device{
-            "vdd_reg",
-            false,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface()),
-            std::move(presenceDetection),
-            std::move(configuration),
-            std::move(phaseFaultDetection)};
+        Device device{"vdd_reg",
+                      false,
+                      deviceInvPath,
+                      std::move(createI2CInterface()),
+                      std::move(presenceDetection),
+                      std::move(configuration),
+                      std::move(phaseFaultDetection)};
         EXPECT_NE(device.getPhaseFaultDetection(), nullptr);
         EXPECT_EQ(device.getPhaseFaultDetection()->getActions().size(), 1);
     }
 }
 
-TEST(DeviceTests, GetPresenceDetection)
+TEST_F(DeviceTests, GetPresenceDetection)
 {
     // Test where PresenceDetection was not specified in constructor
     {
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface())};
+        Device device{"vdd_reg", true, deviceInvPath,
+                      std::move(createI2CInterface())};
         EXPECT_EQ(device.getPresenceDetection(), nullptr);
     }
 
@@ -698,27 +626,24 @@
         // Create PresenceDetection
         std::vector<std::unique_ptr<Action>> actions{};
         actions.push_back(std::make_unique<MockAction>());
-        std::unique_ptr<PresenceDetection> presenceDetection =
+        auto presenceDetection =
             std::make_unique<PresenceDetection>(std::move(actions));
 
         // Create Device
-        Device device{
-            "vdd_reg", false,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface()), std::move(presenceDetection)};
+        Device device{"vdd_reg", false, deviceInvPath,
+                      std::move(createI2CInterface()),
+                      std::move(presenceDetection)};
         EXPECT_NE(device.getPresenceDetection(), nullptr);
         EXPECT_EQ(device.getPresenceDetection()->getActions().size(), 1);
     }
 }
 
-TEST(DeviceTests, GetRails)
+TEST_F(DeviceTests, GetRails)
 {
     // Test where no rails were specified in constructor
     {
-        Device device{
-            "vdd_reg", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface())};
+        Device device{"vdd_reg", true, deviceInvPath,
+                      std::move(createI2CInterface())};
         EXPECT_EQ(device.getRails().size(), 0);
     }
 
@@ -734,140 +659,88 @@
         rails.push_back(std::make_unique<Rail>("vdd1"));
 
         // Create Device
-        Device device{
-            "vdd_reg",
-            false,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-            std::move(createI2CInterface()),
-            std::move(presenceDetection),
-            std::move(configuration),
-            std::move(phaseFaultDetection),
-            std::move(rails)};
+        Device device{"vdd_reg",
+                      false,
+                      deviceInvPath,
+                      std::move(createI2CInterface()),
+                      std::move(presenceDetection),
+                      std::move(configuration),
+                      std::move(phaseFaultDetection),
+                      std::move(rails)};
         EXPECT_EQ(device.getRails().size(), 2);
         EXPECT_EQ(device.getRails()[0]->getID(), "vdd0");
         EXPECT_EQ(device.getRails()[1]->getID(), "vdd1");
     }
 }
 
-TEST(DeviceTests, IsPresent)
+TEST_F(DeviceTests, IsPresent)
 {
     // Test where PresenceDetection not specified in constructor
     {
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface)};
 
         // Create MockServices
         MockServices services{};
 
         // Since no PresenceDetection defined, isPresent() should return true
-        EXPECT_TRUE(devicePtr->isPresent(services, system, *chassisPtr));
+        EXPECT_TRUE(device.isPresent(services, *system, *chassis));
     }
 
     // Test where PresenceDetection was specified in constructor: Is present
     {
         // Create PresenceDetection.  Indicates device is present.
-        std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+        auto action = std::make_unique<MockAction>();
         EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
         std::vector<std::unique_ptr<Action>> actions{};
         actions.emplace_back(std::move(action));
-        std::unique_ptr<PresenceDetection> presenceDetection =
+        auto presenceDetection =
             std::make_unique<PresenceDetection>(std::move(actions));
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface),
+                      std::move(presenceDetection)};
 
         // Create MockServices
         MockServices services{};
 
         // PresenceDetection::execute() and isPresent() should return true
-        EXPECT_TRUE(devicePtr->isPresent(services, system, *chassisPtr));
+        EXPECT_TRUE(device.isPresent(services, *system, *chassis));
     }
 
     // Test where PresenceDetection was specified in constructor: Is not present
     {
         // Create PresenceDetection.  Indicates device is not present.
-        std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+        auto action = std::make_unique<MockAction>();
         EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(false));
         std::vector<std::unique_ptr<Action>> actions{};
         actions.emplace_back(std::move(action));
-        std::unique_ptr<PresenceDetection> presenceDetection =
+        auto presenceDetection =
             std::make_unique<PresenceDetection>(std::move(actions));
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface),
+                      std::move(presenceDetection)};
 
         // Create MockServices
         MockServices services{};
 
         // PresenceDetection::execute() and isPresent() should return false
-        EXPECT_FALSE(devicePtr->isPresent(services, system, *chassisPtr));
+        EXPECT_FALSE(device.isPresent(services, *system, *chassis));
     }
 }
 
-TEST(DeviceTests, IsRegulator)
+TEST_F(DeviceTests, IsRegulator)
 {
-    Device device{
-        "vdd_reg", false,
-        "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg2",
-        std::move(createI2CInterface())};
+    Device device{"vdd_reg", false, deviceInvPath,
+                  std::move(createI2CInterface())};
     EXPECT_EQ(device.isRegulator(), false);
 }
 
-TEST(DeviceTests, MonitorSensors)
+TEST_F(DeviceTests, MonitorSensors)
 {
     // Test where device is not present
     {
@@ -879,25 +752,31 @@
         EXPECT_CALL(sensors, endRail).Times(0);
 
         // Create SensorMonitoring.  Action inside it should not be executed.
-        std::unique_ptr<MockAction> sensAction = std::make_unique<MockAction>();
-        EXPECT_CALL(*sensAction, execute).Times(0);
-        std::vector<std::unique_ptr<Action>> sensActions{};
-        sensActions.emplace_back(std::move(sensAction));
-        std::unique_ptr<SensorMonitoring> sensorMonitoring =
-            std::make_unique<SensorMonitoring>(std::move(sensActions));
+        std::unique_ptr<SensorMonitoring> sensorMonitoring{};
+        {
+            auto action = std::make_unique<MockAction>();
+            EXPECT_CALL(*action, execute).Times(0);
+            std::vector<std::unique_ptr<Action>> actions{};
+            actions.emplace_back(std::move(action));
+            sensorMonitoring =
+                std::make_unique<SensorMonitoring>(std::move(actions));
+        }
 
         // Create Rail
         std::unique_ptr<Configuration> configuration{};
-        std::unique_ptr<Rail> rail = std::make_unique<Rail>(
-            "vddr1", std::move(configuration), std::move(sensorMonitoring));
+        auto rail = std::make_unique<Rail>("vddr1", std::move(configuration),
+                                           std::move(sensorMonitoring));
 
         // Create PresenceDetection.  Indicates device is not present.
-        std::unique_ptr<MockAction> presAction = std::make_unique<MockAction>();
-        EXPECT_CALL(*presAction, execute).Times(1).WillOnce(Return(false));
-        std::vector<std::unique_ptr<Action>> presActions{};
-        presActions.emplace_back(std::move(presAction));
-        std::unique_ptr<PresenceDetection> presenceDetection =
-            std::make_unique<PresenceDetection>(std::move(presActions));
+        std::unique_ptr<PresenceDetection> presenceDetection{};
+        {
+            auto action = std::make_unique<MockAction>();
+            EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(false));
+            std::vector<std::unique_ptr<Action>> actions{};
+            actions.emplace_back(std::move(action));
+            presenceDetection =
+                std::make_unique<PresenceDetection>(std::move(actions));
+        }
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
@@ -905,29 +784,17 @@
         std::unique_ptr<PhaseFaultDetection> phaseFaultDetection{};
         std::vector<std::unique_ptr<Rail>> rails{};
         rails.emplace_back(std::move(rail));
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection),
-            std::move(deviceConfiguration), std::move(phaseFaultDetection),
-            std::move(rails));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2",
+                      true,
+                      deviceInvPath,
+                      std::move(i2cInterface),
+                      std::move(presenceDetection),
+                      std::move(deviceConfiguration),
+                      std::move(phaseFaultDetection),
+                      std::move(rails)};
 
         // Call monitorSensors().  Should do nothing.
-        devicePtr->monitorSensors(services, system, *chassisPtr);
+        device.monitorSensors(services, *system, *chassis);
     }
 
     // Test where Rails were not specified in constructor
@@ -941,27 +808,10 @@
 
         // Create Device
         std::unique_ptr<i2c::I2CInterface> i2cInterface = createI2CInterface();
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2", true, deviceInvPath, std::move(i2cInterface)};
 
         // Call monitorSensors().  Should do nothing.
-        devicePtr->monitorSensors(services, system, *chassisPtr);
+        device.monitorSensors(services, *system, *chassis);
     }
 
     // Test where Rails were specified in constructor
@@ -969,15 +819,9 @@
         // Create mock services.  Set Sensors service expectations.
         MockServices services{};
         MockSensors& sensors = services.getMockSensors();
-        EXPECT_CALL(sensors, startRail("vdd0",
-                                       "/xyz/openbmc_project/inventory/system/"
-                                       "chassis/motherboard/reg1",
-                                       chassisInvPath))
+        EXPECT_CALL(sensors, startRail("vdd0", deviceInvPath, chassisInvPath))
             .Times(1);
-        EXPECT_CALL(sensors, startRail("vio0",
-                                       "/xyz/openbmc_project/inventory/system/"
-                                       "chassis/motherboard/reg1",
-                                       chassisInvPath))
+        EXPECT_CALL(sensors, startRail("vio0", deviceInvPath, chassisInvPath))
             .Times(1);
         EXPECT_CALL(sensors, setValue).Times(0);
         EXPECT_CALL(sensors, endRail(false)).Times(2);
@@ -987,34 +831,34 @@
         // Create Rail vdd0
         {
             // Create SensorMonitoring for Rail
-            std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+            auto action = std::make_unique<MockAction>();
             EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
             std::vector<std::unique_ptr<Action>> actions{};
             actions.emplace_back(std::move(action));
-            std::unique_ptr<SensorMonitoring> sensorMonitoring =
+            auto sensorMonitoring =
                 std::make_unique<SensorMonitoring>(std::move(actions));
 
             // Create Rail
             std::unique_ptr<Configuration> configuration{};
-            std::unique_ptr<Rail> rail = std::make_unique<Rail>(
-                "vdd0", std::move(configuration), std::move(sensorMonitoring));
+            auto rail = std::make_unique<Rail>("vdd0", std::move(configuration),
+                                               std::move(sensorMonitoring));
             rails.emplace_back(std::move(rail));
         }
 
         // Create Rail vio0
         {
             // Create SensorMonitoring for Rail
-            std::unique_ptr<MockAction> action = std::make_unique<MockAction>();
+            auto action = std::make_unique<MockAction>();
             EXPECT_CALL(*action, execute).Times(1).WillOnce(Return(true));
             std::vector<std::unique_ptr<Action>> actions{};
             actions.emplace_back(std::move(action));
-            std::unique_ptr<SensorMonitoring> sensorMonitoring =
+            auto sensorMonitoring =
                 std::make_unique<SensorMonitoring>(std::move(actions));
 
             // Create Rail
             std::unique_ptr<Configuration> configuration{};
-            std::unique_ptr<Rail> rail = std::make_unique<Rail>(
-                "vio0", std::move(configuration), std::move(sensorMonitoring));
+            auto rail = std::make_unique<Rail>("vio0", std::move(configuration),
+                                               std::move(sensorMonitoring));
             rails.emplace_back(std::move(rail));
         }
 
@@ -1023,28 +867,16 @@
         std::unique_ptr<PresenceDetection> presenceDetection{};
         std::unique_ptr<Configuration> configuration{};
         std::unique_ptr<PhaseFaultDetection> phaseFaultDetection{};
-        std::unique_ptr<Device> device = std::make_unique<Device>(
-            "reg1", true,
-            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1",
-            std::move(i2cInterface), std::move(presenceDetection),
-            std::move(configuration), std::move(phaseFaultDetection),
-            std::move(rails));
-        Device* devicePtr = device.get();
-
-        // Create Chassis that contains Device
-        std::vector<std::unique_ptr<Device>> devices{};
-        devices.emplace_back(std::move(device));
-        std::unique_ptr<Chassis> chassis =
-            std::make_unique<Chassis>(1, chassisInvPath, std::move(devices));
-        Chassis* chassisPtr = chassis.get();
-
-        // Create System that contains Chassis
-        std::vector<std::unique_ptr<Rule>> rules{};
-        std::vector<std::unique_ptr<Chassis>> chassisVec{};
-        chassisVec.emplace_back(std::move(chassis));
-        System system{std::move(rules), std::move(chassisVec)};
+        Device device{"reg2",
+                      true,
+                      deviceInvPath,
+                      std::move(i2cInterface),
+                      std::move(presenceDetection),
+                      std::move(configuration),
+                      std::move(phaseFaultDetection),
+                      std::move(rails)};
 
         // Call monitorSensors().  Should monitor sensors in both rails.
-        devicePtr->monitorSensors(services, system, *chassisPtr);
+        device.monitorSensors(services, *system, *chassis);
     }
 }