Merge pull request #1057 from ruwany/master

Adding Unit Tests
2025-10-06 02:01:45 +00:00 · 2017-10-13 09:49:19 +05:30 · 2017-10-13 09:49:19 +05:30 · 0edc9837a3
commit 0edc9837a3
parent 08bce84da9 57ab21f76d
3 changed files with 241 additions and 26 deletions
--- a/components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/EnrollmentDAOImpl.java
+++ b/components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/dao/impl/EnrollmentDAOImpl.java
@ -23,9 +23,12 @@ import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.dao.EnrollmentDAO;
 import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
-import org.wso2.carbon.device.mgt.core.operation.mgt.OperationMapping;

-import java.sql.*;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
@ -201,25 +204,53 @@ public class EnrollmentDAOImpl implements EnrollmentDAO {
        return true;
    }

+    private int getCountOfDevicesOfOwner(String owner, int tenantID) throws DeviceManagementDAOException {
+        Connection conn;
+        PreparedStatement stmt = null;
+        ResultSet rs = null;
+        int count = 0;
+        try {
+            conn = this.getConnection();
+            String checkQuery = "SELECT COUNT(ID) AS COUNT FROM DM_ENROLMENT WHERE OWNER = ? AND TENANT_ID = ?";
+            stmt = conn.prepareStatement(checkQuery);
+            stmt.setString(1, owner);
+            stmt.setInt(2, tenantID);
+            rs = stmt.executeQuery();
+            if(rs.next()){
+                count = rs.getInt("COUNT");
+            }
+        } catch (SQLException e) {
+            throw new DeviceManagementDAOException("Error occurred while trying to get device " +
+                    "count of Owner : "+owner, e);
+        } finally {
+            DeviceManagementDAOUtil.cleanupResources(stmt, rs);
+        }
+        return count;
+    }
+
    @Override
    public boolean setStatus(String currentOwner, EnrolmentInfo.Status status,
                             int tenantId) throws DeviceManagementDAOException {
        Connection conn;
        PreparedStatement stmt = null;
-        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);
+        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
--- a/components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/TestDeviceManager.java
+++ b/components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/TestDeviceManager.java
@ -20,6 +20,7 @@ import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration
 import org.wso2.carbon.device.mgt.common.license.mgt.License;
 import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException;

+import java.util.ArrayList;
 import java.util.List;

 public class TestDeviceManager implements DeviceManager {
@ -80,7 +81,15 @@ public class TestDeviceManager implements DeviceManager {

    @Override
    public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
-        return null;
+        List<Feature> features = new ArrayList<Feature>();
+        List<Device.Property> properties = new ArrayList<Device.Property>();
+        Device.Property prop1 = new Device.Property();
+        prop1.setName("Prop1");
+        prop1.setValue("Prop1-value");
+        properties.add(prop1);
+        Device device = new Device(deviceId.getType()+"-"+deviceId.getId(), deviceId.getType(),
+                "This is a test Device", deviceId.getId(), null, features, properties);
+        return device;
    }

    @Override
@ -92,7 +101,7 @@ public class TestDeviceManager implements DeviceManager {
    @Override
    public boolean setOwnership(DeviceIdentifier deviceId, String ownershipType)
            throws DeviceManagementException {
-        return false;
+        return true;
    }

    @Override
--- a/components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderServiceTest.java
+++ b/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;
@ -98,6 +101,20 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
        Assert.assertTrue(deviceTypes.size() > 0);
    }

+    @Test
+    public void testGetAvailableDeviceType() throws DeviceManagementException {
+        DeviceType deviceType = deviceMgtService.getDeviceType(DEVICE_TYPE);
+        Assert.assertTrue(deviceType.getName().equalsIgnoreCase(DEVICE_TYPE));
+    }
+
+    @Test
+    public void addLicense() throws DeviceManagementException {
+        License license = new License();
+        license.setLanguage("ENG");
+        license.setName("RANDON_DEVICE_LICENSE");
+        deviceMgtService.addLicense(DEVICE_TYPE, license);
+    }
+
    @Test(expectedExceptions = DeviceManagementException.class)
    public void testNullDeviceEnrollment() throws DeviceManagementException {
        deviceMgtService.enrollDevice(null);
@ -176,14 +193,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
-                        .getDeviceIdentifier(),
-                        device.getType()));
+                (device.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();
@ -259,6 +307,12 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
        Assert.assertTrue(device.getDeviceInfo() != null);
    }

+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceTypeWithProps() throws DeviceManagementException {
+        Device device = deviceMgtService.getDeviceWithTypeProperties(new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE));
+        Assert.assertTrue(!device.getProperties().isEmpty());
+    }
+
    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
    public void testGetDeviceWithOutInfo() throws DeviceManagementException {
        Device device = deviceMgtService.getDevice(new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE)
@ -272,6 +326,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 +362,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 +411,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 +435,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 +515,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 +549,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);
@ -427,6 +564,26 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
        Assert.assertTrue(result.getRecordsTotal() > 0);
    }

+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testSetOwnership() throws DeviceManagementException {
+        boolean status = deviceMgtService.setOwnership(new DeviceIdentifier(DEVICE_ID,
+                DEVICE_TYPE), EnrolmentInfo.OwnerShip.COPE.toString());
+        Assert.assertTrue(status);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testSetOwnershipNonExistentDT() throws DeviceManagementException {
+        boolean status = deviceMgtService.setOwnership(new DeviceIdentifier(DEVICE_ID,
+                "non-existent-dt"), EnrolmentInfo.OwnerShip.COPE.toString());
+        Assert.assertFalse(status);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"}, expectedExceptions =
+            DeviceManagementException.class)
+    public void testSetOwnershipOfNullDevice() throws DeviceManagementException {
+        deviceMgtService.setOwnership(null, EnrolmentInfo.OwnerShip.COPE.toString());
+    }
+
    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
    public void testGetDeviesByStatus() throws DeviceManagementException {
        PaginationRequest request = new PaginationRequest(0, 100);
@ -435,6 +592,25 @@ 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 testUpdateDevicesStatusWithDeviceID() throws DeviceManagementException {
+        boolean status = deviceMgtService.setStatus(new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE),"user1",
+                EnrolmentInfo.Status.ACTIVE);
+        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 +627,6 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
        props.setProperty("password", "!@#$$$%");

        EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
-
        deviceMgtService.sendRegistrationEmail(metaInfo);
        Assert.assertTrue(true);
    }