diff --git a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/common/TestDataHolder.java b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/common/TestDataHolder.java
index bea2094a77..05be27318b 100644
--- a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/common/TestDataHolder.java
+++ b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/common/TestDataHolder.java
@@ -23,6 +23,7 @@ import io.entgra.device.mgt.core.device.mgt.common.EnrolmentInfo;
 import io.entgra.device.mgt.core.device.mgt.common.MonitoringOperation;
 import io.entgra.device.mgt.core.device.mgt.common.OperationMonitoringTaskConfig;
 import io.entgra.device.mgt.core.device.mgt.common.app.mgt.Application;
+import io.entgra.device.mgt.core.device.mgt.common.device.details.DeviceData;
 import io.entgra.device.mgt.core.device.mgt.common.device.details.DeviceInfo;
 import io.entgra.device.mgt.core.device.mgt.common.group.mgt.DeviceGroup;
 import io.entgra.device.mgt.core.device.mgt.common.notification.mgt.Notification;
@@ -32,6 +33,7 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 import java.util.Properties;
+import java.util.Calendar;
 
 public class TestDataHolder {
 
@@ -39,15 +41,23 @@ public class TestDataHolder {
     public final static Integer SUPER_TENANT_ID = -1234;
     public final static String SUPER_TENANT_DOMAIN = "carbon.super";
     public final static String initialDeviceIdentifier = "12345";
+    public final static String initialDeviceName = "TEST-DEVICE";
     public final static String OWNER = "admin";
     public static final String OPERATION_CONFIG = "TEST-OPERATION-";
     public static Device initialTestDevice;
     public static DeviceType initialTestDeviceType;
 
+    public static Date getTimeBefore(int minutes) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.MINUTE, -minutes);
+        return calendar.getTime();
+    }
+
     public static Device generateDummyDeviceData(String deviceType) {
         Device device = new Device();
         device.setEnrolmentInfo(generateEnrollmentInfo(new Date().getTime(), new Date().getTime(), OWNER, EnrolmentInfo
                 .OwnerShip.BYOD, EnrolmentInfo.Status.ACTIVE));
+        device.setName(initialDeviceName);
         device.setDescription("Test Description");
         device.setDeviceIdentifier(initialDeviceIdentifier);
         device.setType(deviceType);
@@ -141,6 +151,15 @@ public class TestDataHolder {
         return device;
     }
 
+    public static DeviceData generateDummyDevice(DeviceIdentifier deviceIdentifier) {
+        DeviceData deviceData = new DeviceData();
+        deviceData.setDeviceIdentifier(deviceIdentifier);
+        deviceData.setDeviceOwner(OWNER);
+        deviceData.setDeviceOwnership(EnrolmentInfo.OwnerShip.BYOD.toString());
+        deviceData.setLastModifiedDate(getTimeBefore(1));
+        return deviceData;
+    }
+
     public static DeviceType generateDeviceTypeData(String devTypeName) {
         DeviceType deviceType = new DeviceType();
         deviceType.setName(devTypeName);
diff --git a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/DevicePersistTests.java b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/DevicePersistTests.java
index e76a4f7850..1eb0dc1357 100644
--- a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/DevicePersistTests.java
+++ b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/DevicePersistTests.java
@@ -18,7 +18,13 @@
 
 package io.entgra.device.mgt.core.device.mgt.core.dao;
 
+import io.entgra.device.mgt.core.device.mgt.common.EnrolmentInfo;
 import io.entgra.device.mgt.core.device.mgt.common.PaginationRequest;
+import io.entgra.device.mgt.core.device.mgt.common.device.details.DeviceData;
+import io.entgra.device.mgt.core.device.mgt.common.geo.service.GeoCluster;
+import io.entgra.device.mgt.core.device.mgt.common.geo.service.GeoCoordinate;
+import io.entgra.device.mgt.core.device.mgt.common.geo.service.GeoQuery;
+import org.apache.commons.collections.map.SingletonMap;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.testng.Assert;
@@ -34,6 +40,7 @@ import io.entgra.device.mgt.core.device.mgt.core.common.TestDataHolder;
 import io.entgra.device.mgt.core.device.mgt.core.dto.DeviceType;
 
 import java.sql.*;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -275,6 +282,7 @@ public class DevicePersistTests extends BaseDeviceManagementTest {
             pr.setStatusList(Collections.singletonList(Status.ACTIVE.name()));
             List<Device> results = deviceDAO.getDevicesByStatus(pr, TestDataHolder.SUPER_TENANT_ID);
             Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
         } catch (DeviceManagementDAOException e) {
             throw new DeviceManagementDAOException("Error occurred while retrieving the current status of the " +
                     "enrolment", e);
@@ -283,4 +291,510 @@ public class DevicePersistTests extends BaseDeviceManagementTest {
         }
     }
 
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDevicesByTenantId() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevices(TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDeviceId() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(device.getDeviceIdentifier(),TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDeviceIdentifierWithTenantId() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+            Device results = deviceDAO.getDevice(deviceIdentifier,TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDeviceData() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+        DeviceData deviceData = TestDataHolder.generateDummyDevice(deviceIdentifier);
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(deviceData, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByOwner() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(deviceIdentifier,TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDateSince() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(deviceIdentifier, TestDataHolder.getTimeBefore(1), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDateSinceWithDeviceId() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(device.getDeviceIdentifier(), TestDataHolder.getTimeBefore(1), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByEnrollmentStatus() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            Device results = deviceDAO.getDevice(deviceIdentifier, Status.ACTIVE, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(device.getDeviceIdentifier(), results.getDeviceIdentifier(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDeviceIdentifier() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            SingletonMap results = deviceDAO.getDevice(deviceIdentifier);
+            Assert.assertNotNull(results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceByDeviceType() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevices(device.getType(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getAllocatedDevices() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getAllocatedDevices(device.getType(), TestDataHolder.SUPER_TENANT_ID, 1, 0);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDevicesOfUser() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevicesOfUser(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDevicesOfUserWithDeviceType() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevicesOfUser(TestDataHolder.OWNER, device.getType(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDevicesOfUserWithDeviceStatus() throws DeviceManagementDAOException, TransactionManagementException {
+        List<String> status = new ArrayList<>() ;
+        status.add(Status.ACTIVE.name());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevicesOfUser(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID, status);
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getCountOfDevicesInGroup() throws DeviceManagementDAOException, TransactionManagementException {
+        PaginationRequest pr = new PaginationRequest(0, 10);
+        pr.setGroupId(1);
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getCountOfDevicesInGroup(pr, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(0, results, "No device count returned in group");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device count" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountWithOwner() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCount(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountWithType() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCount(device.getType(), Status.ACTIVE.name(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void setEnrolmentStatusInBulk() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        List<String> devices = new ArrayList<>() ;
+        devices.add(device.getDeviceIdentifier());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            boolean results = deviceDAO.setEnrolmentStatusInBulk(device.getType(), Status.ACTIVE.name(),TestDataHolder.SUPER_TENANT_ID, devices );
+            Assert.assertTrue(results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCount() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCount(TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountWithPagination() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        PaginationRequest pr = new PaginationRequest(0, 10);
+        pr.setDeviceName(device.getName());
+        pr.setDeviceType(device.getType());
+        pr.setOwner(TestDataHolder.OWNER);
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCount(pr, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByType() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByType(device.getType(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByUser() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByUser(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByName() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByName(TestDataHolder.initialDeviceName, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByOwnership() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByOwnership(EnrolmentInfo.OwnerShip.BYOD.name(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByStatus() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByStatus(Status.ACTIVE.name(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceCountByStatusWithType() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getDeviceCountByStatus(device.getType(), Status.ACTIVE.name(), TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getActiveEnrolment() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(device.getDeviceIdentifier(), device.getType());
+
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            EnrolmentInfo results = deviceDAO.getActiveEnrolment(deviceIdentifier, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertEquals(Status.ACTIVE, results.getStatus(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDeviceEnrolledTenants() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Integer> results = deviceDAO.getDeviceEnrolledTenants();
+            Assert.assertEquals(1, results.size(), "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void findGeoClusters() throws DeviceManagementDAOException, TransactionManagementException {
+        GeoQuery geoQuery = new GeoQuery(new GeoCoordinate(123,123), new GeoCoordinate(123,123),12345);
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<GeoCluster> results = deviceDAO.findGeoClusters(geoQuery, TestDataHolder.SUPER_TENANT_ID);
+            Assert.assertNotNull(results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getAppNotInstalledDevices() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        PaginationRequest pr = new PaginationRequest(0, 10);
+        pr.setDeviceType(device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getAppNotInstalledDevices(pr, TestDataHolder.SUPER_TENANT_ID,"com.google.calc" ,"1.0.0");
+            Assert.assertNotNull(results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getCountOfAppNotInstalledDevices() throws DeviceManagementDAOException, TransactionManagementException {
+        Device device = TestDataHolder.initialTestDevice;
+        PaginationRequest pr = new PaginationRequest(0, 10);
+        pr.setDeviceType(device.getType());
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getCountOfAppNotInstalledDevices(pr, TestDataHolder.SUPER_TENANT_ID,"com.google.calc" ,"1.0.0");
+            Assert.assertEquals(1, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getDevicesByEncryptionStatus() throws DeviceManagementDAOException, TransactionManagementException {
+        PaginationRequest pr = new PaginationRequest(0, 10);
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            List<Device> results = deviceDAO.getDevicesByEncryptionStatus(pr, TestDataHolder.SUPER_TENANT_ID,false);
+            Assert.assertNotNull(results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
+    @Test(dependsOnMethods = "testAddDeviceTest")
+    public void getCountOfDevicesByEncryptionStatus() throws DeviceManagementDAOException, TransactionManagementException {
+        try {
+            DeviceManagementDAOFactory.beginTransaction();
+            int results = deviceDAO.getCountOfDevicesByEncryptionStatus(TestDataHolder.SUPER_TENANT_ID,true);
+            Assert.assertEquals(0, results, "No device returned");
+            DeviceManagementDAOFactory.commitTransaction();
+        } catch (DeviceManagementDAOException e) {
+            throw new DeviceManagementDAOException("Error occurred while retrieving the device" + e);
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+    }
+
 }
diff --git a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/GroupPersistTests.java b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/GroupPersistTests.java
index 0ea871994c..c9d186e14f 100644
--- a/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/GroupPersistTests.java
+++ b/components/device-mgt/io.entgra.device.mgt.core.device.mgt.core/src/test/java/io/entgra/device/mgt/core/device/mgt/core/dao/GroupPersistTests.java
@@ -18,6 +18,8 @@
 
 package io.entgra.device.mgt.core.device.mgt.core.dao;
 
+import io.entgra.device.mgt.core.device.mgt.common.EnrolmentInfo;
+import io.entgra.device.mgt.core.device.mgt.common.PaginationRequest;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.testng.Assert;
@@ -344,4 +346,284 @@ public class GroupPersistTests extends BaseDeviceManagementTest {
         }
         return null;
     }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getAllDevicesOfGroupWithStatus() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        List<String> deviceStatus = new ArrayList<>();
+        deviceStatus.add(EnrolmentInfo.Status.ACTIVE.name());
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getAllDevicesOfGroup(deviceGroup.getName(), deviceStatus, TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting devices of group '" + groupId + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getAllDevicesOfGroup() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getAllDevicesOfGroup(deviceGroup.getName(), TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting devices of group '" + groupId + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getGroupUnassignedDevices() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Device device = TestDataHolder.initialTestDevice;
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        PaginationRequest pr = new PaginationRequest(0,10);
+        pr.setDeviceType(device.getType());
+        List<String> groupNames = new ArrayList<>();
+        groupNames.add(deviceGroup.getName());
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getGroupUnassignedDevices(pr, groupNames);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting devices of group '" + groupId + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getOwnGroupsCount() {
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getOwnGroupsCount(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID, "/");
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting own group count for '" + TestDataHolder.OWNER + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getOwnGroups() {
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getOwnGroups(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting own groups for '" + TestDataHolder.OWNER + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getOwnGroupIds() {
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getOwnGroupIds(TestDataHolder.OWNER, TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting own group Ids for '" + TestDataHolder.OWNER + "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getDeviceCount() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getDeviceCount(deviceGroup.getGroupId(), TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting device count for '" +groupId+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void isDeviceMappedToGroup() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Device device = TestDataHolder.initialTestDevice;
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.isDeviceMappedToGroup(deviceGroup.getGroupId(), Integer.parseInt(device.getDeviceIdentifier()), TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while checking device map to group for '" +groupId+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getGroupCount() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        GroupPaginationRequest pr = new GroupPaginationRequest(0,10);
+        pr.setGroupName(deviceGroup.getName());
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getGroupCount(pr, TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting group count for '" +TestDataHolder.SUPER_TENANT_ID+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getGroupCountWithStatus() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getGroupCount(TestDataHolder.SUPER_TENANT_ID, EnrolmentInfo.Status.ACTIVE.name());
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting group count for '" +TestDataHolder.SUPER_TENANT_ID+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getRootGroups() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getRootGroups(TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting group count for '" +TestDataHolder.SUPER_TENANT_ID+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"addDeviceToGroupTest"})
+    public void getAllGroupProperties() {
+        DeviceGroup deviceGroup = getGroupById(groupId);
+        Assert.assertNotNull(deviceGroup, "Group is null");
+        try {
+            GroupManagementDAOFactory.beginTransaction();
+            groupDAO.getAllGroupProperties(groupId, TestDataHolder.SUPER_TENANT_ID);
+            GroupManagementDAOFactory.commitTransaction();
+            GroupManagementDAOFactory.closeConnection();
+        } catch (GroupManagementDAOException e) {
+            GroupManagementDAOFactory.rollbackTransaction();
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while getting groups for '" +TestDataHolder.SUPER_TENANT_ID+ "'.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        } catch (TransactionManagementException e) {
+            GroupManagementDAOFactory.closeConnection();
+            String msg = "Error occurred while initiating transaction.";
+            log.error(msg, e);
+            Assert.fail(msg, e);
+        }
+    }
 }