diff --git a/test/mocked_utils.hpp b/test/mocked_utils.hpp
index ef4baa5..873c73b 100644
--- a/test/mocked_utils.hpp
+++ b/test/mocked_utils.hpp
@@ -33,6 +33,9 @@
     MOCK_CONST_METHOD1(getVersion,
                        std::string(const std::string& psuInventoryPath));
 
+    MOCK_CONST_METHOD1(getModel,
+                       std::string(const std::string& psuInventoryPath));
+
     MOCK_CONST_METHOD1(getLatestVersion,
                        std::string(const std::set<std::string>& versions));
 
diff --git a/test/test_activation.cpp b/test/test_activation.cpp
index 27e0c66..4beffbc 100644
--- a/test/test_activation.cpp
+++ b/test/test_activation.cpp
@@ -35,8 +35,8 @@
         // By default make it compatible with the test software
         ON_CALL(mockedUtils, getPropertyImpl(_, _, _, _, StrEq(MANUFACTURER)))
             .WillByDefault(Return(any(PropertyType(std::string("TestManu")))));
-        ON_CALL(mockedUtils, getPropertyImpl(_, _, _, _, StrEq(MODEL)))
-            .WillByDefault(Return(any(PropertyType(std::string("TestModel")))));
+        ON_CALL(mockedUtils, getModel(_))
+            .WillByDefault(Return(std::string("TestModel")));
         ON_CALL(mockedUtils, isAssociated(_, _)).WillByDefault(Return(false));
     }
     ~TestActivation() override
@@ -320,9 +320,8 @@
     constexpr auto psu1 = "/com/example/inventory/psu1";
     constexpr auto psu2 = "/com/example/inventory/psu2";
     constexpr auto psu3 = "/com/example/inventory/psu3";
-    ON_CALL(mockedUtils, getPropertyImpl(_, _, StrEq(psu1), _, StrEq(MODEL)))
-        .WillByDefault(
-            Return(any(PropertyType(std::string("DifferentModel")))));
+    ON_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillByDefault(Return(std::string("DifferentModel")));
     activation = std::make_unique<Activation>(
         mockedBus, dBusPath, versionId, extVersion, status, associations,
         filePath, &mockedAssociationInterface, &mockedActivationListener);
diff --git a/test/test_item_updater.cpp b/test/test_item_updater.cpp
index 7fd1e7a..ad01f42 100644
--- a/test/test_item_updater.cpp
+++ b/test/test_item_updater.cpp
@@ -69,7 +69,6 @@
     std::unique_ptr<ItemUpdater> itemUpdater;
     Properties propAdded{{PRESENT, PropertyType(true)}};
     Properties propRemoved{{PRESENT, PropertyType(false)}};
-    Properties propModel{{MODEL, PropertyType(std::string("dummyModel"))}};
 };
 
 TEST_F(TestItemUpdater, ctordtor)
@@ -88,14 +87,9 @@
         .WillOnce(Return(std::vector<std::string>({psuPath})));
     EXPECT_CALL(mockedUtils, getService(_, StrEq(psuPath), _))
         .WillOnce(Return(service));
-    EXPECT_CALL(mockedUtils, getVersion(StrEq(psuPath)))
-        .WillOnce(Return(std::string(version)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(false)))); // not present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("")))));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -122,9 +116,8 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -157,17 +150,15 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel0")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel1")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -209,17 +200,15 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel0")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel1")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -261,9 +250,8 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -295,14 +283,9 @@
         .WillOnce(Return(std::vector<std::string>({psuPath})));
     EXPECT_CALL(mockedUtils, getService(_, StrEq(psuPath), _))
         .WillOnce(Return(service));
-    EXPECT_CALL(mockedUtils, getVersion(StrEq(psuPath)))
-        .WillOnce(Return(std::string(version)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(false)))); // not present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("")))));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -314,14 +297,14 @@
     itemUpdater = std::make_unique<ItemUpdater>(mockedBus, dBusPath);
 
     // The PSU is present and version is added in a single call
-    Properties propAddedAndModel{
-        {PRESENT, PropertyType(true)},
-        {MODEL, PropertyType(std::string("testModel"))}};
+    Properties propAdded{{PRESENT, PropertyType(true)}};
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psuPath)))
         .WillOnce(Return(std::string(version)));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("testModel")));
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(objPath)))
         .Times(2);
-    onPsuInventoryChanged(psuPath, propAddedAndModel);
+    onPsuInventoryChanged(psuPath, propAdded);
 }
 
 TEST_F(TestItemUpdater, OnOnePSURemovedAndAddedWithLatestVersion)
@@ -339,9 +322,8 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -359,6 +341,8 @@
 
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psuPath)))
         .WillOnce(Return(std::string(version)));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(objPath)))
         .Times(2);
 
@@ -372,7 +356,6 @@
                                                           StrEq("StartUnit")))
         .Times(0);
     onPsuInventoryChanged(psuPath, propAdded);
-    onPsuInventoryChanged(psuPath, propModel);
 
     // on exit, objects are removed
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_removed(_, StrEq(objPath)))
@@ -403,17 +386,15 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel0")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel1")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -449,16 +430,18 @@
     objPath1 = getObjPath(version1);
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu0)))
         .WillOnce(Return(std::string(version0)));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(objPath0)))
         .Times(2);
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(objPath1)))
         .Times(2);
     onPsuInventoryChanged(psu0, propAdded);
-    onPsuInventoryChanged(psu1, propModel);
     onPsuInventoryChanged(psu1, propAdded);
-    onPsuInventoryChanged(psu0, propModel);
 
     // on exit, objects are removed
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_removed(_, StrEq(objPath0)))
@@ -479,14 +462,9 @@
         .WillOnce(Return(std::vector<std::string>({psuPath})));
     EXPECT_CALL(mockedUtils, getService(_, StrEq(psuPath), _))
         .WillOnce(Return(service));
-    EXPECT_CALL(mockedUtils, getVersion(StrEq(psuPath)))
-        .WillOnce(Return(std::string(version)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(false)))); // not present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("")))));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -523,9 +501,8 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
                                              _, StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
 
     // The item updater itself
     EXPECT_CALL(sdbusMock, sd_bus_emit_object_added(_, StrEq(dBusPath)))
@@ -572,17 +549,15 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel0")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel1")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
 
     itemUpdater = std::make_unique<ItemUpdater>(mockedBus, dBusPath);
 
@@ -642,17 +617,15 @@
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu0), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel0")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu0)))
+        .WillOnce(Return(std::string("dummyModel0")));
     EXPECT_CALL(mockedUtils, getVersion(StrEq(psu1)))
         .WillOnce(Return(std::string(version1)));
     EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
                                              StrEq(PRESENT)))
         .WillOnce(Return(any(PropertyType(true)))); // present
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psu1), _,
-                                             StrEq(MODEL)))
-        .WillOnce(Return(any(PropertyType(std::string("dummyModel1")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psu1)))
+        .WillOnce(Return(std::string("dummyModel1")));
 
     itemUpdater = std::make_unique<ItemUpdater>(mockedBus, dBusPath);
 
@@ -702,9 +675,9 @@
     ON_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath), _,
                                          StrEq(PRESENT)))
         .WillByDefault(Return(any(PropertyType(true)))); // present
-    ON_CALL(mockedUtils,
-            getPropertyImpl(_, StrEq(service), StrEq(psuPath), _, StrEq(MODEL)))
-        .WillByDefault(Return(any(PropertyType(std::string("dummyModel")))));
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("dummyModel")));
+
     itemUpdater = std::make_unique<ItemUpdater>(mockedBus, dBusPath);
 
     // Add an association to simulate that it has image in BMC filesystem
@@ -725,10 +698,9 @@
                                              _, StrEq(MANUFACTURER)))
         .WillOnce(
             Return(any(PropertyType(std::string(""))))); // Checking compatible
-    EXPECT_CALL(mockedUtils, getPropertyImpl(_, StrEq(service), StrEq(psuPath),
-                                             _, StrEq(MODEL)))
-        .WillOnce(
-            Return(any(PropertyType(std::string(""))))); // Checking compatible
+    EXPECT_CALL(mockedUtils, getModel(StrEq(psuPath)))
+        .WillOnce(Return(std::string("")))
+        .WillOnce(Return(std::string("")));
     std::set<std::string> expectedVersions = {version, oldVersion};
     EXPECT_CALL(mockedUtils, getLatestVersion(ContainerEq(expectedVersions)))
         .WillOnce(Return(version));
@@ -739,5 +711,4 @@
         .Times(3); // There are 3 systemd units are started, enable bmc reboot
                    // guard, start activation, and disable bmc reboot guard
     onPsuInventoryChanged(psuPath, propAdded);
-    onPsuInventoryChanged(psuPath, propModel);
 }