Adding additional test cases for devicemgt core

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/EnrollmentDAOImpl.java

@@ -18,6 +18,8 @@
  */
 package org.wso2.carbon.device.mgt.core.dao.impl;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
@@ -32,6 +34,8 @@ import java.util.List;
 
 public class EnrollmentDAOImpl implements EnrollmentDAO {
 
+    private static final Log log = LogFactory.getLog(EnrollmentDAOImpl.class);
+
     @Override
     public int addEnrollment(int deviceId, EnrolmentInfo enrolmentInfo,
                              int tenantId) throws DeviceManagementDAOException {
@@ -201,25 +205,53 @@ public class EnrollmentDAOImpl implements EnrollmentDAO {
         return true;
     }
 
-    @Override
+    private int getCountOfDevicesOfOwner(String owner, int tenantID) throws DeviceManagementDAOException {
-    public boolean setStatus(String currentOwner, EnrolmentInfo.Status status,
-                             int tenantId) throws DeviceManagementDAOException {
         Connection conn;
         PreparedStatement stmt = null;
+        ResultSet rs = null;
+        int count = 0;
         try {
             conn = this.getConnection();
-            String sql = "UPDATE DM_ENROLMENT SET STATUS = ? WHERE OWNER = ? AND TENANT_ID = ?";
+            String checkQuery = "SELECT COUNT(ID) AS COUNT FROM DM_ENROLMENT WHERE OWNER = ? AND TENANT_ID = ?";
-            stmt = conn.prepareStatement(sql);
+            stmt = conn.prepareStatement(checkQuery);
-            stmt.setString(1, status.toString());
+            stmt.setString(1, owner);
-            stmt.setString(2, currentOwner);
+            stmt.setInt(2, tenantID);
-            stmt.setInt(3, tenantId);
+            rs = stmt.executeQuery();
-            stmt.executeUpdate();
+            if(rs.next()){
+                count = rs.getInt("COUNT");
+            }
         } catch (SQLException e) {
-            throw new DeviceManagementDAOException("Error occurred while setting the status of device enrolment", e);
+            throw new DeviceManagementDAOException("Error occurred while trying to get device " +
+                    "count of Owner : "+owner, e);
         } finally {
-            DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
+        }
+        return count;
+    }
+
+    @Override
+    public boolean setStatus(String currentOwner, EnrolmentInfo.Status status,
+                             int tenantId) throws DeviceManagementDAOException {
+        Connection conn;
+        PreparedStatement stmt = null;
+        if(getCountOfDevicesOfOwner(currentOwner, tenantId) > 0){
+            try {
+                conn = this.getConnection();
+                String sql = "UPDATE DM_ENROLMENT SET STATUS = ? WHERE OWNER = ? AND TENANT_ID = ?";
+                stmt = conn.prepareStatement(sql);
+                stmt.setString(1, status.toString());
+                stmt.setString(2, currentOwner);
+                stmt.setInt(3, tenantId);
+                stmt.executeUpdate();
+            } catch (SQLException e) {
+                throw new DeviceManagementDAOException("Error occurred while setting the status of device enrolment", e);
+            } finally {
+                DeviceManagementDAOUtil.cleanupResources(stmt, null);
+            }
+            return true;
+        } else {
+            return false;
         }
-        return true;
     }
 
     @Override

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderServiceTest.java

@@ -17,6 +17,7 @@ package org.wso2.carbon.device.mgt.core.service;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.mockito.Mockito;
 import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
@@ -45,10 +46,12 @@ import org.wso2.carbon.registry.core.exceptions.RegistryException;
 import org.wso2.carbon.registry.core.internal.RegistryDataHolder;
 import org.wso2.carbon.registry.core.jdbc.realm.InMemoryRealmService;
 import org.wso2.carbon.registry.core.service.RegistryService;
+import org.wso2.carbon.user.api.UserStoreException;
 import org.wso2.carbon.user.core.service.RealmService;
 import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
 
 import java.io.InputStream;
+import java.lang.reflect.Field;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.HashMap;
@@ -176,14 +179,45 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
     public void testDisenrollment() throws DeviceManagementException {
         Device device = TestDataHolder.generateDummyDeviceData(new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE));
         boolean disenrollmentStatus = deviceMgtService.disenrollDevice(new DeviceIdentifier
-                (device
+                (device.getDeviceIdentifier(), device.getType()));
-                        .getDeviceIdentifier(),
-                        device.getType()));
         log.info(disenrollmentStatus);
 
         Assert.assertTrue(disenrollmentStatus);
     }
 
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceWithOtherUser"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testDisenrollmentWithNullDeviceID() throws DeviceManagementException {
+        deviceMgtService.disenrollDevice(null);
+    }
+
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceWithOtherUser"})
+    public void testDisenrollmentWithNonExistentDT() throws DeviceManagementException {
+        Device device = TestDataHolder.generateDummyDeviceData(new DeviceIdentifier(DEVICE_ID,
+                "NON_EXISTENT_DT"));
+        boolean result = deviceMgtService.disenrollDevice(new DeviceIdentifier(
+                device.getDeviceIdentifier(), device.getType()));
+        Assert.assertTrue(!result);
+    }
+
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceWithOtherUser"})
+    public void testDisenrollmentWithNonExistentDevice() throws DeviceManagementException {
+        Device device = TestDataHolder.generateDummyDeviceData(new DeviceIdentifier(ALTERNATE_DEVICE_ID,
+                DEVICE_TYPE));
+        boolean result = deviceMgtService.disenrollDevice(new DeviceIdentifier(
+                device.getDeviceIdentifier(), device.getType()));
+        Assert.assertTrue(!result);
+    }
+
+    @Test(dependsOnMethods = {"testDisenrollment"})
+    public void testDisenrollAlreadyDisEnrolledDevice() throws DeviceManagementException {
+        Device device = TestDataHolder.generateDummyDeviceData(new DeviceIdentifier(DEVICE_ID,
+                DEVICE_TYPE));
+        boolean result = deviceMgtService.disenrollDevice(new DeviceIdentifier(
+                device.getDeviceIdentifier(), device.getType()));
+        Assert.assertTrue(result);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testGetDeviceCount() throws DeviceManagementException {
         int count = deviceMgtService.getDeviceCount();
@@ -272,6 +306,35 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         Assert.assertTrue(devices.size() > 0);
     }
 
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testGetAllDevicesOfRoleFailureFlow() throws DeviceManagementException, UserStoreException, NoSuchFieldException, IllegalAccessException {
+        int tenantID = -1234;
+        RealmService mockRealmService = Mockito.mock(RealmService.class, Mockito.CALLS_REAL_METHODS);
+
+        Mockito.doThrow(new UserStoreException("Mocked Exception when obtaining Tenant Realm"))
+                .when(mockRealmService).getTenantUserRealm(tenantID);
+        RealmService currentRealm = DeviceManagementDataHolder.getInstance().getRealmService();
+        DeviceManagementDataHolder.getInstance().setRealmService(mockRealmService);
+        try {
+            deviceMgtService.getAllDevicesOfRole("admin");
+        } finally {
+            DeviceManagementDataHolder.getInstance().setRealmService(currentRealm);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetAllDevicesOfRoleWithNonExistentRole() throws DeviceManagementException {
+        List<Device> devices = deviceMgtService.getAllDevicesOfRole("non-existent-role");
+        Assert.assertTrue(devices.size() == 0);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testGetAllDevicesOfRoleWithNullArgs() throws DeviceManagementException {
+        deviceMgtService.getAllDevicesOfRole(null);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testDeviceByOwner() throws DeviceManagementException {
         Device device = deviceMgtService.getDevice(new DeviceIdentifier(DEVICE_ID,
@@ -279,11 +342,47 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         Assert.assertTrue(device != null);
     }
 
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testDeviceByOwnerAndNonExistentDeviceID() throws DeviceManagementException {
+        String nonExistentDeviceID = "4455";
+        Device device = deviceMgtService.getDevice(new DeviceIdentifier(nonExistentDeviceID,
+                DEVICE_TYPE), "admin", true);
+        Assert.assertTrue(device == null);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testDeviceByOwnerWithNullDeviceID() throws DeviceManagementException {
+        deviceMgtService.getDevice(null, "admin", true);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testDeviceByDate() throws DeviceManagementException, TransactionManagementException, DeviceDetailsMgtDAOException {
         Device initialDevice = deviceMgtService.getDevice(new DeviceIdentifier(DEVICE_ID,
                 DEVICE_TYPE));
 
+        addDeviceInformation(initialDevice);
+
+        Device device = deviceMgtService.getDevice(new DeviceIdentifier(DEVICE_ID,
+                DEVICE_TYPE), yesterday());
+        Assert.assertTrue(device != null);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testDeviceByDateWithNonExistentDevice() throws DeviceManagementException,
+            TransactionManagementException, DeviceDetailsMgtDAOException {
+        Device device = deviceMgtService.getDevice(new DeviceIdentifier(ALTERNATE_DEVICE_ID,
+                DEVICE_TYPE), yesterday());
+        Assert.assertTrue(device == null);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testDeviceByDateWithNullDeviceID() throws DeviceManagementException {
+        deviceMgtService.getDevice(null, yesterday());
+    }
+
+    private void addDeviceInformation(Device initialDevice) throws TransactionManagementException, DeviceDetailsMgtDAOException {
         DeviceManagementDAOFactory.beginTransaction();
 
         //Device details table will be reffered when looking for last updated time
@@ -292,10 +391,6 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
                 .generateDummyDeviceInfo());
 
         DeviceManagementDAOFactory.closeConnection();
-
-        Device device = deviceMgtService.getDevice(new DeviceIdentifier(DEVICE_ID,
-                DEVICE_TYPE), yesterday());
-        Assert.assertTrue(device != null);
     }
 
     @Test(dependsOnMethods = {"testDeviceByDate"})
@@ -320,10 +415,18 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testGetAllDevicesPaginated() throws DeviceManagementException {
         PaginationRequest request = new PaginationRequest(0, 100);
+        request.setOwnerRole("admin");
         PaginationResult result = deviceMgtService.getAllDevices(request);
         Assert.assertTrue(result.getRecordsTotal() > 0);
     }
 
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testGetAllDevicesWithNullRequest() throws DeviceManagementException {
+        PaginationRequest request = null;
+        deviceMgtService.getAllDevices(request);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testGetAllDevicesByName() throws DeviceManagementException {
         PaginationRequest request = new PaginationRequest(0, 100);
@@ -392,8 +495,15 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         Assert.assertTrue(false);
     }
 
-    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
     public void testGetDeviesOfUser() throws DeviceManagementException {
+        String username = null;
+        deviceMgtService.getDevicesOfUser(username);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviesOfUserWhileUserNull() throws DeviceManagementException {
         List<Device> devices = deviceMgtService.getDevicesOfUser("admin");
         Assert.assertTrue(!devices.isEmpty());
     }
@@ -419,6 +529,13 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         Assert.assertTrue(result.getRecordsTotal() > 0);
     }
 
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testGetDeviesOfUserWhileNullOwnerPaginated() throws DeviceManagementException {
+        PaginationRequest request = null;
+        deviceMgtService.getDevicesOfUser(request, true);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testGetDeviesByOwnership() throws DeviceManagementException {
         PaginationRequest request = new PaginationRequest(0, 100);
@@ -435,6 +552,18 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         Assert.assertTrue(result.getRecordsTotal() > 0);
     }
 
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceUnderSameUser"})
+    public void testUpdateDevicesStatus() throws DeviceManagementException {
+        boolean status = deviceMgtService.setStatus("user1", EnrolmentInfo.Status.REMOVED);
+        Assert.assertTrue(status);
+    }
+
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceUnderSameUser"})
+    public void testUpdateDevicesStatusOfNonExistingUser() throws DeviceManagementException {
+        boolean status = deviceMgtService.setStatus("random-user", EnrolmentInfo.Status.REMOVED);
+        Assert.assertFalse(status);
+    }
+
     @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testGetDeviesOfUserAndDeviceType() throws DeviceManagementException {
         List<Device> devices = deviceMgtService.getDevicesOfUser("admin", DEVICE_TYPE, true);
@@ -451,7 +580,6 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         props.setProperty("password", "!@#$$$%");
 
         EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
-
         deviceMgtService.sendRegistrationEmail(metaInfo);
         Assert.assertTrue(true);
     }