Merge pull request #1000 from Megala21/master

Improving the existing test cases and adding some negative test cases

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/DeviceTypeManager.java

@@ -189,6 +189,9 @@ public class DeviceTypeManager implements DeviceManager {
     @Override
     public boolean saveConfiguration(PlatformConfiguration tenantConfiguration)
             throws DeviceManagementException {
+        if (tenantConfiguration == null) {
+            throw new DeviceManagementException("Platform configuration is null. Cannot save the configuration");
+        }
         try {
             if (log.isDebugEnabled()) {
                 log.debug("Persisting " + deviceType + " configurations in Registry");
@@ -246,6 +249,9 @@ public class DeviceTypeManager implements DeviceManager {
 
     @Override
     public boolean enrollDevice(Device device) throws DeviceManagementException {
+        if (device == null) {
+            throw new DeviceManagementException("Device is null. Cannot enroll the device.");
+        }
         if (propertiesExist) {
             boolean status = false;
             boolean isEnrolled = this.isEnrolled(
@@ -313,6 +319,9 @@ public class DeviceTypeManager implements DeviceManager {
 
     @Override
     public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
+        if (deviceId == null) {
+            throw new DeviceManagementException("Cannot check the enrollment status of a null device");
+        }
         if (propertiesExist) {
             boolean isEnrolled = false;
             try {
@@ -347,6 +356,9 @@ public class DeviceTypeManager implements DeviceManager {
 
     @Override
     public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
+        if (deviceId == null) {
+            throw new DeviceManagementException("Cannot get the device. DeviceIdentifier is null");
+        }
         if (propertiesExist) {
             Device device;
             try {

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/DeviceTypePluginDAOImpl.java

@@ -44,7 +44,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
     private String selectDBQueryForGetDevice;
     private String createDBqueryForAddDevice;
     private String updateDBQueryForUpdateDevice;
-    private String deleteDBQueryToRemoveDevicd;
     private String selectDBQueryToGetAllDevice;
 
     public DeviceTypePluginDAOImpl(DeviceDAODefinition deviceDAODefinition,
@@ -158,33 +157,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
         return status;
     }
 
-    public boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException {
-        boolean status = false;
-        Connection conn = null;
-        PreparedStatement stmt = null;
-        try {
-            conn = deviceTypeDAOHandler.getConnection();
-            stmt = conn.prepareStatement(deleteDBQueryToRemoveDevicd);
-            stmt.setString(1, deviceId);
-            int rows = stmt.executeUpdate();
-            if (rows > 0) {
-                status = true;
-                if (log.isDebugEnabled()) {
-                    log.debug("device " + deviceId + " data has deleted from the " +
-                            deviceDAODefinition.getDeviceTableName() + " table.");
-                }
-            }
-        } catch (SQLException e) {
-            String msg =
-                    "Error occurred while deleting " + deviceDAODefinition.getDeviceTableName() + " device " + deviceId;
-            log.error(msg, e);
-            throw new DeviceTypeMgtPluginException(msg, e);
-        } finally {
-            DeviceTypeUtils.cleanupResources(stmt, null);
-        }
-        return status;
-    }
-
     public List<Device> getAllDevices() throws DeviceTypeMgtPluginException {
         Connection conn;
         PreparedStatement stmt = null;
@@ -264,10 +236,6 @@ public class DeviceTypePluginDAOImpl implements PluginDAO {
         updateDBQueryForUpdateDevice = "UPDATE " + deviceDAODefinition.getDeviceTableName() + " SET "
                 + getDeviceTableColumnNamesForUpdateQuery() + " WHERE " + deviceDAODefinition.getPrimaryKey() + " = ?";
 
-        deleteDBQueryToRemoveDevicd =
-                "DELETE FROM " + deviceDAODefinition.getDeviceTableName() + " WHERE " + deviceDAODefinition
-                        .getPrimaryKey() + " = ?";
-
         selectDBQueryToGetAllDevice =
                 "SELECT " + getDeviceTableColumnNames() + "," + deviceDAODefinition.getPrimaryKey() + " FROM "
                         + deviceDAODefinition.getDeviceTableName();

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/PluginDAO.java

@@ -30,7 +30,5 @@ public interface PluginDAO {
 
     boolean updateDevice(Device device) throws DeviceTypeMgtPluginException;
 
-    boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException;
-
     List<Device> getAllDevices() throws DeviceTypeMgtPluginException;
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/dao/PropertyBasedPluginDAOImpl.java

@@ -158,36 +158,6 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
         }
     }
 
-    public boolean deleteDevice(String deviceId) throws DeviceTypeMgtPluginException {
-        boolean status = false;
-        Connection conn = null;
-        PreparedStatement stmt = null;
-        try {
-            conn = deviceTypeDAOHandler.getConnection();
-            stmt = conn.prepareStatement("DELETE FROM DM_DEVICE_PROPERTIES WHERE DEVICE_TYPE_NAME = ? " +
-                                                 "AND DEVICE_IDENTIFICATION = ? AND TENANT_ID = ?");
-            stmt.setString(1, deviceType);
-            stmt.setString(2, deviceId);
-            stmt.setInt(3, PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(true));
-            int rows = stmt.executeUpdate();
-            if (rows > 0) {
-                status = true;
-                if (log.isDebugEnabled()) {
-                    log.debug("device " + deviceId + " data has deleted from the " +
-                                      deviceType + " table.");
-                }
-            }
-        } catch (SQLException e) {
-            String msg =
-                    "Error occurred while deleting " + deviceType + " device " + deviceId;
-            log.error(msg, e);
-            throw new DeviceTypeMgtPluginException(msg, e);
-        } finally {
-            DeviceTypeUtils.cleanupResources(stmt, null);
-        }
-        return status;
-    }
-
     public List<Device> getAllDevices() throws DeviceTypeMgtPluginException {
         Connection conn;
         PreparedStatement stmt = null;
@@ -220,7 +190,7 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
                 log.debug(
                         "All device details have fetched from " + deviceType + " table.");
             }
-            return Arrays.asList((Device[])deviceMap.values().toArray());
+            return new ArrayList<>(deviceMap.values());
         } catch (SQLException e) {
             String msg =
                     "Error occurred while fetching all " + deviceType + " device data'";

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/java/org/wso2/carbon/device/mgt/extensions/device/type/template/DeviceTypeManagerServiceTest.java

@@ -305,12 +305,12 @@ public class DeviceTypeManagerServiceTest {
             DeviceTypeConfigurationException, JAXBException {
         ClassLoader classLoader = getClass().getClassLoader();
         URL resourceUrl = classLoader.getResource("arduino.xml");
-        File raspberrypiConfiguration = null;
+        File arduinoConfiguration = null;
         if (resourceUrl != null) {
-            raspberrypiConfiguration = new File(resourceUrl.getFile());
+            arduinoConfiguration = new File(resourceUrl.getFile());
         }
-        arduinoDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(raspberrypiConfiguration);
+        arduinoDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(arduinoConfiguration);
-        arduinoDeviceTypeManagerService = new DeviceTypeManagerService(new
+        arduinoDeviceTypeManagerService = new DeviceTypeManagerService(
-                DeviceTypeConfigIdentifier("arduino", "carbon.super"), arduinoDeviceTypeConfiguration);
+                new DeviceTypeConfigIdentifier("arduino", "carbon.super"), arduinoDeviceTypeConfiguration);
     }
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/java/org/wso2/carbon/device/mgt/extensions/device/type/template/DeviceTypeManagerTest.java

@@ -26,12 +26,16 @@ import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceDetails;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Properties;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceDAODefinition;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypeDAOHandler;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOImpl;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOManager;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.PluginDAO;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.PropertyBasedPluginDAOImpl;
 import org.wso2.carbon.device.mgt.extensions.utils.Utils;
 import org.wso2.carbon.registry.core.exceptions.RegistryException;
 import org.xml.sax.SAXException;
@@ -47,17 +51,26 @@ import java.net.URL;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
- * This class tests the {@link DeviceTypeManager}
+ * This class tests the {@link DeviceTypeManager}.
  */
 public class DeviceTypeManagerTest {
     private DeviceTypeManager androidDeviceTypeManager;
+    private DeviceTypeManager customDeviceTypeManager;
     private DeviceIdentifier nonExistingDeviceIdentifier;
     private Device sampleDevice1;
     private Device sampleDevice2;
+    private Device customDevice;
     private String androidDeviceType;
+    private String customDeviceType = "customDeviceType";
+    private Field datasourceField;
+    private Field currentConnection;
+    private Field deviceTypePluginDAOField;
+    private Field deviceTypeDAOHandlerField;
+    private String[] customDeviceTypeProperties = {"custom_property", "custom_property2"};
 
     @BeforeTest(description = "Mocking the classes for testing")
     public void setup() throws NoSuchFieldException, IllegalAccessException, IOException, SQLException, SAXException,
@@ -67,26 +80,33 @@ public class DeviceTypeManagerTest {
         androidDeviceType = "android";
         File androidDatabaseScript = null;
         javax.sql.DataSource dataSource = null;
-        File carbonHome = new File("src/test/resources/carbon-home");
+        File androidConfiguration = null;
 
         if (resourceUrl != null) {
             androidDatabaseScript = new File(resourceUrl.getFile());
         }
-        if (carbonHome.exists()) {
-            System.setProperty("carbon.home", carbonHome.getAbsolutePath());
-        }
         resourceUrl = classLoader.getResource("android.xml");
-        File androidConfiguration = null;
+
         if (resourceUrl != null) {
             androidConfiguration = new File(resourceUrl.getFile());
         }
+        datasourceField = DeviceTypeDAOHandler.class.getDeclaredField("dataSource");
+        datasourceField.setAccessible(true);
+        currentConnection = DeviceTypeDAOHandler.class.getDeclaredField("currentConnection");
+        currentConnection.setAccessible(true);
+        deviceTypePluginDAOField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypePluginDAO");
+        deviceTypePluginDAOField.setAccessible(true);
+        deviceTypeDAOHandlerField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypeDAOHandler");
+        deviceTypeDAOHandlerField.setAccessible(true);
+
         DeviceTypeConfiguration androidDeviceConfiguration = Utils.getDeviceTypeConfiguration(androidConfiguration);
         androidDeviceTypeManager = Mockito.mock(DeviceTypeManager.class, Mockito.CALLS_REAL_METHODS);
+        customDeviceTypeManager = Mockito.mock(DeviceTypeManager.class, Mockito.CALLS_REAL_METHODS);
 
         if (androidDatabaseScript != null) {
-            dataSource = Utils.createDataTables("deviceType", androidDatabaseScript.getAbsolutePath());
+            dataSource = Utils.createDataTables("customDeviceType", androidDatabaseScript.getAbsolutePath());
         }
-        DeviceTypePluginDAOManager deviceTypePluginDAOManager = createMockDeviceTypePluginDAOManager(dataSource,
+        DeviceTypePluginDAOManager deviceTypePluginDAOManager = createandroidDeviceTypePluginDAOManager(dataSource,
                 androidDeviceConfiguration);
         Field deviceTypePluginDAOManagerField = DeviceTypeManager.class.getDeclaredField("deviceTypePluginDAOManager");
         deviceTypePluginDAOManagerField.setAccessible(true);
@@ -96,9 +116,16 @@ public class DeviceTypeManagerTest {
         propertiesExist.setAccessible(true);
         Field deviceType = DeviceTypeManager.class.getDeclaredField("deviceType");
         deviceType.setAccessible(true);
+
         deviceType.set(androidDeviceTypeManager, androidDeviceType);
         propertiesExist.set(androidDeviceTypeManager, true);
-        createDevice();
+        createAndroidDevice();
+
+        DeviceTypePluginDAOManager propertyBasedPluginDAOManager = createPluginBasedDeviceTypeManager();
+        deviceTypePluginDAOManagerField.set(customDeviceTypeManager, propertyBasedPluginDAOManager);
+        deviceType.set(customDeviceTypeManager, customDeviceType);
+        propertiesExist.set(customDeviceTypeManager, true);
+        createCustomDevice();
     }
 
     @Test(description = "This test case tests IsEnrolled method of the DeviceTypeManager",
@@ -106,10 +133,17 @@ public class DeviceTypeManagerTest {
     public void testIsEnrolled() throws DeviceManagementException {
         DeviceIdentifier deviceIdentifier = new DeviceIdentifier(sampleDevice2.getDeviceIdentifier(),
                 sampleDevice2.getType());
-        Assert.assertTrue(!androidDeviceTypeManager.isEnrolled(nonExistingDeviceIdentifier),
+        DeviceIdentifier nonExistingCustomDeviceIdentifier = new DeviceIdentifier(sampleDevice2.getDeviceIdentifier(),
-                "Device with " + "NON-Existing ID is not enrolled, but this shows as enrolled");
+                customDevice.getType());
+
+        Assert.assertFalse(androidDeviceTypeManager.isEnrolled(nonExistingDeviceIdentifier),
+                "Device with NON-Existing ID is not enrolled, but this shows as enrolled");
         Assert.assertTrue(androidDeviceTypeManager.isEnrolled(deviceIdentifier),
                 "Enrolled device is shown as un-enrolled");
+        Assert.assertFalse(customDeviceTypeManager.isEnrolled(nonExistingCustomDeviceIdentifier),
+                "Custom device type manager returns an non-existing device as enrolled");
+        Assert.assertTrue(customDeviceTypeManager.isEnrolled(new DeviceIdentifier(customDeviceType, customDeviceType))
+                , "Enrolled device is shown as un-enrolled in custom device type manager");
     }
 
     @Test(description = "This test case tests the getDevcie method of the DeviceTypeManager", dependsOnMethods =
@@ -120,20 +154,37 @@ public class DeviceTypeManagerTest {
         Assert.assertNull(androidDeviceTypeManager.getDevice(nonExistingDeviceIdentifier),
                 "Non existing sampleDevice was retrieved");
         Assert.assertNotNull(androidDeviceTypeManager.getDevice(existingDeviceIdntifier),
-                "Existing sampleDevice was retrieved");
+                "Existing sampleDevice was not retrieved");
+        Device customDevice1 = customDeviceTypeManager
+                .getDevice(new DeviceIdentifier(customDeviceType, customDeviceType));
+        Assert.assertEquals(customDevice1.getProperties().size(), 2,
+                "GetDevice call" + " failed in custom deviceTypeManager");
     }
 
     @Test(description = "This test case tests the enrollment of the device")
     public void testEnrollDevice() throws DeviceManagementException {
-        Assert.assertTrue(androidDeviceTypeManager.enrollDevice(sampleDevice1));
+        Assert.assertTrue(androidDeviceTypeManager.enrollDevice(sampleDevice1), "New android device enrollment failed");
-        Assert.assertTrue(!androidDeviceTypeManager.enrollDevice(sampleDevice2));
+        Assert.assertFalse(androidDeviceTypeManager.enrollDevice(sampleDevice2),
+                "Modification to existing android " + "device enrollment failed");
+        Assert.assertTrue(customDeviceTypeManager.enrollDevice(customDevice), "Custom device type enrollment failed.");
+        List<Device.Property> properties = customDevice.getProperties();
+        Device.Property property = new Device.Property();
+        property.setName("test");
+        property.setValue("test");
+        properties.add(property);
+        customDevice.setProperties(properties);
+        Assert.assertFalse(customDeviceTypeManager.enrollDevice(customDevice),
+                "Custom device type re-enrollment " + "failed.");
+
     }
 
     @Test(description = "This test case tests the get all devices method of the DeviceTypeManager", dependsOnMethods
             = {"testEnrollDevice"})
     public void testGetAllDevices() throws DeviceManagementException {
         Assert.assertEquals(androidDeviceTypeManager.getAllDevices().size(), 1,
-                "All the added devices are not fetched " + "from the database");
+                "All the added devices are not fetched from the database");
+        Assert.assertEquals(customDeviceTypeManager.getAllDevices().size(), 1,
+                "All the added devices are not fetched from the database");
     }
 
     @Test(description = "This test case tests the addition of platform configuration and retrieval of the same")
@@ -147,6 +198,7 @@ public class DeviceTypeManagerTest {
                 "Platform Configuration saved and retrieved correctly in " + "DeviceType Manager");
         Assert.assertEquals(actualPlatformConfiguration.getType(), androidDeviceType,
                 "Platform Configuration saved and " + "retrieved correctly in DeviceType Manager");
+        Assert.assertNull(customDeviceTypeManager.getConfiguration());
     }
 
     @Test (description = "This test case tests the getDefaultConfiguration method")
@@ -169,9 +221,9 @@ public class DeviceTypeManagerTest {
     }
 
     /**
-     * To create a sample sampleDevice to add to DAO Layer.
+     * To create sample android devices to add to DAO Layer.
      */
-    private void createDevice() {
+    private void createAndroidDevice() {
         nonExistingDeviceIdentifier = new DeviceIdentifier("NON-EXISTING", androidDeviceType);
         List<Device.Property> list = new ArrayList<>();
 
@@ -190,6 +242,21 @@ public class DeviceTypeManagerTest {
         sampleDevice2 = new Device("testdevice1", androidDeviceType, "test", "testdevice", null, null, list);
     }
 
+    /**
+     * To create a sample custom device.
+     */
+    private void createCustomDevice () {
+        List<Device.Property> list = new ArrayList<>();
+        for(String customProperty : customDeviceTypeProperties) {
+            Device.Property property = new Device.Property();
+            property.setName(customProperty);
+            property.setValue(customProperty);
+            list.add(property);
+        }
+        customDevice = new Device(customDeviceType, customDeviceType, customDeviceType, customDeviceType, null,
+                null, list);
+    }
+
     /*
      * To create a mock sampleDevice type plugin dao manager.
      * @param dataSource DataSource for the DAO layer
@@ -198,13 +265,8 @@ public class DeviceTypeManagerTest {
      * @throws NoSuchFieldException No Such Field Exception
      * @throws IllegalAccessException Illegal Access Exception
      */
-    private DeviceTypePluginDAOManager createMockDeviceTypePluginDAOManager(javax.sql.DataSource dataSource,
+    private DeviceTypePluginDAOManager createandroidDeviceTypePluginDAOManager(javax.sql.DataSource dataSource,
             DeviceTypeConfiguration androidDeviceConfiguration) throws NoSuchFieldException, IllegalAccessException {
-        Field datasourceField = DeviceTypeDAOHandler.class.getDeclaredField("dataSource");
-        datasourceField.setAccessible(true);
-        Field currentConnection = DeviceTypeDAOHandler.class.getDeclaredField("currentConnection");
-        currentConnection.setAccessible(true);
-
         DeviceTypeDAOHandler deviceTypeDAOHandler = Mockito
                 .mock(DeviceTypeDAOHandler.class, Mockito.CALLS_REAL_METHODS);
         datasourceField.set(deviceTypeDAOHandler, dataSource);
@@ -213,13 +275,52 @@ public class DeviceTypeManagerTest {
         DeviceDAODefinition deviceDAODefinition = Utils.getDeviceDAODefinition(androidDeviceConfiguration);
         DeviceTypePluginDAOImpl deviceTypePluginDAO = new DeviceTypePluginDAOImpl(deviceDAODefinition,
                 deviceTypeDAOHandler);
+        DeviceTypePluginDAOManager deviceTypePluginDAOManager = Mockito
+                .mock(DeviceTypePluginDAOManager.class, Mockito.CALLS_REAL_METHODS);
+        deviceTypePluginDAOField.set(deviceTypePluginDAOManager, deviceTypePluginDAO);
+        deviceTypeDAOHandlerField.set(deviceTypePluginDAOManager, deviceTypeDAOHandler);
+
+        return deviceTypePluginDAOManager;
+    }
+
+    /**
+     * To create a plugin based device type manager.
+     *
+     * @return Plugin based device type manager.
+     * @throws IOException            IO Exception.
+     * @throws SQLException           SQL Exception
+     * @throws NoSuchFieldException   No Such File Exception.
+     * @throws IllegalAccessException Illegal Access Exception.
+     */
+    private DeviceTypePluginDAOManager createPluginBasedDeviceTypeManager()
+            throws IOException, SQLException, NoSuchFieldException, IllegalAccessException {
+        ClassLoader classLoader = getClass().getClassLoader();
+        URL resourceUrl = classLoader.getResource("h2.sql");
+        File cdmDataScript = null;
+        javax.sql.DataSource dataSource = null;
+        if (resourceUrl != null) {
+            cdmDataScript = new File(resourceUrl.getFile());
+        }
+        if (cdmDataScript != null) {
+            dataSource = Utils.createDataTables(customDeviceType, cdmDataScript.getAbsolutePath());
+        }
+
+        DeviceDetails deviceDetails = new DeviceDetails();
+        List<String> propertyList = new ArrayList<>();
+        propertyList.addAll(Arrays.asList(customDeviceTypeProperties));
+        Properties properties = new Properties();
+        properties.addProperties(propertyList);
+        deviceDetails.setProperties(properties);
+
+        DeviceTypeDAOHandler deviceTypeDAOHandler = Mockito
+                .mock(DeviceTypeDAOHandler.class, Mockito.CALLS_REAL_METHODS);
+        datasourceField.set(deviceTypeDAOHandler, dataSource);
+        currentConnection.set(deviceTypeDAOHandler, new ThreadLocal<Connection>());
+        PluginDAO deviceTypePluginDAO = new PropertyBasedPluginDAOImpl(deviceDetails, deviceTypeDAOHandler,
+                customDeviceType);
 
         DeviceTypePluginDAOManager deviceTypePluginDAOManager = Mockito
                 .mock(DeviceTypePluginDAOManager.class, Mockito.CALLS_REAL_METHODS);
-        Field deviceTypePluginDAOField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypePluginDAO");
-        deviceTypePluginDAOField.setAccessible(true);
-        Field deviceTypeDAOHandlerField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypeDAOHandler");
-        deviceTypeDAOHandlerField.setAccessible(true);
         deviceTypePluginDAOField.set(deviceTypePluginDAOManager, deviceTypePluginDAO);
         deviceTypeDAOHandlerField.set(deviceTypePluginDAOManager, deviceTypeDAOHandler);
 

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/java/org/wso2/carbon/device/mgt/extensions/device/type/template/HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest.java

@@ -21,34 +21,19 @@ package org.wso2.carbon.device.mgt.extensions.device.type.template;
 import org.testng.Assert;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
-import org.wso2.carbon.CarbonConstants;
-import org.wso2.carbon.base.MultitenantConstants;
-import org.wso2.carbon.context.PrivilegedCarbonContext;
-import org.wso2.carbon.context.RegistryType;
-import org.wso2.carbon.context.internal.OSGiDataHolder;
 import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
-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.push.notification.PushNotificationConfig;
 import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
 import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeMetaDefinition;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Feature;
-import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Operation;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.PushNotificationProvider;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
-import org.wso2.carbon.device.mgt.extensions.internal.DeviceTypeExtensionDataHolder;
-import org.wso2.carbon.device.mgt.extensions.license.mgt.registry.RegistryBasedLicenseManager;
 import org.wso2.carbon.device.mgt.extensions.utils.Utils;
-import org.wso2.carbon.governance.api.util.GovernanceArtifactConfiguration;
-import org.wso2.carbon.governance.api.util.GovernanceUtils;
-import org.wso2.carbon.registry.core.Registry;
 import org.wso2.carbon.registry.core.exceptions.RegistryException;
-import org.wso2.carbon.registry.core.service.RegistryService;
-import org.wso2.carbon.registry.core.session.UserRegistry;
-import org.wso2.carbon.utils.FileUtil;
 import org.xml.sax.SAXException;
 
 import javax.xml.bind.JAXBException;
@@ -59,8 +44,6 @@ import java.net.URL;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.wso2.carbon.governance.api.util.GovernanceUtils.getGovernanceArtifactConfiguration;
-
 /**
  * This test case contains the tests for {@link HTTPDeviceTypeManagerService} and {@link DeviceTypeGeneratorServiceImpl}
  */
@@ -69,7 +52,6 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
     private HTTPDeviceTypeManagerService httpDeviceTypeManagerService;
     private DeviceTypeGeneratorServiceImpl deviceTypeGeneratorService;
     private String androidSenseDeviceType = "androidsense";
-    private String sampleDeviceType = "sample";
 
     @BeforeTest
     public void setup() throws RegistryException, IOException, SAXException, ParserConfigurationException,
@@ -100,12 +82,38 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
 
     @Test(description = "This test case tests the populate device management service method")
     public void testPopulateDeviceManagementService() {
+        String sampleDeviceType = "sample";
         DeviceManagementService deviceManagementService = deviceTypeGeneratorService
                 .populateDeviceManagementService(sampleDeviceType, deviceTypeMetaDefinition);
         Assert.assertEquals(deviceManagementService.getType(), sampleDeviceType,
                 "DeviceTypeGeneration for the " + "sample device type failed");
     }
 
+
+    @Test(description = "This test case tests the negative scenarios when saving the platform configurations",
+            expectedExceptions = {DeviceManagementException.class})
+    public void testSaveConfiguration() throws DeviceManagementException {
+        httpDeviceTypeManagerService.getDeviceManager().saveConfiguration(null);
+    }
+
+    @Test(description = "This test case tests the negative scenarios when getting a device",
+            expectedExceptions = {DeviceManagementException.class})
+    public void testGetDevice() throws DeviceManagementException {
+        httpDeviceTypeManagerService.getDeviceManager().getDevice(null);
+    }
+
+    @Test(description = "This test case tests the negative scenario when checking whether a device has enrolled",
+            expectedExceptions = {DeviceManagementException.class})
+    public void testIsEnrolled() throws DeviceManagementException {
+        httpDeviceTypeManagerService.getDeviceManager().isEnrolled(null);
+    }
+
+    @Test(description = "This test case tests the negative scenario when enrolling a device",
+            expectedExceptions = {DeviceManagementException.class})
+    public void testEnroll() throws DeviceManagementException {
+        httpDeviceTypeManagerService.getDeviceManager().enrollDevice(null);
+    }
+
     /**
      * To create a sample device type meta defintion.
      * @throws SAXException SAX Exception.

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/resources/h2.sql

@@ -0,0 +1,531 @@
+CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
+     ID INT AUTO_INCREMENT NOT NULL,
+     NAME VARCHAR(300) NULL DEFAULT NULL,
+     DEVICE_TYPE_META VARCHAR(20000) NULL DEFAULT NULL,
+     LAST_UPDATED_TIMESTAMP TIMESTAMP NOT NULL,
+     PROVIDER_TENANT_ID INTEGER DEFAULT 0,
+     SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
+     PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_GROUP (
+  ID                  INTEGER AUTO_INCREMENT NOT NULL,
+  GROUP_NAME          VARCHAR(100) DEFAULT NULL,
+  DESCRIPTION         TEXT         DEFAULT NULL,
+  OWNER               VARCHAR(45)  DEFAULT NULL,
+  TENANT_ID           INTEGER      DEFAULT 0,
+  PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_ROLE_GROUP_MAP (
+  ID        INTEGER AUTO_INCREMENT NOT NULL,
+  GROUP_ID  INTEGER     DEFAULT NULL,
+  ROLE      VARCHAR(45) DEFAULT NULL,
+  TENANT_ID INTEGER     DEFAULT 0,
+  PRIMARY KEY (ID),
+  CONSTRAINT fk_DM_ROLE_GROUP_MAP_DM_GROUP2 FOREIGN KEY (GROUP_ID)
+  REFERENCES DM_GROUP (ID) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE (
+     ID                    INTEGER auto_increment NOT NULL,
+     DESCRIPTION           TEXT DEFAULT NULL,
+     NAME                  VARCHAR(100) DEFAULT NULL,
+     DEVICE_TYPE_ID        INT(11) DEFAULT NULL,
+     DEVICE_IDENTIFICATION VARCHAR(300) DEFAULT NULL,
+     LAST_UPDATED_TIMESTAMP TIMESTAMP NOT NULL,
+     TENANT_ID INTEGER DEFAULT 0,
+     PRIMARY KEY (ID),
+     CONSTRAINT fk_DM_DEVICE_DM_DEVICE_TYPE2 FOREIGN KEY (DEVICE_TYPE_ID)
+     REFERENCES DM_DEVICE_TYPE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+     CONSTRAINT uk_DM_DEVICE UNIQUE (NAME, DEVICE_TYPE_ID, DEVICE_IDENTIFICATION, TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_PROPERTIES (
+     DEVICE_TYPE_NAME VARCHAR(300) NOT NULL,
+     DEVICE_IDENTIFICATION VARCHAR(300) NOT NULL,
+     PROPERTY_NAME VARCHAR(100) DEFAULT 0,
+     PROPERTY_VALUE VARCHAR(100) DEFAULT NULL,
+     TENANT_ID VARCHAR(100),
+     PRIMARY KEY (DEVICE_TYPE_NAME, DEVICE_IDENTIFICATION, PROPERTY_NAME, TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_MAP (
+  ID        INTEGER AUTO_INCREMENT NOT NULL,
+  DEVICE_ID INTEGER DEFAULT NULL,
+  GROUP_ID  INTEGER DEFAULT NULL,
+  TENANT_ID INTEGER DEFAULT 0,
+  PRIMARY KEY (ID),
+  CONSTRAINT fk_DM_DEVICE_GROUP_MAP_DM_DEVICE2 FOREIGN KEY (DEVICE_ID)
+  REFERENCES DM_DEVICE (ID) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT fk_DM_DEVICE_GROUP_MAP_DM_GROUP2 FOREIGN KEY (GROUP_ID)
+  REFERENCES DM_GROUP (ID) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS DM_OPERATION (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    TYPE VARCHAR(50) NOT NULL,
+    CREATED_TIMESTAMP TIMESTAMP NOT NULL,
+    RECEIVED_TIMESTAMP TIMESTAMP NULL,
+    OPERATION_CODE VARCHAR(1000) NOT NULL,
+    PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_CONFIG_OPERATION (
+    OPERATION_ID INTEGER NOT NULL,
+    OPERATION_CONFIG  BLOB DEFAULT NULL,
+    ENABLED BOOLEAN NOT NULL DEFAULT FALSE,
+    PRIMARY KEY (OPERATION_ID),
+    CONSTRAINT fk_dm_operation_config FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_COMMAND_OPERATION (
+    OPERATION_ID INTEGER NOT NULL,
+    ENABLED BOOLEAN NOT NULL DEFAULT FALSE,
+    PRIMARY KEY (OPERATION_ID),
+    CONSTRAINT fk_dm_operation_command FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_OPERATION (
+    OPERATION_ID INTEGER NOT NULL,
+    ENABLED INTEGER NOT NULL DEFAULT 0,
+    OPERATION_DETAILS BLOB DEFAULT NULL,
+    PRIMARY KEY (OPERATION_ID),
+    CONSTRAINT fk_dm_operation_policy FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_PROFILE_OPERATION (
+    OPERATION_ID INTEGER NOT NULL,
+    ENABLED INTEGER NOT NULL DEFAULT 0,
+    OPERATION_DETAILS BLOB DEFAULT NULL,
+    PRIMARY KEY (OPERATION_ID),
+    CONSTRAINT fk_dm_operation_profile FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    DEVICE_ID INTEGER NOT NULL,
+    OWNER VARCHAR(50) NOT NULL,
+    OWNERSHIP VARCHAR(45) DEFAULT NULL,
+    STATUS VARCHAR(50) NULL,
+    DATE_OF_ENROLMENT TIMESTAMP DEFAULT NULL,
+    DATE_OF_LAST_UPDATE TIMESTAMP DEFAULT NULL,
+    TENANT_ID INT NOT NULL,
+    PRIMARY KEY (ID),
+    CONSTRAINT fk_dm_device_enrolment FOREIGN KEY (DEVICE_ID) REFERENCES
+    DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT uk_dm_device_enrolment UNIQUE (DEVICE_ID, OWNER, OWNERSHIP, TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_ENROLMENT_OP_MAPPING (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    ENROLMENT_ID INTEGER NOT NULL,
+    OPERATION_ID INTEGER NOT NULL,
+    STATUS VARCHAR(50) NULL,
+    PUSH_NOTIFICATION_STATUS VARCHAR(50) NULL,
+    CREATED_TIMESTAMP INT NOT NULL,
+    UPDATED_TIMESTAMP INT NOT NULL,
+    PRIMARY KEY (ID),
+    CONSTRAINT fk_dm_device_operation_mapping_device FOREIGN KEY (ENROLMENT_ID) REFERENCES
+    DM_ENROLMENT (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT fk_dm_device_operation_mapping_operation FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_OPERATION_RESPONSE (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    ENROLMENT_ID INTEGER NOT NULL,
+    OPERATION_ID INTEGER NOT NULL,
+    EN_OP_MAP_ID  INTEGER NOT NULL,
+    OPERATION_RESPONSE LONGBLOB DEFAULT NULL,
+    RECEIVED_TIMESTAMP TIMESTAMP NULL,
+    PRIMARY KEY (ID),
+    CONSTRAINT fk_dm_device_operation_response_enrollment FOREIGN KEY (ENROLMENT_ID) REFERENCES
+    DM_ENROLMENT (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT fk_dm_device_operation_response_operation FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT  fk_dm_en_op_map_response FOREIGN KEY (EN_OP_MAP_ID) REFERENCES
+    DM_ENROLMENT_OP_MAPPING (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+-- POLICY RELATED TABLES --
+
+CREATE  TABLE IF NOT EXISTS DM_PROFILE (
+  ID INT NOT NULL AUTO_INCREMENT ,
+  PROFILE_NAME VARCHAR(45) NOT NULL ,
+  TENANT_ID INT NOT NULL ,
+  DEVICE_TYPE VARCHAR(300) NOT NULL ,
+  CREATED_TIME DATETIME NOT NULL ,
+  UPDATED_TIME DATETIME NOT NULL ,
+  PRIMARY KEY (ID)
+);
+
+CREATE  TABLE IF NOT EXISTS DM_POLICY (
+  ID INT(11) NOT NULL AUTO_INCREMENT ,
+  NAME VARCHAR(45) DEFAULT NULL ,
+  DESCRIPTION VARCHAR(1000) NULL,
+  TENANT_ID INT(11) NOT NULL ,
+  PROFILE_ID INT(11) NOT NULL ,
+  OWNERSHIP_TYPE VARCHAR(45) NULL,
+  COMPLIANCE VARCHAR(100) NULL,
+  PRIORITY INT NOT NULL,
+  ACTIVE INT(2) NOT NULL,
+  UPDATED INT(1) NULL,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT FK_DM_PROFILE_DM_POLICY
+    FOREIGN KEY (PROFILE_ID )
+    REFERENCES DM_PROFILE (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_DEVICE_POLICY (
+  ID INT(11) NOT NULL AUTO_INCREMENT ,
+  DEVICE_ID INT(11) NOT NULL ,
+  ENROLMENT_ID INT(11) NOT NULL,
+  DEVICE BLOB NOT NULL,
+  POLICY_ID INT(11) NOT NULL ,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT FK_POLICY_DEVICE_POLICY
+    FOREIGN KEY (POLICY_ID )
+    REFERENCES DM_POLICY (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION,
+  CONSTRAINT FK_DEVICE_DEVICE_POLICY
+    FOREIGN KEY (DEVICE_ID )
+    REFERENCES DM_DEVICE (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_DEVICE_TYPE_POLICY (
+  ID INT(11) NOT NULL ,
+  DEVICE_TYPE VARCHAR(300) NOT NULL ,
+  POLICY_ID INT(11) NOT NULL ,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT FK_DEVICE_TYPE_POLICY
+    FOREIGN KEY (POLICY_ID )
+    REFERENCES DM_POLICY (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_PROFILE_FEATURES (
+  ID INT(11) NOT NULL AUTO_INCREMENT,
+  PROFILE_ID INT(11) NOT NULL,
+  FEATURE_CODE VARCHAR(100) NOT NULL,
+  DEVICE_TYPE VARCHAR(300) NOT NULL,
+  TENANT_ID INT(11) NOT NULL ,
+  CONTENT BLOB NULL DEFAULT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_DM_PROFILE_DM_POLICY_FEATURES
+    FOREIGN KEY (PROFILE_ID)
+    REFERENCES DM_PROFILE (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_ROLE_POLICY (
+  ID INT(11) NOT NULL AUTO_INCREMENT ,
+  ROLE_NAME VARCHAR(45) NOT NULL ,
+  POLICY_ID INT(11) NOT NULL ,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT FK_ROLE_POLICY_POLICY
+    FOREIGN KEY (POLICY_ID )
+    REFERENCES DM_POLICY (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_USER_POLICY (
+  ID INT NOT NULL AUTO_INCREMENT ,
+  POLICY_ID INT NOT NULL ,
+  USERNAME VARCHAR(45) NOT NULL ,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT DM_POLICY_USER_POLICY
+    FOREIGN KEY (POLICY_ID )
+    REFERENCES DM_POLICY (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE  TABLE IF NOT EXISTS DM_DEVICE_POLICY_APPLIED (
+  ID INT NOT NULL AUTO_INCREMENT ,
+  DEVICE_ID INT NOT NULL ,
+  ENROLMENT_ID INT(11) NOT NULL,
+  POLICY_ID INT NOT NULL ,
+  POLICY_CONTENT BLOB NULL ,
+  TENANT_ID INT NOT NULL,
+  APPLIED TINYINT(1) NULL ,
+  CREATED_TIME TIMESTAMP NULL ,
+  UPDATED_TIME TIMESTAMP NULL ,
+  APPLIED_TIME TIMESTAMP NULL ,
+  PRIMARY KEY (ID) ,
+  CONSTRAINT FK_DM_POLICY_DEVCIE_APPLIED
+    FOREIGN KEY (DEVICE_ID )
+    REFERENCES DM_DEVICE (ID )
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_CRITERIA (
+  ID INT NOT NULL AUTO_INCREMENT,
+  TENANT_ID INT NOT NULL,
+  NAME VARCHAR(50) NULL,
+  PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA (
+  ID INT NOT NULL AUTO_INCREMENT,
+  CRITERIA_ID INT NOT NULL,
+  POLICY_ID INT NOT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_CRITERIA_POLICY_CRITERIA
+    FOREIGN KEY (CRITERIA_ID)
+    REFERENCES DM_CRITERIA (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION,
+  CONSTRAINT FK_POLICY_POLICY_CRITERIA
+    FOREIGN KEY (POLICY_ID)
+    REFERENCES DM_POLICY (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA_PROPERTIES (
+  ID INT NOT NULL AUTO_INCREMENT,
+  POLICY_CRITERION_ID INT NOT NULL,
+  PROP_KEY VARCHAR(45) NULL,
+  PROP_VALUE VARCHAR(100) NULL,
+  CONTENT BLOB NULL COMMENT 'This is used to ',
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_POLICY_CRITERIA_PROPERTIES
+    FOREIGN KEY (POLICY_CRITERION_ID)
+    REFERENCES DM_POLICY_CRITERIA (ID)
+    ON DELETE CASCADE
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_STATUS (
+  ID INT NOT NULL AUTO_INCREMENT,
+  DEVICE_ID INT NOT NULL,
+  ENROLMENT_ID INT(11) NOT NULL,
+  POLICY_ID INT NOT NULL,
+  TENANT_ID INT NOT NULL,
+  STATUS INT NULL,
+  LAST_SUCCESS_TIME TIMESTAMP NULL,
+  LAST_REQUESTED_TIME TIMESTAMP NULL,
+  LAST_FAILED_TIME TIMESTAMP NULL,
+  ATTEMPTS INT NULL,
+  PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_CHANGE_MGT (
+  ID INT NOT NULL AUTO_INCREMENT,
+  POLICY_ID INT NOT NULL,
+  DEVICE_TYPE VARCHAR(300) NOT NULL ,
+  TENANT_ID INT(11) NOT NULL,
+  PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_FEATURES (
+  ID INT NOT NULL AUTO_INCREMENT,
+  COMPLIANCE_STATUS_ID INT NOT NULL,
+  TENANT_ID INT NOT NULL,
+  FEATURE_CODE VARCHAR(100) NOT NULL,
+  STATUS INT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_COMPLIANCE_FEATURES_STATUS
+    FOREIGN KEY (COMPLIANCE_STATUS_ID)
+    REFERENCES DM_POLICY_COMPLIANCE_STATUS (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_APPLICATION (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    NAME VARCHAR(150) NOT NULL,
+    APP_IDENTIFIER VARCHAR(150) NOT NULL,
+    PLATFORM VARCHAR(50) DEFAULT NULL,
+    CATEGORY VARCHAR(50) NULL,
+    VERSION VARCHAR(50) NULL,
+    TYPE VARCHAR(50) NULL,
+    LOCATION_URL VARCHAR(100) DEFAULT NULL,
+    IMAGE_URL VARCHAR(100) DEFAULT NULL,
+    APP_PROPERTIES BLOB NULL,
+    MEMORY_USAGE INTEGER(10) NULL,
+    IS_ACTIVE BOOLEAN NOT NULL DEFAULT FALSE,
+    TENANT_ID INTEGER NOT NULL,
+    PRIMARY KEY (ID)
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_APPLICATION_MAPPING (
+    ID INTEGER AUTO_INCREMENT NOT NULL,
+    DEVICE_ID INTEGER NOT NULL,
+    APPLICATION_ID INTEGER NOT NULL,
+    TENANT_ID INTEGER NOT NULL,
+    PRIMARY KEY (ID),
+    CONSTRAINT fk_dm_device FOREIGN KEY (DEVICE_ID) REFERENCES
+    DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT fk_dm_application FOREIGN KEY (APPLICATION_ID) REFERENCES
+    DM_APPLICATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+
+-- POLICY RELATED TABLES  FINISHED --
+
+-- NOTIFICATION TABLE --
+CREATE TABLE IF NOT EXISTS DM_NOTIFICATION (
+    NOTIFICATION_ID INTEGER AUTO_INCREMENT NOT NULL,
+    DEVICE_ID INTEGER NOT NULL,
+    OPERATION_ID INTEGER NOT NULL,
+    TENANT_ID INTEGER NOT NULL,
+    STATUS VARCHAR(10) NULL,
+    DESCRIPTION VARCHAR(1000) NULL,
+    PRIMARY KEY (NOTIFICATION_ID),
+    CONSTRAINT fk_dm_device_notification FOREIGN KEY (DEVICE_ID) REFERENCES
+    DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
+    CONSTRAINT fk_dm_operation_notification FOREIGN KEY (OPERATION_ID) REFERENCES
+    DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
+);
+-- NOTIFICATION TABLE END --
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_INFO (
+  ID INTEGER AUTO_INCREMENT NOT NULL,
+  DEVICE_ID INT NULL,
+  KEY_FIELD VARCHAR(45) NULL,
+  VALUE_FIELD VARCHAR(100) NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT DM_DEVICE_INFO_DEVICE
+    FOREIGN KEY (DEVICE_ID)
+    REFERENCES DM_DEVICE (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_LOCATION (
+  ID INTEGER AUTO_INCREMENT NOT NULL,
+  DEVICE_ID INT NULL,
+  LATITUDE DOUBLE NULL,
+  LONGITUDE DOUBLE NULL,
+  STREET1 VARCHAR(255) NULL,
+  STREET2 VARCHAR(45) NULL,
+  CITY VARCHAR(45) NULL,
+  ZIP VARCHAR(10) NULL,
+  STATE VARCHAR(45) NULL,
+  COUNTRY VARCHAR(45) NULL,
+  UPDATE_TIMESTAMP BIGINT(15) NOT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT DM_DEVICE_LOCATION_DEVICE
+    FOREIGN KEY (DEVICE_ID)
+    REFERENCES DM_DEVICE (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_DETAIL (
+  ID INT NOT NULL AUTO_INCREMENT,
+  DEVICE_ID INT NOT NULL,
+  DEVICE_MODEL VARCHAR(45) NULL,
+  VENDOR VARCHAR(45) NULL,
+  OS_VERSION VARCHAR(45) NULL,
+  OS_BUILD_DATE VARCHAR(100) NULL,
+  BATTERY_LEVEL DECIMAL(4) NULL,
+  INTERNAL_TOTAL_MEMORY DECIMAL(30,3) NULL,
+  INTERNAL_AVAILABLE_MEMORY DECIMAL(30,3) NULL,
+  EXTERNAL_TOTAL_MEMORY DECIMAL(30,3) NULL,
+  EXTERNAL_AVAILABLE_MEMORY DECIMAL(30,3) NULL,
+  CONNECTION_TYPE VARCHAR(50) NULL,
+  SSID VARCHAR(45) NULL,
+  CPU_USAGE DECIMAL(5) NULL,
+  TOTAL_RAM_MEMORY DECIMAL(30,3) NULL,
+  AVAILABLE_RAM_MEMORY DECIMAL(30,3) NULL,
+  PLUGGED_IN INT(1) NULL,
+  UPDATE_TIMESTAMP BIGINT(15) NOT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_DM_DEVICE_DETAILS_DEVICE
+    FOREIGN KEY (DEVICE_ID)
+    REFERENCES DM_DEVICE (ID)
+    ON DELETE NO ACTION
+    ON UPDATE NO ACTION
+);
+
+-- POLICY AND DEVICE GROUP MAPPING --
+CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_POLICY (
+  ID INT NOT NULL AUTO_INCREMENT,
+  DEVICE_GROUP_ID INT NOT NULL,
+  POLICY_ID INT NOT NULL,
+  TENANT_ID INT NOT NULL,
+  PRIMARY KEY (ID),
+  CONSTRAINT FK_DM_DEVICE_GROUP_POLICY
+    FOREIGN KEY (DEVICE_GROUP_ID)
+    REFERENCES DM_GROUP (ID)
+    ON DELETE CASCADE
+    ON UPDATE CASCADE ,
+  CONSTRAINT FK_DM_DEVICE_GROUP_DM_POLICY
+    FOREIGN KEY (POLICY_ID)
+    REFERENCES DM_POLICY (ID)
+    ON DELETE CASCADE
+    ON UPDATE CASCADE
+);
+-- END OF POLICY AND DEVICE GROUP MAPPING --
+
+-- DASHBOARD RELATED VIEWS --
+CREATE VIEW POLICY_COMPLIANCE_INFO AS
+SELECT
+DEVICE_INFO.DEVICE_ID,
+DEVICE_INFO.DEVICE_IDENTIFICATION,
+DEVICE_INFO.PLATFORM,
+DEVICE_INFO.OWNERSHIP,
+DEVICE_INFO.CONNECTIVITY_STATUS,
+IFNULL(DEVICE_WITH_POLICY_INFO.POLICY_ID, -1) AS POLICY_ID,
+IFNULL(DEVICE_WITH_POLICY_INFO.IS_COMPLIANT, -1) AS IS_COMPLIANT,
+DEVICE_INFO.TENANT_ID
+FROM
+(SELECT
+DM_DEVICE.ID AS DEVICE_ID,
+DM_DEVICE.DEVICE_IDENTIFICATION,
+DM_DEVICE_TYPE.NAME AS PLATFORM,
+DM_ENROLMENT.OWNERSHIP,
+DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
+DM_DEVICE.TENANT_ID
+FROM DM_DEVICE, DM_DEVICE_TYPE, DM_ENROLMENT
+WHERE DM_DEVICE.DEVICE_TYPE_ID = DM_DEVICE_TYPE.ID AND DM_DEVICE.ID = DM_ENROLMENT.DEVICE_ID) DEVICE_INFO
+LEFT JOIN
+(SELECT
+DEVICE_ID,
+POLICY_ID,
+STATUS AS IS_COMPLIANT
+FROM DM_POLICY_COMPLIANCE_STATUS) DEVICE_WITH_POLICY_INFO
+ON DEVICE_INFO.DEVICE_ID = DEVICE_WITH_POLICY_INFO.DEVICE_ID
+ORDER BY DEVICE_INFO.DEVICE_ID;
+
+CREATE VIEW FEATURE_NON_COMPLIANCE_INFO AS
+SELECT
+DM_DEVICE.ID AS DEVICE_ID,
+DM_DEVICE.DEVICE_IDENTIFICATION,
+DM_DEVICE_DETAIL.DEVICE_MODEL,
+DM_DEVICE_DETAIL.VENDOR,
+DM_DEVICE_DETAIL.OS_VERSION,
+DM_ENROLMENT.OWNERSHIP,
+DM_ENROLMENT.OWNER,
+DM_ENROLMENT.STATUS AS CONNECTIVITY_STATUS,
+DM_POLICY_COMPLIANCE_STATUS.POLICY_ID,
+DM_DEVICE_TYPE.NAME AS PLATFORM,
+DM_POLICY_COMPLIANCE_FEATURES.FEATURE_CODE,
+DM_POLICY_COMPLIANCE_FEATURES.STATUS AS IS_COMPLAINT,
+DM_DEVICE.TENANT_ID
+FROM
+DM_POLICY_COMPLIANCE_FEATURES, DM_POLICY_COMPLIANCE_STATUS, DM_ENROLMENT, DM_DEVICE, DM_DEVICE_TYPE, DM_DEVICE_DETAIL
+WHERE
+DM_POLICY_COMPLIANCE_FEATURES.COMPLIANCE_STATUS_ID = DM_POLICY_COMPLIANCE_STATUS.ID AND
+DM_POLICY_COMPLIANCE_STATUS.ENROLMENT_ID = DM_ENROLMENT.ID AND
+DM_POLICY_COMPLIANCE_STATUS.DEVICE_ID = DM_DEVICE.ID AND
+DM_DEVICE.DEVICE_TYPE_ID = DM_DEVICE_TYPE.ID AND
+DM_DEVICE.ID = DM_DEVICE_DETAIL.DEVICE_ID
+ORDER BY TENANT_ID, DEVICE_ID;
+
+-- END OF DASHBOARD RELATED VIEWS --