Merge branch 'master' of https://github.com/wso2/carbon-device-mgt into add-emm-analytics

components/apimgt-extensions/org.wso2.carbon.apimgt.annotations/pom.xml

@@ -22,13 +22,13 @@
     <parent>
         <artifactId>apimgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.apimgt.annotations</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - API Management Annotations</name>
     <description>WSO2 Carbon - API Management Custom Annotation Module</description>

components/apimgt-extensions/org.wso2.carbon.apimgt.application.extension.api/pom.xml

@@ -21,12 +21,12 @@
     <parent>
         <artifactId>apimgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <artifactId>org.wso2.carbon.apimgt.application.extension.api</artifactId>
     <packaging>war</packaging>
     <name>WSO2 Carbon - API Application Management API</name>

components/apimgt-extensions/org.wso2.carbon.apimgt.application.extension/pom.xml

@@ -22,12 +22,12 @@
     <parent>
         <artifactId>apimgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <artifactId>org.wso2.carbon.apimgt.application.extension</artifactId>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - API Application Management</name>

components/apimgt-extensions/org.wso2.carbon.apimgt.handlers/pom.xml

@@ -21,13 +21,13 @@
     <parent>
         <artifactId>apimgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.apimgt.handlers</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - API Security Handler Component</name>
     <description>WSO2 Carbon - API Management Security Handler Module</description>

components/apimgt-extensions/org.wso2.carbon.apimgt.integration.client/pom.xml

@@ -13,13 +13,13 @@
 	<parent>
 		<artifactId>apimgt-extensions</artifactId>
 		<groupId>org.wso2.carbon.devicemgt</groupId>
-		<version>3.0.119-SNAPSHOT</version>
+		<version>3.0.136-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>org.wso2.carbon.apimgt.integration.client</artifactId>
-	<version>3.0.119-SNAPSHOT</version>
+	<version>3.0.136-SNAPSHOT</version>
 	<packaging>bundle</packaging>
 	<name>WSO2 Carbon - API Management Integration Client</name>
 	<description>WSO2 Carbon - API Management Integration Client</description>

components/apimgt-extensions/org.wso2.carbon.apimgt.integration.generated.client/pom.xml

@@ -13,13 +13,13 @@
 	<parent>
 		<artifactId>apimgt-extensions</artifactId>
 		<groupId>org.wso2.carbon.devicemgt</groupId>
-		<version>3.0.119-SNAPSHOT</version>
+		<version>3.0.136-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>org.wso2.carbon.apimgt.integration.generated.client</artifactId>
-	<version>3.0.119-SNAPSHOT</version>
+	<version>3.0.136-SNAPSHOT</version>
 	<packaging>bundle</packaging>
 	<name>WSO2 Carbon - API Management Integration Generated Client</name>
 	<description>WSO2 Carbon - API Management Integration Client</description>

components/apimgt-extensions/org.wso2.carbon.apimgt.webapp.publisher/pom.xml

@@ -22,13 +22,13 @@
     <parent>
         <artifactId>apimgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.apimgt.webapp.publisher</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - API Management Webapp Publisher</name>
     <description>WSO2 Carbon - API Management Webapp Publisher</description>

components/apimgt-extensions/pom.xml

@@ -22,13 +22,13 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>apimgt-extensions</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - API Management Extensions Component</name>
     <url>http://wso2.org</url>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.api/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>certificate-mgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/certificate-mgt/org.wso2.carbon.certificate.mgt.cert.admin.api/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>certificate-mgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/pom.xml

@@ -21,13 +21,13 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>certificate-mgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.certificate.mgt.core</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Certificate Management Core</name>
     <description>WSO2 Carbon - Certificate Management Core</description>
@@ -162,6 +162,21 @@
             <groupId>org.testng</groupId>
             <artifactId>testng</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.h2database.wso2</groupId>
+            <artifactId>h2-database-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-module-testng</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.wso2.carbon</groupId>
             <artifactId>org.wso2.carbon.logging</artifactId>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/main/java/org/wso2/carbon/certificate/mgt/core/dao/CertificateManagementDAOFactory.java

@@ -115,7 +115,7 @@ public class CertificateManagementDAOFactory {
         currentTxState.set(TxState.CONNECTION_BORROWED);
     }
 
-    public static void openConnection() throws SQLException {
+    public static void  openConnection() throws SQLException {
         Connection conn = currentConnection.get();
         if (conn != null) {
             throw new IllegalTransactionStateException("A transaction is already active within the context of " +

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/common/BaseDeviceManagementCertificateTest.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.certificate.mgt.core.common;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.tomcat.jdbc.pool.PoolProperties;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeSuite;
+import org.w3c.dom.Document;
+import org.wso2.carbon.base.MultitenantConstants;
+import org.wso2.carbon.certificate.mgt.core.util.TestUtils;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
+
+import javax.sql.DataSource;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import java.io.File;
+import java.sql.Connection;
+import java.sql.Statement;
+
+
+public abstract class BaseDeviceManagementCertificateTest {
+    private DataSource dataSource;
+    private static final Log log = LogFactory.getLog(BaseDeviceManagementCertificateTest.class);
+    private static final String DATASOURCE_LOCATION = "src/test/resources/data-source-config.xml";
+
+    @BeforeSuite
+    public void setupDataSource() throws Exception {
+        this.initDataSource();
+        this.initSQLScript();
+        initializeCarbonContext();
+    }
+
+    public void initDataSource() throws Exception {
+        this.dataSource = this.getDataSource(this.readDataSourceConfig());
+        DeviceManagementDAOFactory.init(dataSource);
+        GroupManagementDAOFactory.init(dataSource);
+    }
+
+    public void initDataSource(DataSource ds) throws Exception {
+        this.dataSource = ds;
+        DeviceManagementDAOFactory.init(dataSource);
+        GroupManagementDAOFactory.init(dataSource);
+    }
+
+    @BeforeClass
+    public abstract void init() throws Exception;
+
+    private DataSource getDataSource(DataSourceConfig config) {
+        PoolProperties properties = new PoolProperties();
+        properties.setUrl(config.getUrl());
+        properties.setDriverClassName(config.getDriverClassName());
+        properties.setUsername(config.getUser());
+        properties.setPassword(config.getPassword());
+        return new org.apache.tomcat.jdbc.pool.DataSource(properties);
+    }
+
+    private DataSourceConfig readDataSourceConfig() throws DeviceManagementException {
+        try {
+            File file = new File(DATASOURCE_LOCATION);
+            Document doc = DeviceManagerUtil.convertToDocument(file);
+            JAXBContext testDBContext = JAXBContext.newInstance(DataSourceConfig.class);
+            Unmarshaller unmarshaller = testDBContext.createUnmarshaller();
+            return (DataSourceConfig) unmarshaller.unmarshal(doc);
+        } catch (JAXBException e) {
+            throw new DeviceManagementException("Error occurred while reading data source configuration", e);
+        }
+    }
+
+    private void initSQLScript() throws Exception {
+        Connection conn = null;
+        Statement stmt = null;
+        try {
+            conn = this.getDataSource().getConnection();
+            stmt = conn.createStatement();
+            stmt.executeUpdate("RUNSCRIPT FROM './src/test/resources/sql/h2.sql'");
+        } finally {
+            TestUtils.cleanupResources(conn, stmt, null);
+        }
+    }
+
+    private void initializeCarbonContext() {
+
+        if (System.getProperty("carbon.home") == null) {
+            File file = new File("src/test/resources/carbon-home");
+            if (file.exists()) {
+                System.setProperty("carbon.home", file.getAbsolutePath());
+            }
+            file = new File("../resources/carbon-home");
+            if (file.exists()) {
+                System.setProperty("carbon.home", file.getAbsolutePath());
+            }
+            file = new File("../../resources/carbon-home");
+            if (file.exists()) {
+                System.setProperty("carbon.home", file.getAbsolutePath());
+            }
+            file = new File("../../../resources/carbon-home");
+            if (file.exists()) {
+                System.setProperty("carbon.home", file.getAbsolutePath());
+            }
+        }
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(MultitenantConstants
+                .SUPER_TENANT_DOMAIN_NAME);
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(MultitenantConstants.SUPER_TENANT_ID);
+    }
+
+    public DataSource getDataSource() {
+        return dataSource;
+    }
+
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/common/DataSourceConfig.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.certificate.mgt.core.common;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+/**
+ * Model class for DataSourceConfig.
+ */
+@XmlRootElement(name = "DataSourceConfig")
+public class DataSourceConfig {
+
+    private String url;
+    private String driverClassName;
+    private String user;
+    private String password;
+
+    @Override
+    public String toString() {
+        return "DataSourceConfig[" +
+                " Url ='" + url + '\'' +
+                ", DriverClassName ='" + driverClassName + '\'' +
+                ", UserName ='" + user + '\'' +
+                ", Password ='" + password + '\'' +
+                "]";
+    }
+
+    @XmlElement(name = "Url", nillable = false)
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    @XmlElement(name = "DriverClassName", nillable = false)
+    public String getDriverClassName() {
+        return driverClassName;
+    }
+
+    public void setDriverClassName(String driverClassName) {
+        this.driverClassName = driverClassName;
+    }
+
+    @XmlElement(name = "User", nillable = false)
+    public String getUser() {
+        return user;
+    }
+
+    public void setUser(String user) {
+        this.user = user;
+    }
+
+    @XmlElement(name = "Password", nillable = false)
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/impl/CertificateManagementServiceImplTests.java

@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.certificate.mgt.core.impl;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.bouncycastle.cert.jcajce.JcaCertStore;
+import org.bouncycastle.cms.CMSAbsentContent;
+import org.bouncycastle.cms.CMSException;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.cms.CMSSignedDataGenerator;
+import org.bouncycastle.pkcs.PKCS10CertificationRequest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.wso2.carbon.certificate.mgt.core.common.BaseDeviceManagementCertificateTest;
+import org.wso2.carbon.certificate.mgt.core.dao.CertificateManagementDAOFactory;
+import org.wso2.carbon.certificate.mgt.core.dto.CAStatus;
+import org.wso2.carbon.certificate.mgt.core.dto.CertificateResponse;
+import org.wso2.carbon.certificate.mgt.core.dto.SCEPResponse;
+import org.wso2.carbon.certificate.mgt.core.exception.CertificateManagementException;
+import org.wso2.carbon.certificate.mgt.core.exception.KeystoreException;
+import org.wso2.carbon.certificate.mgt.core.service.CertificateManagementServiceImpl;
+import org.wso2.carbon.certificate.mgt.core.service.PaginationResult;
+import org.wso2.carbon.certificate.mgt.core.util.CSRGenerator;
+import org.wso2.carbon.certificate.mgt.core.util.CertificateManagementConstants;
+import org.wso2.carbon.certificate.mgt.core.util.DummyCertificate;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import sun.misc.BASE64Encoder;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.security.KeyPair;
+import java.security.PrivateKey;
+import java.security.Security;
+import java.security.cert.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Test cases for for CertificateManagementServiceImpl class methods.
+ *
+ */
+public class CertificateManagementServiceImplTests extends BaseDeviceManagementCertificateTest {
+
+    private static Log log = LogFactory.getLog(CertificateManagementServiceImplTests.class);
+    private static final String CA_CERT_PEM = "src/test/resources/ca_cert.pem";
+    private static final String RA_CERT_PEM = "src/test/resources/ra_cert.pem";
+    private CertificateManagementServiceImpl managementService;
+
+    @BeforeClass
+    public void init() throws Exception {
+        initDataSource();
+        CertificateManagementDAOFactory.init(this.getDataSource());
+        //set Bouncycastle as a provider for testing
+        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
+        //save certificatemanagementservice instance as class variable
+        managementService = CertificateManagementServiceImpl.getInstance();
+        Assert.assertNotNull(managementService);
+        log.info("getInstance Test Successful");
+    }
+
+    @Test(description = "This test case tests retrieval of CA Certificate from the keystore")
+    public void testGetCACertificate() throws KeystoreException {
+        CertificateManagementServiceImpl instance = CertificateManagementServiceImpl.getInstance();
+        Certificate caCertificate = instance.getCACertificate();
+        Assert.assertNotNull(caCertificate);
+        Assert.assertEquals(caCertificate.getType(), CertificateManagementConstants.X_509);
+        log.info("GetCACertificate Test Successful");
+    }
+
+    @Test(description = "This test case tests retrieval of RA Certificate from the keystore")
+    public void testGetRACertificate() throws KeystoreException {
+        Certificate raCertificate = managementService.getRACertificate();
+        Assert.assertNotNull(raCertificate);
+        Assert.assertEquals(raCertificate.getType(), CertificateManagementConstants.X_509);
+        log.info("GetRACertificate Test Successful");
+    }
+
+    @Test(description = "This test case test generation of root certificates")
+    public void testGetRootCertificate() throws IOException, KeystoreException {
+        File caCert = new File(CA_CERT_PEM);
+        File raCert = new File(RA_CERT_PEM);
+        //read file to byte arrays
+        byte[] caBytes = FileUtils.readFileToByteArray(caCert);
+        byte[] raBytes = FileUtils.readFileToByteArray(raCert);
+        List<X509Certificate> rootCertificates = managementService.getRootCertificates(caBytes, raBytes);
+        Assert.assertNotNull(rootCertificates);
+        Assert.assertEquals(rootCertificates.get(0).getType(), CertificateManagementConstants.X_509);
+        Assert.assertEquals(rootCertificates.get(1).getType(), CertificateManagementConstants.X_509);
+        log.info("GetRootCertificate Test Successful");
+    }
+
+    @Test(description = "This test case tests generation of X509Certificate")
+    public void testGenerateX509Certificate() throws KeystoreException {
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        Assert.assertNotNull(x509Certificate);
+        Assert.assertEquals(x509Certificate.getType(), CertificateManagementConstants.X_509);
+        log.info("GenerateX509Certificate Test Successful");
+    }
+
+    @Test(description = "This test case tests retrieving SCEP CA Certificate")
+    public void testGetCACertSCEP() throws KeystoreException {
+        SCEPResponse caCertSCEP = managementService.getCACertSCEP();
+        Assert.assertNotNull(caCertSCEP);
+        Assert.assertEquals(caCertSCEP.getResultCriteria(), CAStatus.CA_RA_CERT_RECEIVED);
+        log.info("GetCACertSCEP Test Successful");
+    }
+
+    @Test
+    public void testGetCACapsSCEP() {
+        byte[] caCapsSCEP = managementService.getCACapsSCEP();
+        Assert.assertNotNull(caCapsSCEP);
+        Assert.assertEquals(caCapsSCEP, CertificateManagementConstants.POST_BODY_CA_CAPS.getBytes());
+        log.info("GetCACapsSCEP Test Successful");
+    }
+
+    @Test(description = "This test case tests generation of a X509Certificate from a CSR")
+    public void testGenerateCertificateFromCSR() throws KeystoreException, IOException {
+        CSRGenerator csrGeneration = new CSRGenerator();
+        KeyStoreReader keyStoreReader = new KeyStoreReader();
+        // Generate key pair
+        KeyPair keyPair = csrGeneration.generateKeyPair("RSA", 1024);
+        byte[] csrData = csrGeneration.generateCSR("SHA256WithRSA", keyPair);
+        PKCS10CertificationRequest certificationRequest;
+        PrivateKey privateKeyCA = keyStoreReader.getCAPrivateKey();
+        X509Certificate certCA = (X509Certificate) keyStoreReader.getCACertificate();
+        certificationRequest = new PKCS10CertificationRequest(csrData);
+        X509Certificate x509Certificate = managementService.generateCertificateFromCSR(privateKeyCA,
+                certificationRequest, certCA.getIssuerX500Principal().getName());
+        Assert.assertNotNull(x509Certificate);
+        Assert.assertEquals(x509Certificate.getType(), CertificateManagementConstants.X_509);
+        log.info("GenerateCertificateFromCSR Test Successful");
+    }
+
+    @Test(description = "This test case tests retrieval of a Certificate from the keystore from the Serial Number")
+    public void testGetCertificateBySerial() throws KeystoreException, DeviceManagementException {
+        X509Certificate x509Certificate = null;
+        //generate and save a certificate
+        x509Certificate = managementService.generateX509Certificate();
+        //initialize DeviceConfigurationManager
+        DeviceConfigurationManager.getInstance().initConfig();
+        CertificateResponse certificateBySerial = managementService.getCertificateBySerial(x509Certificate.getSerialNumber().toString());
+        Assert.assertNotNull(certificateBySerial);
+        Assert.assertEquals(certificateBySerial.getSerialNumber(), x509Certificate.getSerialNumber().toString());
+        log.info("GetCertificateBySerial Test Successful");
+    }
+
+    @Test(description = "This test case tests retrieval of a Certificate from the keystore from the Alias")
+    public void testGetCertificateByAlias() throws KeystoreException, DeviceManagementException {
+        X509Certificate x509Certificate = null;
+        //generate and save a certificate
+        x509Certificate = managementService.generateX509Certificate();
+        //initialize DeviceConfigurationManager
+        DeviceConfigurationManager.getInstance().initConfig();
+        Certificate certificateByAlias = managementService.getCertificateByAlias(x509Certificate.getSerialNumber().toString());
+        Assert.assertNotNull(certificateByAlias);
+        Assert.assertEquals(certificateByAlias.getType(), CertificateManagementConstants.X_509);
+        log.info("GetCertificateByAlias Test Successful");
+    }
+
+    @Test(description = "This test case tests Signature verification of a Certificate against the keystore")
+    public void testVerifySignature() throws KeystoreException, CertificateEncodingException, CMSException, IOException {
+        BASE64Encoder encoder = new BASE64Encoder();
+        //generate and save a certificate in the keystore
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        //Generate CMSdata
+        CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
+        List<X509Certificate> list = new ArrayList<>();
+        list.add(x509Certificate);
+        JcaCertStore store = new JcaCertStore(list);
+        generator.addCertificates(store);
+        CMSSignedData degenerateSd = generator.generate(new CMSAbsentContent());
+        byte[] signature = degenerateSd.getEncoded();
+        boolean verifySignature = managementService.verifySignature(encoder.encode(signature));
+        Assert.assertNotNull(verifySignature);
+        Assert.assertTrue(verifySignature);
+        log.info("VerifySignature Test Successful");
+    }
+
+    @Test(description = "This test case tests DN verification of a Certificate against the keystore")
+    public void testVerifySubjectDN() throws DeviceManagementException, KeystoreException {
+        DeviceConfigurationManager.getInstance().initConfig();
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        log.info(x509Certificate.getIssuerX500Principal().getName());
+        managementService.verifySubjectDN(x509Certificate.getIssuerDN().getName());
+    }
+
+    @Test(description = "This test case tests retrieval of a Certificate from the keystore from the Serial")
+    public void testRetrieveCertificate() throws KeystoreException, CertificateManagementException {
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        CertificateResponse certificateResponse = managementService.retrieveCertificate(x509Certificate.getSerialNumber().toString());
+        Assert.assertNotNull(certificateResponse);
+        Assert.assertEquals(x509Certificate.getSerialNumber(), certificateResponse.getCertificateserial());
+    }
+
+    @Test(description = "This test case tests the retrieval of Certificates from keystore in desired pagination")
+    public void testGetAllCertificatesPaginated() throws CertificateManagementException, KeystoreException {
+        managementService.generateX509Certificate();
+        managementService.generateX509Certificate();
+        PaginationResult allCertificates = managementService.getAllCertificates(0, 2);
+        Assert.assertEquals(allCertificates.getData().size(), 2);
+        log.info("GetAllCertificatesPaginated Test Successful");
+    }
+
+    @Test(description = "This test casae tests retrieval of all Certificates from keystore")
+    public void testGetCertificates() throws CertificateManagementException, KeystoreException {
+        List<CertificateResponse> certificatesBefore = managementService.getCertificates();
+        managementService.generateX509Certificate();
+        managementService.generateX509Certificate();
+        List<CertificateResponse> certificatesAfter = managementService.getCertificates();
+        Assert.assertNotNull(certificatesBefore);
+        Assert.assertNotNull(certificatesAfter);
+        Assert.assertEquals((certificatesBefore.size() + 2), certificatesAfter.size());
+        log.info("GetCertificates Test Successful");
+    }
+
+    @Test(description = "This test case tests deleting Certificate from the keystore")
+    public void testRemoveCertificate() throws CertificateManagementException, KeystoreException {
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        List<CertificateResponse> certificates = managementService.getCertificates();
+        int size = certificates.size();
+        boolean removed = managementService.removeCertificate(x509Certificate.getSerialNumber().toString());
+        certificates = managementService.getCertificates();
+        int sizeAfter = certificates.size();
+        Assert.assertNotNull(removed);
+        Assert.assertTrue(removed);
+        Assert.assertEquals((size - 1), sizeAfter);
+        log.info("RemoveCertificate Test Successful");
+    }
+
+
+    @Test(description = "This test case tests searching for a list of certificates by the serial number")
+    public void testSearchCertificates() throws CertificateManagementException, KeystoreException {
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        List<CertificateResponse> certificateResponses = managementService.searchCertificates(x509Certificate.getSerialNumber().toString());
+        Assert.assertNotNull(certificateResponses);
+        Assert.assertEquals(1, certificateResponses.size());
+        Assert.assertEquals(certificateResponses.get(0).getSerialNumber(), x509Certificate.getSerialNumber().toString());
+        log.info("SearchCertificates Test Successful");
+    }
+
+    @Test(description = "This test case tests generation of signed Certificate from a CSR")
+    public void testGetSignedCertificateFromCSR() throws KeystoreException {
+        CSRGenerator csrGeneration = new CSRGenerator();
+        BASE64Encoder encoder = new BASE64Encoder();
+        // Generate key pair
+        KeyPair keyPair = csrGeneration.generateKeyPair("RSA", 1024);
+        byte[] csrData = csrGeneration.generateCSR("SHA256WithRSA", keyPair);
+        X509Certificate signedCertificateFromCSR = managementService.getSignedCertificateFromCSR(encoder.encode(csrData));
+        Assert.assertNotNull(signedCertificateFromCSR);
+        Assert.assertEquals(signedCertificateFromCSR.getType(), CertificateManagementConstants.X_509);
+        log.info("GetSignedCertificateFromCSR Test Successful");
+    }
+
+    @Test(description = "This test case tests the extraction of Challenge token from a Certificate")
+    public void testExtractChallengeToken() throws KeystoreException {
+        X509Certificate x509Certificate1 = new DummyCertificate();
+        String token = managementService.extractChallengeToken(x509Certificate1);
+        Assert.assertNotNull(token);
+        Assert.assertEquals(token, DummyCertificate.EXT);
+        log.info("extractChallengeToken Test Successful");
+    }
+
+    @Test(description = "This test case tests saving a list of Certificates in the keystore")
+    public void testSaveCertificate() throws CertificateManagementException, IOException, CertificateException, KeystoreException {
+        File caCert = new File(CA_CERT_PEM);
+        int before = managementService.getCertificates().size();
+        byte[] caBytes = FileUtils.readFileToByteArray(caCert);
+        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+        X509Certificate cert = (X509Certificate) cf.generateCertificate(new ByteArrayInputStream(caBytes));
+        List<org.wso2.carbon.certificate.mgt.core.bean.Certificate> certificates = new ArrayList<>();
+        org.wso2.carbon.certificate.mgt.core.bean.Certificate certificateToStore =
+                new org.wso2.carbon.certificate.mgt.core.bean.Certificate();
+        certificateToStore.setTenantId(PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId());
+        certificateToStore.setCertificate(cert);
+        certificates.add(certificateToStore);
+        managementService.saveCertificate(certificates);
+        int after = managementService.getCertificates().size();
+        Assert.assertEquals((before + 1), after);
+        log.info("SaveCertificate Test Successful");
+    }
+
+    @Test(description = "This test case tests converting a pem file to X509 Certificate")
+    public void testPemToX509Certificate() throws IOException, KeystoreException {
+        File caCert = new File(CA_CERT_PEM);
+        BASE64Encoder encoder = new BASE64Encoder();
+        byte[] caBytes = FileUtils.readFileToByteArray(caCert);
+        X509Certificate certificate = managementService.pemToX509Certificate(encoder.encode(caBytes));
+        Assert.assertNotNull(certificate);
+        Assert.assertEquals(certificate.getType(), CertificateManagementConstants.X_509);
+        log.info("PemToX509Certificate Test Successful");
+    }
+
+    @Test(description = "This test case tests extracting Certificate from the header Signature")
+    public void testExtractCertificateFromSignature() throws KeystoreException, CertificateEncodingException, CMSException, IOException {
+        BASE64Encoder encoder = new BASE64Encoder();
+        //generate and save a certificate in the keystore
+        X509Certificate x509Certificate = managementService.generateX509Certificate();
+        //Generate CMSdata
+        CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
+        List<X509Certificate> list = new ArrayList<>();
+        list.add(x509Certificate);
+        JcaCertStore store = new JcaCertStore(list);
+        generator.addCertificates(store);
+        CMSSignedData degenerateSd = generator.generate(new CMSAbsentContent());
+        byte[] signature = degenerateSd.getEncoded();
+        X509Certificate certificate = managementService.extractCertificateFromSignature(encoder.encode(signature));
+        Assert.assertNotNull(certificate);
+        Assert.assertEquals(certificate.getType(), CertificateManagementConstants.X_509);
+        log.info("ExtractCertificateFromSignature Test Successful");
+    }
+
+
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/util/CSRGenerator.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.certificate.mgt.core.util;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.OperatorCreationException;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.pkcs.PKCS10CertificationRequest;
+import org.bouncycastle.pkcs.PKCS10CertificationRequestBuilder;
+import org.bouncycastle.pkcs.jcajce.JcaPKCS10CertificationRequestBuilder;
+
+import javax.security.auth.x500.X500Principal;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * Test class for generating a mock CSR request.
+ */
+public class CSRGenerator {
+    private static Log log = LogFactory.getLog(CSRGenerator.class);
+
+    /**
+     * Generate the desired CSR for signing
+     *
+     * @param sigAlg
+     * @param keyPair
+     * @return
+     */
+    public byte[] generateCSR(String sigAlg, KeyPair keyPair) {
+        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+        PrintStream printStream = new PrintStream(outStream);
+        try {
+            PKCS10CertificationRequestBuilder p10Builder = new JcaPKCS10CertificationRequestBuilder(
+                    new X500Principal("CN=Requested Test Certificate"), keyPair.getPublic());
+            JcaContentSignerBuilder csBuilder = new JcaContentSignerBuilder("SHA256withRSA");
+            ContentSigner signer = csBuilder.build(keyPair.getPrivate());
+            PKCS10CertificationRequest csr = p10Builder.build(signer);
+            return csr.getEncoded();
+        } catch (OperatorCreationException ex) {
+            log.error("Error while Key generation operation", ex);
+        } catch (IOException ex) {
+            log.error("Error while generating CSR,ex");
+        }
+        return new byte[0];
+    }
+
+    /**
+     * Generate the desired keypair
+     *
+     * @param alg
+     * @param keySize
+     * @return
+     */
+    public KeyPair generateKeyPair(String alg, int keySize) {
+        try {
+            KeyPairGenerator keyPairGenerator = null;
+            keyPairGenerator = KeyPairGenerator.getInstance(alg);
+            keyPairGenerator.initialize(keySize);
+            return keyPairGenerator.generateKeyPair();
+        } catch (NoSuchAlgorithmException e) {
+            log.error("The provided algorithm is not found ",e);
+        }
+        return null;
+    }
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/util/DummyCertificate.java

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.certificate.mgt.core.util;
+
+import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
+
+import java.math.BigInteger;
+import java.security.Principal;
+import java.security.PublicKey;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.CertificateExpiredException;
+import java.security.cert.CertificateNotYetValidException;
+import java.security.cert.CertificateException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SignatureException;
+import java.security.NoSuchProviderException;
+import java.security.cert.X509Certificate;
+import java.security.InvalidKeyException;
+import java.util.Date;
+import java.util.Set;
+
+/**
+ * A Mock Certificate class with an extension provided.(Used only to test the extension)
+ */
+public class DummyCertificate extends X509Certificate {
+
+    public static final String EXT = "Dummy extension";
+    public static final String DN = "O=WSO2,OU=Mobile,C=LK,CN=123456789";
+
+    @Override
+    public void checkValidity() throws CertificateExpiredException, CertificateNotYetValidException {
+    }
+
+    @Override
+    public void checkValidity(Date date) throws CertificateExpiredException, CertificateNotYetValidException {
+    }
+
+    @Override
+    public int getVersion() {
+        return 0;
+    }
+
+    @Override
+    public BigInteger getSerialNumber() {
+        return new BigInteger("123456789");
+    }
+
+    @Override
+    public Principal getIssuerDN() {
+        return null;
+    }
+
+    @Override
+    public Principal getSubjectDN() {
+        return new Principal() {
+            @Override
+            public String getName() {
+                return DN;
+            }
+        };
+    }
+
+    @Override
+    public Date getNotBefore() {
+        return null;
+    }
+
+    @Override
+    public Date getNotAfter() {
+        return null;
+    }
+
+    @Override
+    public byte[] getTBSCertificate() throws CertificateEncodingException {
+        return new byte[0];
+    }
+
+    @Override
+    public byte[] getSignature() {
+        return new byte[0];
+    }
+
+    @Override
+    public String getSigAlgName() {
+        return null;
+    }
+
+    @Override
+    public String getSigAlgOID() {
+        return null;
+    }
+
+    @Override
+    public byte[] getSigAlgParams() {
+        return new byte[0];
+    }
+
+    @Override
+    public boolean[] getIssuerUniqueID() {
+        return new boolean[0];
+    }
+
+    @Override
+    public boolean[] getSubjectUniqueID() {
+        return new boolean[0];
+    }
+
+    @Override
+    public boolean[] getKeyUsage() {
+        return new boolean[0];
+    }
+
+    @Override
+    public int getBasicConstraints() {
+        return 0;
+    }
+
+    @Override
+    public byte[] getEncoded() throws CertificateEncodingException {
+        return new byte[0];
+    }
+
+    @Override
+    public void verify(PublicKey key) throws CertificateException, NoSuchAlgorithmException, InvalidKeyException, NoSuchProviderException, SignatureException {
+    }
+
+    @Override
+    public void verify(PublicKey key, String sigProvider) throws CertificateException, NoSuchAlgorithmException, InvalidKeyException, NoSuchProviderException, SignatureException {
+    }
+
+    @Override
+    public String toString() {
+        return null;
+    }
+
+    @Override
+    public PublicKey getPublicKey() {
+        return null;
+    }
+
+    @Override
+    public boolean hasUnsupportedCriticalExtension() {
+        return false;
+    }
+
+    @Override
+    public Set<String> getCriticalExtensionOIDs() {
+        return null;
+    }
+
+    @Override
+    public Set<String> getNonCriticalExtensionOIDs() {
+        return null;
+    }
+
+    @Override
+    public byte[] getExtensionValue(String oid) {
+        if (oid.equals(PKCSObjectIdentifiers.pkcs_9_at_challengePassword.toString())) {
+            return EXT.getBytes();
+        } else {
+            return new byte[0];
+        }
+    }
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/java/org/wso2/carbon/certificate/mgt/core/util/TestUtils.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2014, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.certificate.mgt.core.util;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class TestUtils {
+
+    private static final Log log = LogFactory.getLog(TestUtils.class);
+
+    public static void cleanupResources(Connection conn, Statement stmt, ResultSet rs) {
+        if (rs != null) {
+            try {
+                rs.close();
+            } catch (SQLException e) {
+                log.warn("Error occurred while closing result set", e);
+            }
+        }
+        if (stmt != null) {
+            try {
+                stmt.close();
+            } catch (SQLException e) {
+                log.warn("Error occurred while closing prepared statement", e);
+            }
+        }
+        if (conn != null) {
+            try {
+                conn.close();
+            } catch (SQLException e) {
+                log.warn("Error occurred while closing database connection", e);
+            }
+        }
+    }
+
+}

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/carbon-home/repository/conf/carbon.xml

@@ -0,0 +1,655 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright 2005-2017 WSO2 Inc. (http://wso2.com)
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<!--
+    This is the main server configuration file
+
+    ${carbon.home} represents the carbon.home system property.
+    Other system properties can be specified in a similar manner.
+-->
+<Server xmlns="http://wso2.org/projects/carbon/carbon.xml">
+
+    <!--
+       Product Name
+    -->
+    <Name>${product.name}</Name>
+
+    <!--
+       machine readable unique key to identify each product
+    -->
+    <ServerKey>${product.key}</ServerKey>
+
+    <!--
+       Product Version
+    -->
+    <Version>${product.version}</Version>
+
+    <!--
+       Host name or IP address of the machine hosting this server
+       e.g. www.wso2.org, 192.168.1.10
+       This is will become part of the End Point Reference of the
+       services deployed on this server instance.
+    -->
+    <!--HostName>www.wso2.org</HostName-->
+
+    <!--
+    Host name to be used for the Carbon management console
+    -->
+    <!--MgtHostName>mgt.wso2.org</MgtHostName-->
+
+    <!--
+        The URL of the back end server. This is where the admin services are hosted and
+        will be used by the clients in the front end server.
+        This is required only for the Front-end server. This is used when seperating BE server from FE server
+       -->
+    <ServerURL>local:/${carbon.context}/services/</ServerURL>
+    <!--
+    <ServerURL>https://${carbon.local.ip}:${carbon.management.port}${carbon.context}/services/</ServerURL>
+    -->
+     <!--
+     The URL of the index page. This is where the user will be redirected after signing in to the
+     carbon server.
+     -->
+    <!-- IndexPageURL>/carbon/admin/index.jsp</IndexPageURL-->
+
+    <!--
+    For cApp deployment, we have to identify the roles that can be acted by the current server.
+    The following property is used for that purpose. Any number of roles can be defined here.
+    Regular expressions can be used in the role.
+    Ex : <Role>.*</Role> means this server can act any role
+    -->
+    <ServerRoles>
+        <Role>${default.server.role}</Role>
+    </ServerRoles>
+
+    <!-- uncommnet this line to subscribe to a bam instance automatically -->
+    <!--<BamServerURL>https://bamhost:bamport/services/</BamServerURL>-->
+
+    <!--
+       The fully qualified name of the server
+    -->
+    <Package>org.wso2.carbon</Package>
+
+    <!--
+       Webapp context root of WSO2 Carbon management console.
+    -->
+    <WebContextRoot>/</WebContextRoot>
+
+    <!--
+    	Proxy context path is a useful parameter to add a proxy path when a Carbon server is fronted by reverse proxy. In addtion
+        to the proxy host and proxy port this parameter allows you add a path component to external URLs. e.g.
+     		URL of the Carbon server -> https://10.100.1.1:9443/carbon
+   		URL of the reverse proxy -> https://prod.abc.com/appserver/carbon
+
+   	appserver - proxy context path. This specially required whenever you are generating URLs to displace in
+   	Carbon UI components.
+    -->
+    <!--
+    	<MgtProxyContextPath></MgtProxyContextPath>
+    	<ProxyContextPath></ProxyContextPath>
+    -->
+
+    <!-- In-order to  get the registry http Port from the back-end when the default http transport is not the same-->
+    <!--RegistryHttpPort>9763</RegistryHttpPort-->
+
+    <!--
+    Number of items to be displayed on a management console page. This is used at the
+    backend server for pagination of various items.
+    -->
+    <ItemsPerPage>15</ItemsPerPage>
+
+    <!-- The endpoint URL of the cloud instance management Web service -->
+    <!--<InstanceMgtWSEndpoint>https://ec2.amazonaws.com/</InstanceMgtWSEndpoint>-->
+
+    <!--
+       Ports used by this server
+    -->
+    <Ports>
+
+        <!-- Ports offset. This entry will set the value of the ports defined below to
+         the define value + Offset.
+         e.g. Offset=2 and HTTPS port=9443 will set the effective HTTPS port to 9445
+         -->
+        <Offset>0</Offset>
+
+        <!-- The JMX Ports -->
+        <JMX>
+            <!--The port RMI registry is exposed-->
+            <RMIRegistryPort>9999</RMIRegistryPort>
+            <!--The port RMI server should be exposed-->
+            <RMIServerPort>11111</RMIServerPort>
+        </JMX>
+
+        <!-- Embedded LDAP server specific ports -->
+        <EmbeddedLDAP>
+            <!-- Port which embedded LDAP server runs -->
+            <LDAPServerPort>10389</LDAPServerPort>
+            <!-- Port which KDC (Kerberos Key Distribution Center) server runs -->
+            <KDCServerPort>8000</KDCServerPort>
+        </EmbeddedLDAP>
+	
+	<!-- 
+             Override datasources JNDIproviderPort defined in bps.xml and datasources.properties files
+	-->
+	<!--<JNDIProviderPort>2199</JNDIProviderPort>-->
+	<!--Override receive port of thrift based entitlement service.-->
+	<ThriftEntitlementReceivePort>10500</ThriftEntitlementReceivePort>
+
+    </Ports>
+
+    <!--
+        JNDI Configuration
+    -->
+    <JNDI>
+        <!-- 
+             The fully qualified name of the default initial context factory
+        -->
+        <DefaultInitialContextFactory>org.wso2.carbon.tomcat.jndi.CarbonJavaURLContextFactory</DefaultInitialContextFactory>
+        <!-- 
+             The restrictions that are done to various JNDI Contexts in a Multi-tenant environment 
+        -->
+        <Restrictions>
+            <!--
+                Contexts that will be available only to the super-tenant
+            -->
+            <!-- <SuperTenantOnly>
+                <UrlContexts>
+                    <UrlContext>
+                        <Scheme>foo</Scheme>
+                    </UrlContext>
+                    <UrlContext>
+                        <Scheme>bar</Scheme>
+                    </UrlContext>
+                </UrlContexts>
+            </SuperTenantOnly> -->
+            <!-- 
+                Contexts that are common to all tenants
+            -->
+            <AllTenants>
+                <UrlContexts>
+                    <UrlContext>
+                        <Scheme>java</Scheme>
+                    </UrlContext>
+                    <!-- <UrlContext>
+                        <Scheme>foo</Scheme>
+                    </UrlContext> -->
+                </UrlContexts>
+            </AllTenants>
+            <!-- 
+                 All other contexts not mentioned above will be available on a per-tenant basis 
+                 (i.e. will not be shared among tenants)
+            -->
+        </Restrictions>
+    </JNDI>
+
+    <!--
+        Property to determine if the server is running an a cloud deployment environment.
+        This property should only be used to determine deployment specific details that are
+        applicable only in a cloud deployment, i.e when the server deployed *-as-a-service.
+    -->
+    <IsCloudDeployment>false</IsCloudDeployment>
+
+    <!--
+	Property to determine whether usage data should be collected for metering purposes
+    -->
+    <EnableMetering>false</EnableMetering>
+
+    <!-- The Max time a thread should take for execution in seconds -->
+    <MaxThreadExecutionTime>600</MaxThreadExecutionTime>
+
+    <!--
+        A flag to enable or disable Ghost Deployer. By default this is set to false. That is
+        because the Ghost Deployer works only with the HTTP/S transports. If you are using
+        other transports, don't enable Ghost Deployer.
+    -->
+    <GhostDeployment>
+        <Enabled>false</Enabled>
+    </GhostDeployment>
+
+
+    <!--
+        Eager loading or lazy loading is a design pattern commonly used in computer programming which
+        will initialize an object upon creation or load on-demand. In carbon, lazy loading is used to
+        load tenant when a request is received only. Similarly Eager loading is used to enable load
+        existing tenants after carbon server starts up. Using this feature, you will be able to include
+        or exclude tenants which are to be loaded when server startup.
+
+        We can enable only one LoadingPolicy at a given time.
+
+        1. Tenant Lazy Loading
+           This is the default behaviour and enabled by default. With this policy, tenants are not loaded at
+           server startup, but loaded based on-demand (i.e when a request is received for a tenant).
+           The default tenant idle time is 30 minutes.
+
+        2. Tenant Eager Loading
+           This is by default not enabled. It can be be enabled by un-commenting the <EagerLoading> section.
+           The eager loading configurations supported are as below. These configurations can be given as the
+           value for <Include> element with eager loading.
+                (i)Load all tenants when server startup             -   *
+                (ii)Load all tenants except foo.com & bar.com       -   *,!foo.com,!bar.com
+                (iii)Load only foo.com &  bar.com to be included    -   foo.com,bar.com
+    -->
+    <Tenant>
+        <LoadingPolicy>
+            <LazyLoading>
+                <IdleTime>30</IdleTime>
+            </LazyLoading>
+            <!-- <EagerLoading>
+                   <Include>*,!foo.com,!bar.com</Include>
+            </EagerLoading>-->
+        </LoadingPolicy>
+    </Tenant>
+
+    <!--
+     Caching related configurations
+    -->
+    <Cache>
+        <!-- Default cache timeout in minutes -->
+        <DefaultCacheTimeout>15</DefaultCacheTimeout>
+    </Cache>
+
+    <!--
+    Axis2 related configurations
+    -->
+    <Axis2Config>
+        <!--
+             Location of the Axis2 Services & Modules repository
+
+             This can be a directory in the local file system, or a URL.
+
+             e.g.
+             1. /home/wso2wsas/repository/ - An absolute path
+             2. repository - In this case, the path is relative to CARBON_HOME
+             3. file:///home/wso2wsas/repository/
+             4. http://wso2wsas/repository/
+        -->
+        <RepositoryLocation>${carbon.home}/repository/deployment/server/</RepositoryLocation>
+
+        <!--
+         Deployment update interval in seconds. This is the interval between repository listener
+         executions. 
+        -->
+        <DeploymentUpdateInterval>15</DeploymentUpdateInterval>
+
+        <!--
+            Location of the main Axis2 configuration descriptor file, a.k.a. axis2.xml file
+
+            This can be a file on the local file system, or a URL
+
+            e.g.
+            1. /home/repository/axis2.xml - An absolute path
+            2. conf/axis2.xml - In this case, the path is relative to CARBON_HOME
+            3. file:///home/carbon/repository/axis2.xml
+            4. http://repository/conf/axis2.xml
+        -->
+        <ConfigurationFile>${carbon.home}/repository/conf/axis2/axis2.xml</ConfigurationFile>
+
+        <!--
+          ServiceGroupContextIdleTime, which will be set in ConfigurationContex
+          for multiple clients which are going to access the same ServiceGroupContext
+          Default Value is 30 Sec.
+        -->
+        <ServiceGroupContextIdleTime>30000</ServiceGroupContextIdleTime>
+
+        <!--
+          This repository location is used to crete the client side configuration
+          context used by the server when calling admin services.
+        -->
+        <ClientRepositoryLocation>${carbon.home}/repository/deployment/client/</ClientRepositoryLocation>
+        <!-- This axis2 xml is used in createing the configuration context by the FE server
+         calling to BE server -->
+        <clientAxis2XmlLocation>${carbon.home}/repository/conf/axis2/axis2_client.xml</clientAxis2XmlLocation>
+        <!-- If this parameter is set, the ?wsdl on an admin service will not give the admin service wsdl. -->
+        <HideAdminServiceWSDLs>true</HideAdminServiceWSDLs>
+	
+	<!--WARNING-Use With Care! Uncommenting bellow parameter would expose all AdminServices in HTTP transport.
+	With HTTP transport your credentials and data routed in public channels are vulnerable for sniffing attacks. 
+	Use bellow parameter ONLY if your communication channels are confirmed to be secured by other means -->
+        <!--HttpAdminServices>*</HttpAdminServices-->
+
+    </Axis2Config>
+
+    <!--
+       The default user roles which will be created when the server
+       is started up for the first time.
+    -->
+    <ServiceUserRoles>
+        <Role>
+            <Name>admin</Name>
+            <Description>Default Administrator Role</Description>
+        </Role>
+        <Role>
+            <Name>user</Name>
+            <Description>Default User Role</Description>
+        </Role>
+    </ServiceUserRoles>
+    
+    <!-- 
+      Enable following config to allow Emails as usernames. 	
+    -->	    	
+    <!--EnableEmailUserName>true</EnableEmailUserName-->	
+
+    <!--
+      Security configurations
+    -->
+    <Security>
+        <!--
+            KeyStore which will be used for encrypting/decrypting passwords
+            and other sensitive information.
+        -->
+        <KeyStore>
+            <!-- Keystore file location-->
+            <Location>${carbon.home}/repository/resources/security/wso2carbon.jks</Location>
+            <!-- Keystore type (JKS/PKCS12 etc.)-->
+            <Type>JKS</Type>
+            <!-- Keystore password-->
+            <Password>wso2carbon</Password>
+            <!-- Private Key alias-->
+            <KeyAlias>wso2carbon</KeyAlias>
+            <!-- Private Key password-->
+            <KeyPassword>wso2carbon</KeyPassword>
+        </KeyStore>
+
+        <!--
+            System wide trust-store which is used to maintain the certificates of all
+            the trusted parties.
+        -->
+        <TrustStore>
+            <!-- trust-store file location -->
+            <Location>${carbon.home}/repository/resources/security/client-truststore.jks</Location>
+            <!-- trust-store type (JKS/PKCS12 etc.) -->
+            <Type>JKS</Type>
+            <!-- trust-store password -->
+            <Password>wso2carbon</Password>
+        </TrustStore>
+
+        <!--
+            The Authenticator configuration to be used at the JVM level. We extend the
+            java.net.Authenticator to make it possible to authenticate to given servers and 
+            proxies.
+        -->
+        <NetworkAuthenticatorConfig>
+            <!-- 
+                Below is a sample configuration for a single authenticator. Please note that
+                all child elements are mandatory. Not having some child elements would lead to
+                exceptions at runtime.
+            -->
+            <!-- <Credential> -->
+                <!-- 
+                    the pattern that would match a subset of URLs for which this authenticator
+                    would be used
+                -->
+                <!-- <Pattern>regularExpression</Pattern> -->
+                <!-- 
+                    the type of this authenticator. Allowed values are:
+                    1. server
+                    2. proxy
+                -->
+                <!-- <Type>proxy</Type> -->
+                <!-- the username used to log in to server/proxy -->
+                <!-- <Username>username</Username> -->
+                <!-- the password used to log in to server/proxy -->
+                <!-- <Password>password</Password> -->
+            <!-- </Credential> -->
+        </NetworkAuthenticatorConfig>
+
+        <!--
+         The Tomcat realm to be used for hosted Web applications. Allowed values are;
+         1. UserManager
+         2. Memory
+
+         If this is set to 'UserManager', the realm will pick users & roles from the system's
+         WSO2 User Manager. If it is set to 'memory', the realm will pick users & roles from
+         CARBON_HOME/repository/conf/tomcat/tomcat-users.xml
+        -->
+        <TomcatRealm>UserManager</TomcatRealm>
+
+	<!--Option to disable storing of tokens issued by STS-->
+	<DisableTokenStore>false</DisableTokenStore>
+
+	<!--
+	 Security token store class name. If this is not set, default class will be
+	 org.wso2.carbon.security.util.SecurityTokenStore
+	-->
+	<!--TokenStoreClassName>org.wso2.carbon.identity.sts.store.DBTokenStore</TokenStoreClassName-->
+    </Security>
+
+    <!--
+       The temporary work directory
+    -->
+    <WorkDirectory>${carbon.home}/tmp/work</WorkDirectory>
+
+    <!--
+       House-keeping configuration
+    -->
+    <HouseKeeping>
+
+        <!--
+           true  - Start House-keeping thread on server startup
+           false - Do not start House-keeping thread on server startup.
+                   The user will run it manually as and when he wishes.
+        -->
+        <AutoStart>true</AutoStart>
+
+        <!--
+           The interval in *minutes*, between house-keeping runs
+        -->
+        <Interval>10</Interval>
+
+        <!--
+          The maximum time in *minutes*, temp files are allowed to live
+          in the system. Files/directories which were modified more than
+          "MaxTempFileLifetime" minutes ago will be removed by the
+          house-keeping task
+        -->
+        <MaxTempFileLifetime>30</MaxTempFileLifetime>
+    </HouseKeeping>
+
+    <!--
+       Configuration for handling different types of file upload & other file uploading related
+       config parameters.
+       To map all actions to a particular FileUploadExecutor, use
+       <Action>*</Action>
+    -->
+    <FileUploadConfig>
+        <!--
+           The total file upload size limit in MB
+        -->
+        <TotalFileSizeLimit>100</TotalFileSizeLimit>
+
+        <Mapping>
+            <Actions>
+                <Action>keystore</Action>
+                <Action>certificate</Action>
+                <Action>*</Action>
+            </Actions>
+            <Class>org.wso2.carbon.ui.transports.fileupload.AnyFileUploadExecutor</Class>
+        </Mapping>
+
+        <Mapping>
+            <Actions>
+                <Action>jarZip</Action>
+            </Actions>
+            <Class>org.wso2.carbon.ui.transports.fileupload.JarZipUploadExecutor</Class>
+        </Mapping>
+        <Mapping>
+            <Actions>
+                <Action>dbs</Action>
+            </Actions>
+            <Class>org.wso2.carbon.ui.transports.fileupload.DBSFileUploadExecutor</Class>
+        </Mapping>
+        <Mapping>
+            <Actions>
+                <Action>tools</Action>
+            </Actions>
+            <Class>org.wso2.carbon.ui.transports.fileupload.ToolsFileUploadExecutor</Class>
+        </Mapping>
+        <Mapping>
+            <Actions>
+                <Action>toolsAny</Action>
+            </Actions>
+            <Class>org.wso2.carbon.ui.transports.fileupload.ToolsAnyFileUploadExecutor</Class>
+        </Mapping>
+    </FileUploadConfig>
+
+    <!--
+       Processors which process special HTTP GET requests such as ?wsdl, ?policy etc.
+
+       In order to plug in a processor to handle a special request, simply add an entry to this
+       section.
+
+       The value of the Item element is the first parameter in the query string(e.g. ?wsdl)
+       which needs special processing
+       
+       The value of the Class element is a class which implements
+       org.wso2.carbon.transport.HttpGetRequestProcessor
+    -->
+    <HttpGetRequestProcessors>
+        <Processor>
+            <Item>info</Item>
+            <Class>org.wso2.carbon.core.transports.util.InfoProcessor</Class>
+        </Processor>
+        <Processor>
+            <Item>wsdl</Item>
+            <Class>org.wso2.carbon.core.transports.util.Wsdl11Processor</Class>
+        </Processor>
+        <Processor>
+            <Item>wsdl2</Item>
+            <Class>org.wso2.carbon.core.transports.util.Wsdl20Processor</Class>
+        </Processor>
+        <Processor>
+            <Item>xsd</Item>
+            <Class>org.wso2.carbon.core.transports.util.XsdProcessor</Class>
+        </Processor>
+    </HttpGetRequestProcessors>
+
+    <!-- Deployment Synchronizer Configuration. t Enabled value to true when running with "svn based" dep sync.
+	In master nodes you need to set both AutoCommit and AutoCheckout to true
+	and in  worker nodes set only AutoCheckout to true.
+    -->
+    <DeploymentSynchronizer>
+        <Enabled>false</Enabled>
+        <AutoCommit>false</AutoCommit>
+        <AutoCheckout>true</AutoCheckout>
+        <RepositoryType>svn</RepositoryType>
+        <SvnUrl>http://svnrepo.example.com/repos/</SvnUrl>
+        <SvnUser>username</SvnUser>
+        <SvnPassword>password</SvnPassword>
+        <SvnUrlAppendTenantId>true</SvnUrlAppendTenantId>
+    </DeploymentSynchronizer>
+
+    <!-- Deployment Synchronizer Configuration. Uncomment the following section when running with "registry based" dep sync.
+        In master nodes you need to set both AutoCommit and AutoCheckout to true
+        and in  worker nodes set only AutoCheckout to true.
+    -->
+    <!--<DeploymentSynchronizer>
+        <Enabled>true</Enabled>
+        <AutoCommit>false</AutoCommit>
+        <AutoCheckout>true</AutoCheckout>
+    </DeploymentSynchronizer>-->
+
+    <!-- Mediation persistence configurations. Only valid if mediation features are available i.e. ESB -->
+    <!--<MediationConfig>
+        <LoadFromRegistry>false</LoadFromRegistry>
+        <SaveToFile>false</SaveToFile>
+        <Persistence>enabled</Persistence>
+        <RegistryPersistence>enabled</RegistryPersistence>
+    </MediationConfig>-->
+
+    <!--
+    Server intializing code, specified as implementation classes of org.wso2.carbon.core.ServerInitializer.
+    This code will be run when the Carbon server is initialized
+    -->
+    <ServerInitializers>
+        <!--<Initializer></Initializer>-->
+    </ServerInitializers>
+    
+    <!--
+    Indicates whether the Carbon Servlet is required by the system, and whether it should be
+    registered
+    -->
+    <RequireCarbonServlet>${require.carbon.servlet}</RequireCarbonServlet>
+
+    <!--
+    Carbon H2 OSGI Configuration
+    By default non of the servers start.
+        name="web" - Start the web server with the H2 Console
+        name="webPort" - The port (default: 8082)
+        name="webAllowOthers" - Allow other computers to connect
+        name="webSSL" - Use encrypted (HTTPS) connections
+        name="tcp" - Start the TCP server
+        name="tcpPort" - The port (default: 9092)
+        name="tcpAllowOthers" - Allow other computers to connect
+        name="tcpSSL" - Use encrypted (SSL) connections
+        name="pg" - Start the PG server
+        name="pgPort"  - The port (default: 5435)
+        name="pgAllowOthers"  - Allow other computers to connect
+        name="trace" - Print additional trace information; for all servers
+        name="baseDir" - The base directory for H2 databases; for all servers  
+    -->
+    <!--H2DatabaseConfiguration>
+        <property name="web" />
+        <property name="webPort">8082</property>
+        <property name="webAllowOthers" />
+        <property name="webSSL" />
+        <property name="tcp" />
+        <property name="tcpPort">9092</property>
+        <property name="tcpAllowOthers" />
+        <property name="tcpSSL" />
+        <property name="pg" />
+        <property name="pgPort">5435</property>
+        <property name="pgAllowOthers" />
+        <property name="trace" />
+        <property name="baseDir">${carbon.home}</property>
+    </H2DatabaseConfiguration-->
+    <!--Disabling statistics reporter by default-->
+    <StatisticsReporterDisabled>true</StatisticsReporterDisabled>
+
+    <!-- Enable accessing Admin Console via HTTP -->
+    <!-- EnableHTTPAdminConsole>true</EnableHTTPAdminConsole -->
+
+    <!--
+       Default Feature Repository of WSO2 Carbon.
+    -->
+    <FeatureRepository>
+	    <RepositoryName>default repository</RepositoryName>
+	    <RepositoryURL>${p2.repo.url}</RepositoryURL>
+    </FeatureRepository>
+
+    <!--
+	Configure API Management
+   -->
+   <APIManagement>
+	
+	<!--Uses the embedded API Manager by default. If you want to use an external 
+	API Manager instance to manage APIs, configure below  externalAPIManager-->
+	
+	<Enabled>true</Enabled>
+	
+	<!--Uncomment and configure API Gateway and 
+	Publisher URLs to use external API Manager instance-->
+	
+	<!--ExternalAPIManager>
+
+		<APIGatewayURL>http://localhost:8281</APIGatewayURL>
+		<APIPublisherURL>http://localhost:8281/publisher</APIPublisherURL>
+
+	</ExternalAPIManager-->
+	
+	<LoadAPIContextsInServerStartup>true</LoadAPIContextsInServerStartup>
+   </APIManagement>
+</Server>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/carbon-home/repository/conf/cdm-config.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<DeviceMgtConfiguration>
+    <ManagementRepository>
+        <DataSourceConfiguration>
+            <JndiLookupDefinition>
+                <Name>jdbc/DM_DS</Name>
+            </JndiLookupDefinition>
+        </DataSourceConfiguration>
+    </ManagementRepository>
+    <EmailClientConfiguration>
+        <minimumThread>8</minimumThread>
+        <maximumThread>100</maximumThread>
+        <keepAliveTime>20</keepAliveTime>
+        <ThreadQueueCapacity>1000</ThreadQueueCapacity>
+    </EmailClientConfiguration>
+    <IdentityConfiguration>
+        <ServerUrl>https://localhost:9443</ServerUrl>
+        <AdminUsername>admin</AdminUsername>
+        <AdminPassword>admin</AdminPassword>
+    </IdentityConfiguration>
+    <PolicyConfiguration>
+        <monitoringClass>org.wso2.carbon.policy.mgt</monitoringClass>
+        <monitoringEnable>true</monitoringEnable>
+        <monitoringFrequency>60000</monitoringFrequency>
+        <maxRetries>5</maxRetries>
+        <minRetriesToMarkUnreachable>8</minRetriesToMarkUnreachable>
+        <minRetriesToMarkInactive>20</minRetriesToMarkInactive>
+        <!--<PolicyEvaluationPoint>Simple</PolicyEvaluationPoint>-->
+        <PolicyEvaluationPoint>Simple</PolicyEvaluationPoint>
+    </PolicyConfiguration>
+    <!--This specifies whether to enable the DeviceStatus Task in this node.-->
+    <DeviceStatusTaskConfig>
+        <Enable>true</Enable>
+    </DeviceStatusTaskConfig>
+    <CertificateCacheConfiguration>
+        <Enable>true</Enable>
+        <ExpiryTime>86400</ExpiryTime>
+    </CertificateCacheConfiguration>
+    <DeviceCacheConfiguration>
+        <Enable>true</Enable>
+        <ExpiryTime>300</ExpiryTime>
+    </DeviceCacheConfiguration>
+</DeviceMgtConfiguration>
+

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/carbon-home/repository/conf/certificate-config.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<CertificateConfigurations>
+    <CertificateKeystore>
+        <!-- Certificate Keystore file location-->
+        <CertificateKeystoreLocation>${carbon.home}/repository/conf/security/wso2certs.jks</CertificateKeystoreLocation>
+        <!-- Certificate Keystore type (JKS/PKCS12 etc.)-->
+        <CertificateKeystoreType>JKS</CertificateKeystoreType>
+        <!-- Certificate Keystore password-->
+        <CertificateKeystorePassword>wso2carbon</CertificateKeystorePassword>
+        <!-- Certificate authority certificate alias -->
+        <CACertAlias>cacert</CACertAlias>
+        <!-- Certificate authority private key password -->
+        <CAPrivateKeyPassword>cacert</CAPrivateKeyPassword>
+        <!-- Registration authority certificate alias -->
+        <RACertAlias>racert</RACertAlias>
+        <!-- Registration authority private key password -->
+        <RAPrivateKeyPassword>racert</RAPrivateKeyPassword>
+    </CertificateKeystore>
+</CertificateConfigurations>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/carbon-home/repository/conf/datasources/master-datasources.xml

@@ -0,0 +1,85 @@
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<datasources-configuration xmlns:svns="http://org.wso2.securevault/configuration">
+  
+    <providers>
+        <provider>org.wso2.carbon.ndatasource.rdbms.RDBMSDataSourceReader</provider>
+    </providers>
+  
+    <datasources>
+      
+        <datasource>
+            <name>WSO2_CARBON_DB</name>
+            <description>The datasource used for registry and user manager</description>
+            <jndiConfig>
+                <name>jdbc/WSO2CarbonDB</name>
+            </jndiConfig>
+            <definition type="RDBMS">
+                <configuration>
+                    <url>jdbc:h2:repository/database/WSO2CARBON_DB;DB_CLOSE_ON_EXIT=FALSE;LOCK_TIMEOUT=60000</url>
+                    <username>wso2carbon</username>
+                    <password>wso2carbon</password>
+                    <driverClassName>org.h2.Driver</driverClassName>
+                    <maxActive>50</maxActive>
+                    <maxWait>60000</maxWait>
+                    <testOnBorrow>true</testOnBorrow>
+                    <validationQuery>SELECT 1</validationQuery>
+                    <validationInterval>30000</validationInterval>
+                    <defaultAutoCommit>false</defaultAutoCommit>
+                </configuration>
+            </definition>
+        </datasource>
+
+        <!-- For an explanation of the properties, see: http://people.apache.org/~fhanik/jdbc-pool/jdbc-pool.html -->
+        <!--datasource>
+            <name>SAMPLE_DATA_SOURCE</name>
+            <jndiConfig>
+                <name></name>
+                <environment>
+                    <property name="java.naming.factory.initial"></property>
+                    <property name="java.naming.provider.url"></property>
+                </environment>
+            </jndiConfig>
+            <definition type="RDBMS">
+                <configuration>
+
+                    <defaultAutoCommit></defaultAutoCommit>
+                    <defaultReadOnly></defaultReadOnly>
+                    <defaultTransactionIsolation>NONE|READ_COMMITTED|READ_UNCOMMITTED|REPEATABLE_READ|SERIALIZABLE</defaultTransactionIsolation>
+                    <defaultCatalog></defaultCatalog>
+                    <username></username>
+                    <password svns:secretAlias="WSO2.DB.Password"></password>
+                    <maxActive></maxActive>
+                    <maxIdle></maxIdle>
+                    <initialSize></initialSize>
+                    <maxWait></maxWait>
+
+                    <dataSourceClassName>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</dataSourceClassName>
+                    <dataSourceProps>
+                        <property name="url">jdbc:mysql://localhost:3306/Test1</property>
+                        <property name="user">root</property>
+                        <property name="password">123</property>
+                    </dataSourceProps>
+
+                </configuration>
+            </definition>
+        </datasource-->
+
+    </datasources>
+
+</datasources-configuration>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/carbon-home/repository/conf/log4j.properties

@@ -0,0 +1,165 @@
+#
+# Copyright 2017 WSO2, Inc. (http://wso2.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# This is the log4j configuration file used by WSO2 Carbon
+#
+# IMPORTANT : Please do not remove or change the names of any
+# of the Appenders defined here. The layout pattern & log file
+# can be changed using the WSO2 Carbon Management Console, and those
+# settings will override the settings in this file.
+#
+
+log4j.rootLogger=INFO, CARBON_CONSOLE, CARBON_LOGFILE, CARBON_MEMORY, CARBON_SYS_LOG
+
+log4j.logger.AUDIT_LOG=INFO, AUDIT_LOGFILE
+log4j.logger.org.apache.axis2.wsdl.codegen.writer.PrettyPrinter=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.axis2.clustering=INFO, CARBON_CONSOLE, CARBON_LOGFILE
+log4j.logger.org.apache=INFO, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.catalina=WARN
+log4j.logger.org.apache.tomcat=WARN
+log4j.logger.org.wso2.carbon.apacheds=WARN
+log4j.logger.org.apache.directory.server.ldap=ERROR
+log4j.logger.org.apache.directory.server.core.event=WARN
+log4j.logger.com.atomikos=INFO,ATOMIKOS
+log4j.logger.org.quartz=WARN
+log4j.logger.org.apache.jackrabbit.webdav=WARN
+log4j.logger.org.apache.juddi=ERROR
+log4j.logger.org.apache.commons.digester.Digester=WARN
+log4j.logger.org.apache.jasper.compiler.TldLocationsCache=WARN
+log4j.logger.org.apache.qpid=WARN
+log4j.logger.org.apache.qpid.server.Main=INFO
+log4j.logger.qpid.message=WARN
+log4j.logger.qpid.message.broker.listening=INFO
+log4j.logger.org.apache.tiles=WARN
+log4j.logger.org.apache.commons.httpclient=ERROR
+log4j.logger.org.apache.coyote=WARN
+log4j.logger.org.apache.solr=ERROR
+log4j.logger.me.prettyprint.cassandra.hector.TimingLogger=ERROR
+log4j.logger.org.wso2=INFO
+log4j.logger.org.apache.axis2.enterprise=FATAL, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.opensaml.xml=WARN, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.shared.ldap=WARN, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.server.ldap.handlers=WARN, CARBON_LOGFILE, CARBON_MEMORY
+#Following are to remove false error messages from startup (IS)
+log4j.logger.org.apache.directory.shared.ldap.entry.DefaultServerAttribute=FATAL, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.server.core.DefaultDirectoryService=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.shared.ldap.ldif.LdifReader=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.server.ldap.LdapProtocolHandler=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.server.core=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+log4j.logger.org.apache.directory.server.ldap.LdapSession=ERROR, CARBON_LOGFILE, CARBON_MEMORY
+#Hive Related Log configurations
+log4j.logger.DataNucleus=ERROR
+log4j.logger.Datastore=ERROR
+log4j.logger.Datastore.Schema=ERROR
+log4j.logger.JPOX.Datastore=ERROR
+log4j.logger.JPOX.Plugin=ERROR
+log4j.logger.JPOX.MetaData=ERROR
+log4j.logger.JPOX.Query=ERROR
+log4j.logger.JPOX.General=ERROR
+log4j.logger.JPOX.Enhancer=ERROR
+log4j.logger.org.apache.hadoop.hive=WARN
+log4j.logger.hive=WARN
+log4j.logger.ExecMapper=WARN
+log4j.logger.ExecReducer=WARN
+log4j.logger.net.sf.ehcache.config.ConfigurationFactory=ERROR
+
+log4j.logger.trace.messages=TRACE,CARBON_TRACE_LOGFILE
+
+log4j.additivity.org.apache.axis2.clustering=false
+log4j.additivity.com.atomikos=false
+log4j.additivity.org.apache=false
+
+# CARBON_CONSOLE is set to be a ConsoleAppender using a PatternLayout.
+log4j.appender.CARBON_CONSOLE=org.wso2.carbon.utils.logging.appenders.CarbonConsoleAppender
+log4j.appender.CARBON_CONSOLE.layout=org.wso2.carbon.utils.logging.TenantAwarePatternLayout
+# ConversionPattern will be overridden by the configuration setting in the DB
+log4j.appender.CARBON_CONSOLE.layout.ConversionPattern=[%d] %P%5p {%c} - %x %m%n
+log4j.appender.CARBON_CONSOLE.layout.TenantPattern=%U%@%D[%T]
+log4j.appender.CARBON_CONSOLE.threshold=DEBUG
+
+# CARBON_MEMORY is set to be a MemoryAppender using a PatternLayout.
+log4j.appender.CARBON_MEMORY=org.wso2.carbon.utils.logging.appenders.MemoryAppender
+log4j.appender.CARBON_MEMORY.layout=org.apache.log4j.PatternLayout
+log4j.appender.CARBON_MEMORY.bufferSize=200
+# ConversionPattern will be overridden by the configuration setting in the DB
+#log4j.appender.CARBON_MEMORY.layout.ConversionPattern=[%d] %5p - %x %m {%c}%n
+log4j.appender.CARBON_MEMORY.layout.ConversionPattern=[%d] %5p {%c} - %x %m %n
+log4j.appender.CARBON_MEMORY.threshold=DEBUG
+
+
+# CARBON_LOGFILE is set to be a DailyRollingFileAppender using a PatternLayout.
+log4j.appender.CARBON_LOGFILE=org.wso2.carbon.utils.logging.appenders.CarbonDailyRollingFileAppender
+# Log file will be overridden by the configuration setting in the DB
+# This path should be relative to WSO2 Carbon Home
+log4j.appender.CARBON_LOGFILE.File=${carbon.home}/repository/logs/${instance.log}/wso2carbon${instance.log}.log
+log4j.appender.CARBON_LOGFILE.Append=true
+log4j.appender.CARBON_LOGFILE.layout=org.wso2.carbon.utils.logging.TenantAwarePatternLayout
+# ConversionPattern will be overridden by the configuration setting in the DB
+log4j.appender.CARBON_LOGFILE.layout.ConversionPattern=TID: [%T] [%S] [%d] %P%5p {%c} - %x %m %n
+log4j.appender.CARBON_LOGFILE.layout.TenantPattern=%U%@%D [%T] [%S]
+log4j.appender.CARBON_LOGFILE.threshold=DEBUG
+
+log4j.appender.CARBON_SYS_LOG = org.apache.log4j.net.SyslogAppender
+log4j.appender.CARBON_SYS_LOG.layout=org.apache.log4j.PatternLayout
+log4j.appender.CARBON_SYS_LOG.layout.ConversionPattern=[%d] %5p {%c} - %x %m %n
+log4j.appender.CARBON_SYS_LOG.SyslogHost=localhost
+log4j.appender.CARBON_SYS_LOG.Facility=USER
+log4j.appender.CARBON_SYS_LOG.threshold=DEBUG
+
+# LOGEVENT is set to be a LogEventAppender using a PatternLayout to send logs to LOGEVENT 
+log4j.appender.LOGEVENT=org.wso2.carbon.logging.service.appender.LogEventAppender
+log4j.appender.LOGEVENT.url=tcp://10.100.3.103:7611
+log4j.appender.LOGEVENT.layout=org.wso2.carbon.utils.logging.TenantAwarePatternLayout
+log4j.appender.LOGEVENT.columnList=%T,%S,%A,%d,%c,%p,%m,%H,%I,%Stacktrace
+log4j.appender.LOGEVENT.userName=admin
+log4j.appender.LOGEVENT.password=admin
+#log4j.appender.LOGEVENT.password=secretAlias:Log4j.Appender.LOGEVENT.Password
+
+# Appender config to CARBON_TRACE_LOGFILE
+log4j.appender.CARBON_TRACE_LOGFILE=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.CARBON_TRACE_LOGFILE.File=${carbon.home}/repository/logs/${instance.log}/wso2carbon-trace-messages${instance.log}.log
+log4j.appender.CARBON_TRACE_LOGFILE.Append=true
+log4j.appender.CARBON_TRACE_LOGFILE.layout=org.wso2.carbon.utils.logging.TenantAwarePatternLayout
+log4j.appender.CARBON_TRACE_LOGFILE.layout.ConversionPattern=[%d] %P%5p {%c} - %x %m %n
+log4j.appender.CARBON_TRACE_LOGFILE.layout.TenantPattern=%U%@%D [%T] [%S]
+log4j.appender.CARBON_TRACE_LOGFILE.threshold=TRACE
+log4j.additivity.trace.messages=false
+
+# Appender config to AUDIT_LOGFILE
+log4j.appender.AUDIT_LOGFILE=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.AUDIT_LOGFILE.File=${carbon.home}/repository/logs/audit.log
+log4j.appender.AUDIT_LOGFILE.Append=true
+log4j.appender.AUDIT_LOGFILE.layout=org.wso2.carbon.utils.logging.TenantAwarePatternLayout
+log4j.appender.AUDIT_LOGFILE.layout.ConversionPattern=[%d] %P%5p {%c}- %x %m %n
+log4j.appender.AUDIT_LOGFILE.layout.TenantPattern=%U%@%D [%T] [%S]
+log4j.appender.AUDIT_LOGFILE.threshold=INFO
+log4j.additivity.AUDIT_LOG=false
+
+# Appender config to send Atomikos transaction logs to new log file tm.out.
+log4j.appender.ATOMIKOS = org.apache.log4j.RollingFileAppender
+log4j.appender.ATOMIKOS.File = repository/logs/tm.out
+log4j.appender.ATOMIKOS.Append = true
+log4j.appender.ATOMIKOS.layout = org.apache.log4j.PatternLayout
+log4j.appender.ATOMIKOS.layout.ConversionPattern=%p %t %c - %m%n
+
+# This file is used to override the default logger settings, and is used to remove unwanted logs from Shindig appearing on the console.
+
+# Specification of Handler used by Console Logger
+handlers=java.util.logging.ConsoleHandler
+
+# Replacing default INFO level with SEVERE
+java.util.logging.ConsoleHandler.level=SEVERE

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/certificate-config.xml

@@ -1,8 +1,25 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
 <CertificateConfigurations>
     <CertificateKeystore>
         <!-- Certificate Keystore file location-->
-        <CertificateKeystoreLocation>${carbon.home}/repository/resources/security/wso2certs.jks</CertificateKeystoreLocation>
+        <CertificateKeystoreLocation>${carbon.home}/repository/resources/wso2certs.jks</CertificateKeystoreLocation>
         <!-- Certificate Keystore type (JKS/PKCS12 etc.)-->
         <CertificateKeystoreType>JKS</CertificateKeystoreType>
         <!-- Certificate Keystore password-->

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/data-source-config.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<DataSourceConfig>
+    <Url>jdbc:h2:mem:cdm-test-db;DB_CLOSE_ON_EXIT=FALSE;MVCC=true</Url>
+    <DriverClassName>org.h2.Driver</DriverClassName>
+    <User>wso2carbon</User>
+    <Password>wso2carbon</Password>
+
+
+    <!-- For MySql -->
+
+    <!--<Url>jdbc:mysql://localhost:3306/WSO2CDM</Url>-->
+    <!--<DriverClassName>com.mysql.jdbc.Driver</DriverClassName>-->
+    <!--<User>root</User>-->
+    <!--<Password></Password>-->
+</DataSourceConfig>

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/log4j.properties

@@ -1,33 +0,0 @@
-#
-# Copyright 2015 WSO2, Inc. (http://wso2.com)
-#
-# WSO2 Inc. licenses this file to you under the Apache License,
-# version 2.0 (the "License"); you may not use this file except
-# in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-#
-# This is the log4j configuration file used by WSO2 Carbon
-#
-# IMPORTANT : Please do not remove or change the names of any
-# of the Appenders defined here. The layout pattern & log file
-# can be changed using the WSO2 Carbon Management Console, and those
-# settings will override the settings in this file.
-#
-
-log4j.rootLogger=INFO, STD_OUT
- 
-# Redirect log messages to console
-log4j.appender.STD_OUT=org.apache.log4j.ConsoleAppender
-log4j.appender.STD_OUT.Target=System.out
-log4j.appender.STD_OUT.layout=org.apache.log4j.PatternLayout
-log4j.appender.STD_OUT.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/sql/h2.sql

@@ -0,0 +1,25 @@
+--
+-- Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+--
+-- WSO2 Inc. licenses this file to you under the Apache License,
+-- Version 2.0 (the "License"); you may not use this file except
+-- in compliance with the License.
+-- You may obtain a copy of the License at
+--
+-- http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing,
+-- software distributed under the License is distributed on an
+-- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+-- KIND, either express or implied.  See the License for the
+-- specific language governing permissions and limitations
+-- under the License.
+
+CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE (
+      ID                    INTEGER auto_increment NOT NULL,
+      SERIAL_NUMBER            VARCHAR(500) DEFAULT NULL,
+    	CERTIFICATE                  BLOB DEFAULT NULL,
+    	TENANT_ID INTEGER DEFAULT 0,
+    	USERNAME  VARCHAR(500) DEFAULT NULL,
+    	PRIMARY KEY (ID)
+);

components/certificate-mgt/org.wso2.carbon.certificate.mgt.core/src/test/resources/testng.xml

@@ -1,12 +1,33 @@
 <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+<suite name="CertificateManagementServiceImplTests">
 
-<suite name="iOS-MDM-Tests">
     <test name="Operatoin Bean validation tests" preserve-order="true">
         <classes>
+            <class name="org.wso2.carbon.certificate.mgt.core.common.BaseDeviceManagementCertificateTest"/>
+            <class name="org.wso2.carbon.certificate.mgt.core.common.DataSourceConfig"/>
+            <class name="org.wso2.carbon.certificate.mgt.core.impl.CertificateManagementServiceImplTests"/>
             <class name="org.wso2.carbon.certificate.mgt.core.impl.CertificateGeneratorTestSuite"/>
             <class name="org.wso2.carbon.certificate.mgt.core.util.CommonUtil"/>
             <class name="org.wso2.carbon.certificate.mgt.core.impl.CertificateGeneratorTests"/>
             <class name="org.wso2.carbon.certificate.mgt.core.impl.KeyGeneratorTests"/>
         </classes>
     </test>
-</suite>
+</suite>
+

components/certificate-mgt/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.wso2.carbon.devicemgt</groupId>
     <artifactId>certificate-mgt</artifactId>
-    <version>3.0.119-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - Certificate Management Component</name>
     <url>http://wso2.org</url>

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.device.type.deployer/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.pull.notification/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.push.notification.provider.fcm/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.push.notification.provider.http/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.push.notification.provider.mqtt/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/org.wso2.carbon.device.mgt.extensions.push.notification.provider.xmpp/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt-extensions/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>carbon-devicemgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 

components/device-mgt/org.wso2.carbon.device.mgt.analytics.dashboard/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>device-mgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt/org.wso2.carbon.device.mgt.analytics.data.publisher/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>device-mgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt/org.wso2.carbon.device.mgt.api/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt/org.wso2.carbon.device.mgt.common/pom.xml

@@ -21,7 +21,7 @@
     <parent>
         <artifactId>device-mgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

components/device-mgt/org.wso2.carbon.device.mgt.core/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>device-mgt</artifactId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -224,10 +224,7 @@
         <dependency>
             <groupId>org.powermock</groupId>
             <artifactId>powermock-module-testng</artifactId>
-        </dependency>
+            <scope>test</scope>
-        <dependency>
-            <groupId>org.powermock</groupId>
-            <artifactId>powermock-api-mockito</artifactId>
         </dependency>
         <dependency>
             <groupId>org.wso2.carbon</groupId>
@@ -353,7 +350,11 @@
 		<dependency>
 			<groupId>javassist</groupId>
 			<artifactId>javassist</artifactId>
-		</dependency>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito</artifactId>
+        </dependency>
     </dependencies>
 
 </project>

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/authorization/DeviceAccessAuthorizationServiceImpl.java

@@ -20,11 +20,10 @@ package org.wso2.carbon.device.mgt.core.authorization;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.CarbonConstants;
 import org.wso2.carbon.context.CarbonContext;
-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.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
 import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationService;
 import org.wso2.carbon.device.mgt.common.authorization.DeviceAuthorizationResult;
@@ -36,11 +35,9 @@ import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.core.permission.mgt.PermissionUtils;
 import org.wso2.carbon.user.api.UserRealm;
 import org.wso2.carbon.user.api.UserStoreException;
-
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
+
 
 /**
  * Implementation of DeviceAccessAuthorization service.
@@ -233,7 +230,7 @@ public class DeviceAccessAuthorizationServiceImpl implements DeviceAccessAuthori
             return userRealm.getAuthorizationManager()
                     .isUserAuthorized(removeTenantDomain(username),
                                       PermissionUtils.getAbsolutePermissionPath(CDM_ADMIN_PERMISSION),
-                                      PermissionMethod.UI_EXECUTE);
+                            CarbonConstants.UI_PERMISSION_ACTION);
         }
         return false;
     }
@@ -265,22 +262,6 @@ public class DeviceAccessAuthorizationServiceImpl implements DeviceAccessAuthori
         return PermissionUtils.putPermission(permission);
     }
 
-    private Map<String, String> getOwnershipOfDevices(List<Device> devices) {
-        Map<String, String> ownershipData = new HashMap<>();
-        EnrolmentInfo enrolmentInfo;
-        String owner;
-        for (Device device : devices) {
-            enrolmentInfo = device.getEnrolmentInfo();
-            if (enrolmentInfo != null) {
-                owner = enrolmentInfo.getOwner();
-                if (owner != null && !owner.isEmpty()) {
-                    ownershipData.put(device.getDeviceIdentifier(), owner);
-                }
-            }
-        }
-        return ownershipData;
-    }
-
     public static final class PermissionMethod {
         public static final String READ = "read";
         public static final String WRITE = "write";

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/config/DeviceConfigurationManager.java

@@ -57,9 +57,9 @@ public class DeviceConfigurationManager {
         return deviceConfigManager;
     }
 
-    public synchronized void initConfig() throws DeviceManagementException {
+    public synchronized void initConfig(String configLocation) throws DeviceManagementException {
         try {
-            File deviceMgtConfig = new File(DeviceConfigurationManager.DEVICE_MGT_CONFIG_PATH);
+            File deviceMgtConfig = new File(configLocation);
             Document doc = DeviceManagerUtil.convertToDocument(deviceMgtConfig);
 
             /* Un-marshaling Device Management configuration */
@@ -72,15 +72,8 @@ public class DeviceConfigurationManager {
         }
     }
 
-    private static Schema getSchema() throws DeviceManagementException {
+    public void initConfig() throws DeviceManagementException {
-        try {
+        this.initConfig(DEVICE_MGT_CONFIG_PATH);
-            File deviceManagementSchemaConfig = new File(DeviceConfigurationManager.DEVICE_MGT_CONFIG_SCHEMA_PATH);
-            SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
-            return factory.newSchema(deviceManagementSchemaConfig);
-        } catch (SAXException e) {
-            throw new DeviceManagementException("Error occurred while initializing the schema of " +
-                    "device-mgt-config.xml", e);
-        }
     }
 
     public DeviceManagementConfig getDeviceManagementConfig() {

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

@@ -122,7 +122,14 @@ public abstract class AbstractDeviceDAOImpl implements DeviceDAO {
                     "e.DATE_OF_ENROLMENT, e.ID AS ENROLMENT_ID FROM DM_ENROLMENT e, (SELECT d.ID, d.DESCRIPTION, d.NAME, " +
                     "t.NAME AS DEVICE_TYPE, d.DEVICE_IDENTIFICATION FROM DM_DEVICE d, DM_DEVICE_TYPE t WHERE " +
                     "t.NAME = ? AND t.ID = d.DEVICE_TYPE_ID AND d.DEVICE_IDENTIFICATION = ? AND d.TENANT_ID = ?) d1 WHERE d1.ID = e.DEVICE_ID " +
-                    "AND TENANT_ID = ? ORDER BY e.DATE_OF_LAST_UPDATE DESC";
+                    "AND TENANT_ID = ? ORDER BY e.DATE_OF_LAST_UPDATE DESC, e.STATUS ASC";
+            // Status adeed as an orderby clause to fix a bug : when an existing device is
+            // re-enrolled, earlier enrollment is marked as removed and a new enrollment is added.
+            // However, both enrollments share the same time stamp. When retrieving the device
+            // due to same timestamp, enrollment information is incorrect, intermittently. Hence
+            // status also should be taken into consideration when ordering. This should not present a
+            // problem for other status transitions, as there would be an intermediary removed
+            // state in between.
             stmt = conn.prepareStatement(sql);
             stmt.setString(1, deviceIdentifier.getType());
             stmt.setString(2, deviceIdentifier.getId());

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/geo/service/GeoLocationProviderServiceImpl.java

@@ -390,7 +390,7 @@ public class GeoLocationProviderServiceImpl implements GeoLocationProviderServic
         }
     }
 
-    private EventProcessorAdminServiceStub getEventProcessorAdminServiceStub() throws JWTClientException {
+    protected EventProcessorAdminServiceStub getEventProcessorAdminServiceStub() throws JWTClientException {
         //send alert to event-processing
         String eventProcessorAdminServiceWSUrl = Utils.replaceSystemProperty(GeoServices.DAS_URL) +
                 "/services/EventProcessorAdminService";

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationEnrolmentMapping.java

@@ -25,12 +25,12 @@ import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
  */
 public class OperationEnrolmentMapping {
 
-    int enrolmentId;
+    private int enrolmentId;
-    int tenantId;
+    private int tenantId;
-    long createdTime;
+    private long createdTime;
-    String deviceType;
+    private String deviceType;
-    String deviceId;
+    private String deviceId;
-    EnrolmentInfo.Status deviceStatus;
+    private EnrolmentInfo.Status deviceStatus;
 
     public int getTenantId() {
         return tenantId;

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationManagerImpl.java

@@ -141,7 +141,7 @@ public class OperationManagerImpl implements OperationManager {
                 org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation operationDto =
                         OperationDAOUtil.convertOperation(operation);
                 int operationId = this.lookupOperationDAO(operation).addOperation(operationDto);
-                boolean isScheduledOperation = this.isTaskScheduledOperation(operation, deviceIds);
+                boolean isScheduledOperation = this.isTaskScheduledOperation(operation);
                 boolean isNotRepeated = false;
                 boolean isScheduled = false;
 
@@ -344,18 +344,22 @@ public class OperationManagerImpl implements OperationManager {
         PaginationResult paginationResult = null;
         List<Operation> operations = new ArrayList<>();
         String owner = request.getOwner();
+        try {
+            if (!DeviceManagerUtil.isDeviceExists(deviceId)) {
+                throw new OperationManagementException("Device not found for given device " +
+                        "Identifier:" + deviceId.getId() + " and given type : " +
+                        deviceId.getType());
+            }
+        } catch (DeviceManagementException e) {
+            throw new OperationManagementException("Error while checking the existence of the device identifier - "
+                    + deviceId.getId() + " of the device type - " + deviceId.getType(), e);
+        }
         if (!isActionAuthorized(deviceId)) {
             throw new OperationManagementException("User '" + getUser() + "' is not authorized to access the '" +
                     deviceId.getType() + "' device, which carries the identifier '" +
                     deviceId.getId() + "' of owner '" + owner + "'");
         }
-
         EnrolmentInfo enrolmentInfo = this.getEnrolmentInfo(deviceId, owner);
-        if (enrolmentInfo == null) {
-            throw new OperationManagementException("Device not found for given device " +
-                    "Identifier:" + deviceId.getId() + " and given type" +
-                    deviceId.getType());
-        }
         int enrolmentId = enrolmentInfo.getId();
         try {
             OperationManagementDAOFactory.openConnection();
@@ -530,9 +534,8 @@ public class OperationManagerImpl implements OperationManager {
         try {
             int enrolmentId = enrolmentInfo.getId();
             OperationManagementDAOFactory.beginTransaction();
-            boolean isUpdated = false;
             if (operation.getStatus() != null) {
-                isUpdated = operationDAO.updateOperationStatus(enrolmentId, operationId,
+                 operationDAO.updateOperationStatus(enrolmentId, operationId,
                         org.wso2.carbon.device.mgt.core.dto.operation.mgt.
                                 Operation.Status.valueOf(operation.getStatus().
                                 toString()));
@@ -806,25 +809,6 @@ public class OperationManagerImpl implements OperationManager {
         }
     }
 
-    private OperationDAO lookupOperationDAO(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation operation) {
-
-        if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.CommandOperation ||
-                operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.COMMAND)) {
-            return commandOperationDAO;
-        } else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.ProfileOperation ||
-                operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.PROFILE)) {
-            return profileOperationDAO;
-        } else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.ConfigOperation ||
-                operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.CONFIG)) {
-            return configOperationDAO;
-        } else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.PolicyOperation ||
-                operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.POLICY)) {
-            return policyOperationDAO;
-        } else {
-            return operationDAO;
-        }
-    }
-
     private String getUser() {
         return CarbonContext.getThreadLocalCarbonContext().getUsername();
     }
@@ -867,26 +851,6 @@ public class OperationManagerImpl implements OperationManager {
         return isUserAuthorized;
     }
 
-    private int getEnrolmentByStatus(DeviceIdentifier deviceId,
-                                     EnrolmentInfo.Status status) throws OperationManagementException {
-        int enrolmentId;
-        try {
-            DeviceManagementDAOFactory.openConnection();
-            int tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
-            enrolmentId = deviceDAO.getEnrolmentByStatus(deviceId, status, tenantId);
-        } catch (DeviceManagementDAOException e) {
-            throw new OperationManagementException("Error occurred while retrieving metadata of '" +
-                    deviceId.getType() + "' device carrying the identifier '" +
-                    deviceId.getId() + "'", e);
-        } catch (SQLException e) {
-            throw new OperationManagementException(
-                    "Error occurred while opening a connection to the data source", e);
-        } finally {
-            DeviceManagementDAOFactory.closeConnection();
-        }
-        return enrolmentId;
-    }
-
     private EnrolmentInfo getEnrolmentInfo(DeviceIdentifier deviceId, String owner) throws OperationManagementException {
         EnrolmentInfo enrolmentInfo = null;
         try {
@@ -959,39 +923,15 @@ public class OperationManagerImpl implements OperationManager {
         return updateStatus;
     }
 
-    private boolean isTaskScheduledOperation(Operation operation, List<DeviceIdentifier> deviceIds) {
+    private boolean isTaskScheduledOperation(Operation operation) {
         DeviceManagementProviderService deviceManagementProviderService = DeviceManagementDataHolder.getInstance().
                 getDeviceManagementProvider();
-
         List<MonitoringOperation> monitoringOperations = deviceManagementProviderService.getMonitoringOperationList(deviceType);//Get task list from each device type
-
         for (MonitoringOperation op : monitoringOperations) {
             if (operation.getCode().equals(op.getTaskName())) {
                 return true;
             }
         }
-
-//        for(String dti : taskOperation){
-//            if (dti.equals(deviceType)) {
-//                monitoringOperations = deviceTypeSpecificTasks.get(dti);
-//
-//            }
-//        }
-//
-//        for(DeviceIdentifier deviceIdentifier : deviceIds){
-//            String deviceType = deviceIdentifier.getType();
-//
-//
-//
-//        }
-
-//        TaskConfiguration taskConfiguration = DeviceConfigurationManager.getInstance().getDeviceManagementConfig().
-//                getTaskConfiguration();
-//        for (TaskConfiguration.Operation op : taskConfiguration.getOperations()) {
-//            if (operation.getCode().equals(op.getOperationName())) {
-//                return true;
-//            }
-//        }
         return false;
     }
 

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/OperationMgtConstants.java

@@ -22,7 +22,6 @@ public class OperationMgtConstants {
 
     public final class DeviceConstants {
         private DeviceConstants() {
-            throw new AssertionError();
         }
 
         public static final String DEVICE_ID_NOT_FOUND = "Device not found for device id: %s";
@@ -30,8 +29,8 @@ public class OperationMgtConstants {
 
     public final class OperationCodes {
         private OperationCodes() {
-            throw new AssertionError();
         }
+
         public static final String POLICY_REVOKE = "POLICY_REVOKE";
     }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/operation/mgt/dao/OperationDAO.java

@@ -31,8 +31,6 @@ public interface OperationDAO {
 
     int addOperation(Operation operation) throws OperationManagementDAOException;
 
-    void updateOperation(Operation operation) throws OperationManagementDAOException;
-
     Operation getOperation(int operationId) throws OperationManagementDAOException;
 
     Operation getOperationByDeviceAndId(int enrolmentId, int operationId) throws OperationManagementDAOException;
@@ -66,8 +64,6 @@ public interface OperationDAO {
 
     Activity getActivityByDevice(int operationId, int deviceId) throws OperationManagementDAOException;
 
-    List<Activity> getActivitiesUpdatedAfter(long timestamp) throws OperationManagementDAOException;
-
     List<Activity> getActivitiesUpdatedAfter(long timestamp, int limit, int offset) throws OperationManagementDAOException;
 
     int getActivityCountUpdatedAfter(long timestamp) throws OperationManagementDAOException;

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

@@ -53,23 +53,6 @@ public class CommandOperationDAOImpl extends GenericOperationDAOImpl {
         return operationId;
     }
 
-    @Override
-    public void updateOperation(Operation operation) throws OperationManagementDAOException {
-        PreparedStatement stmt = null;
-        try {
-            Connection connection = OperationManagementDAOFactory.getConnection();
-            stmt = connection.prepareStatement(
-                    "UPDATE DM_COMMAND_OPERATION SET ENABLED = ? WHERE OPERATION_ID = ?");
-            stmt.setBoolean(1, operation.isEnabled());
-            stmt.setInt(2, operation.getId());
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new OperationManagementDAOException("Error occurred while adding operation metadata", e);
-        } finally {
-            OperationManagementDAOUtil.cleanupResources(stmt);
-        }
-    }
-
     public CommandOperation getOperation(int id) throws OperationManagementDAOException {
         PreparedStatement stmt = null;
         ResultSet rs = null;

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

@@ -58,46 +58,6 @@ public class ConfigOperationDAOImpl extends GenericOperationDAOImpl {
         return operationId;
     }
 
-    @Override
-    public void updateOperation(Operation operation) throws OperationManagementDAOException {
-        PreparedStatement stmt = null;
-        ByteArrayOutputStream bao = null;
-        ObjectOutputStream oos = null;
-        try {
-            super.updateOperation(operation);
-            Connection connection = OperationManagementDAOFactory.getConnection();
-            stmt = connection.prepareStatement("UPDATE FROM DM_CONFIG_OPERATION SET OPERATION_CONFIG = ? " +
-                    "WHERE OPERATION_ID = ?");
-            bao = new ByteArrayOutputStream();
-            oos = new ObjectOutputStream(bao);
-            oos.writeObject(operation);
-
-            stmt.setBytes(1, bao.toByteArray());
-            stmt.setInt(2, operation.getId());
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new OperationManagementDAOException("Error occurred while update policy operation metadata", e);
-        } catch (IOException e) {
-            throw new OperationManagementDAOException("Error occurred while serializing policy operation object", e);
-        } finally {
-            if (bao != null) {
-                try {
-                    bao.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ByteArrayOutputStream", e);
-                }
-            }
-            if (oos != null) {
-                try {
-                    oos.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ObjectOutputStream", e);
-                }
-            }
-            OperationManagementDAOUtil.cleanupResources(stmt);
-        }
-    }
-
     @Override
     public Operation getOperation(int operationId) throws OperationManagementDAOException {
         PreparedStatement stmt = null;
@@ -118,6 +78,8 @@ public class ConfigOperationDAOImpl extends GenericOperationDAOImpl {
                 bais = new ByteArrayInputStream(operationDetails);
                 ois = new ObjectInputStream(bais);
                 configOperation = (ConfigOperation) ois.readObject();
+                configOperation.setId(rs.getInt("OPERATION_ID"));
+                configOperation.setEnabled(rs.getBoolean("ENABLED"));
             }
         } catch (IOException e) {
             throw new OperationManagementDAOException("IO Error occurred while de serialize the policy operation " +

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

@@ -85,23 +85,6 @@ public class GenericOperationDAOImpl implements OperationDAO {
         }
     }
 
-    @Override
-    public void updateOperation(Operation operation) throws OperationManagementDAOException {
-        PreparedStatement stmt = null;
-        try {
-            Connection connection = OperationManagementDAOFactory.getConnection();
-            stmt = connection.prepareStatement("UPDATE DM_OPERATION SET RECEIVED_TIMESTAMP=? " +
-                    "WHERE ID=?");
-            stmt.setTimestamp(1, new Timestamp(new Date().getTime()));
-            stmt.setInt(2, operation.getId());
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new OperationManagementDAOException("Error occurred while update operation metadata", e);
-        } finally {
-            OperationManagementDAOUtil.cleanupResources(stmt);
-        }
-    }
-
     public boolean updateOperationStatus(int enrolmentId, int operationId, Operation.Status status)
             throws OperationManagementDAOException {
         PreparedStatement stmt = null;
@@ -403,11 +386,6 @@ public class GenericOperationDAOImpl implements OperationDAO {
         return activity;
     }
 
-    @Override
-    public List<Activity> getActivitiesUpdatedAfter(long timestamp) throws OperationManagementDAOException {
-        return this.getActivitiesUpdatedAfter(timestamp, 0, 0);
-    }
-
     @Override
     public List<Activity> getActivitiesUpdatedAfter(long timestamp, int limit,
                                                     int offset) throws OperationManagementDAOException {

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

@@ -82,46 +82,6 @@ public class PolicyOperationDAOImpl extends GenericOperationDAOImpl {
         return operationId;
     }
 
-    @Override
-    public void updateOperation(Operation operation) throws OperationManagementDAOException {
-        PreparedStatement stmt = null;
-        ByteArrayOutputStream bao = null;
-        ObjectOutputStream oos = null;
-        try {
-            super.updateOperation(operation);
-            Connection connection = OperationManagementDAOFactory.getConnection();
-            stmt = connection.prepareStatement("UPDATE DM_POLICY_OPERATION SET OPERATION_DETAILS=? " +
-                    "WHERE OPERATION_ID=?");
-            bao = new ByteArrayOutputStream();
-            oos = new ObjectOutputStream(bao);
-            oos.writeObject(operation);
-
-            stmt.setBytes(1, bao.toByteArray());
-            stmt.setInt(2, operation.getId());
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new OperationManagementDAOException("Error occurred while update policy operation metadata", e);
-        } catch (IOException e) {
-            throw new OperationManagementDAOException("Error occurred while serializing policy operation object", e);
-        } finally {
-            if (bao != null) {
-                try {
-                    bao.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ByteArrayOutputStream", e);
-                }
-            }
-            if (oos != null) {
-                try {
-                    oos.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ObjectOutputStream", e);
-                }
-            }
-            OperationManagementDAOUtil.cleanupResources(stmt);
-        }
-    }
-
     @Override
     public Operation getOperation(int operationId) throws OperationManagementDAOException {
         PreparedStatement stmt = null;

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

@@ -82,47 +82,6 @@ public class ProfileOperationDAOImpl extends GenericOperationDAOImpl {
         return operationId;
     }
 
-    @Override
-    public void updateOperation(Operation operation) throws OperationManagementDAOException {
-        PreparedStatement stmt = null;
-        ByteArrayOutputStream bao = null;
-        ObjectOutputStream oos = null;
-        try {
-            super.updateOperation(operation);
-            Connection connection = OperationManagementDAOFactory.getConnection();
-            stmt = connection.prepareStatement("UPDATE DM_PROFILE_OPERATION SET OPERATION_DETAILS=? " +
-                    "WHERE OPERATION_ID=?");
-
-            bao = new ByteArrayOutputStream();
-            oos = new ObjectOutputStream(bao);
-            oos.writeObject(operation);
-
-            stmt.setBytes(1, bao.toByteArray());
-            stmt.setInt(2, operation.getId());
-            stmt.executeUpdate();
-        } catch (SQLException e) {
-            throw new OperationManagementDAOException("Error occurred while update operation metadata", e);
-        } catch (IOException e) {
-            throw new OperationManagementDAOException("Error occurred while serializing profile operation object", e);
-        } finally {
-            if (bao != null) {
-                try {
-                    bao.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ByteArrayOutputStream", e);
-                }
-            }
-            if (oos != null) {
-                try {
-                    oos.close();
-                } catch (IOException e) {
-                    log.warn("Error occurred while closing ObjectOutputStream", e);
-                }
-            }
-            OperationManagementDAOUtil.cleanupResources(stmt);
-        }
-    }
-
     public Operation getOperation(int id) throws OperationManagementDAOException {
         PreparedStatement stmt = null;
         ResultSet rs = null;

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderService.java

@@ -481,8 +481,6 @@ public interface DeviceManagementProviderService {
      */
     PlatformConfiguration getConfiguration(String deviceType) throws DeviceManagementException;
 
-    void updateDeviceEnrolmentInfo(Device device, EnrolmentInfo.Status active) throws DeviceManagementException;
-
     /**
      * This method is used to check whether the device is enrolled with the give user.
      *
@@ -510,8 +508,6 @@ public interface DeviceManagementProviderService {
 
     boolean enrollDevice(Device device) throws DeviceManagementException;
 
-    PlatformConfiguration getConfiguration() throws DeviceManagementException;
-
     boolean saveConfiguration(PlatformConfiguration configuration) throws DeviceManagementException;
 
     boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException;

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/service/DeviceManagementProviderServiceImpl.java

@@ -129,11 +129,6 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         return dms.saveConfiguration(configuration);
     }
 
-    @Override
-    public PlatformConfiguration getConfiguration() throws DeviceManagementException {
-        return null;
-    }
-
     @Override
     public PlatformConfiguration getConfiguration(String deviceType) throws DeviceManagementException {
         DeviceManager dms =
@@ -1746,6 +1741,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
             if (requireDeviceInfo) {
                 this.getAllDeviceInfo(userDevices);
             }
+            devices.addAll(userDevices);
         }
         return devices;
     }
@@ -1895,41 +1891,6 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
         return result;
     }
 
-    @Override
-    public void updateDeviceEnrolmentInfo(Device device, EnrolmentInfo.Status status) throws DeviceManagementException {
-        try {
-            if (device == null || status == null) {
-                String msg = "Received incomplete data for updateDeviceEnrolmentInfo";
-                log.error(msg);
-                throw new DeviceManagementException(msg);
-            }
-            if (log.isDebugEnabled()) {
-                log.debug("Updating enrolment for device: " + device.getId() + " of type '" + device.getType() + "'");
-            }
-            DeviceManagementDAOFactory.beginTransaction();
-            device.getEnrolmentInfo().setDateOfLastUpdate(new Date().getTime());
-            device.getEnrolmentInfo().setStatus(status);
-            deviceDAO.updateDevice(device, this.getTenantId());
-            DeviceManagementDAOFactory.commitTransaction();
-        } catch (DeviceManagementDAOException e) {
-            DeviceManagementDAOFactory.rollbackTransaction();
-            String msg = "Error occurred while updating device enrolment status for " + device.getDeviceIdentifier() +
-                    " of type " + device.getType();
-            log.error(msg, e);
-            throw new DeviceManagementException(msg, e);
-        } catch (TransactionManagementException e) {
-            String msg = "Error occurred while initiating transaction";
-            log.error(msg, e);
-            throw new DeviceManagementException(msg, e);
-        } catch (Exception e) {
-            String msg = "Error occurred in updateDeviceEnrolmentInfo";
-            log.error(msg, e);
-            throw new DeviceManagementException(msg, e);
-        } finally {
-            DeviceManagementDAOFactory.closeConnection();
-        }
-    }
-
     @Override
     public void registerDeviceManagementService(DeviceManagementService deviceManagementService) {
         if (log.isDebugEnabled()) {

components/device-mgt/org.wso2.carbon.device.mgt.core/src/main/java/org/wso2/carbon/device/mgt/core/util/DeviceManagerUtil.java

@@ -486,6 +486,13 @@ public final class DeviceManagerUtil {
         return true;
     }
 
+    public static boolean isDeviceExists(DeviceIdentifier deviceIdentifier) throws DeviceManagementException {
+        Device device = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().getDevice(deviceIdentifier,
+                false);
+        return !(device == null || device.getDeviceIdentifier() == null ||
+                device.getDeviceIdentifier().isEmpty() || device.getEnrolmentInfo() == null);
+    }
+
     private static CacheManager getCacheManager() {
         return Caching.getCacheManagerFactory().getCacheManager(DeviceManagementConstants.DM_CACHE_MANAGER);
     }

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

@@ -31,10 +31,18 @@ public class TestDeviceManagementService implements DeviceManagementService {
 
     private String providerType;
     private String tenantDomain;
+    private String operationCode;
+
+    public TestDeviceManagementService(String deviceType, String tenantDomain, String operationCode) {
+        providerType = deviceType;
+        this.tenantDomain = tenantDomain;
+        this.operationCode = operationCode;
+    }
 
     public TestDeviceManagementService(String deviceType, String tenantDomain) {
         providerType = deviceType;
         this.tenantDomain = tenantDomain;
+        this.operationCode = "default";
     }
 
     @Override
@@ -48,12 +56,10 @@ public class TestDeviceManagementService implements DeviceManagementService {
         taskConfig.setEnabled(true);
         taskConfig.setFrequency(3000);
         List<MonitoringOperation> monitoringOperations = new ArrayList<>();
-        for (int i = 0; i < 5; i++) {
+        MonitoringOperation monitoringOperation = new MonitoringOperation();
-            MonitoringOperation monitoringOperation = new MonitoringOperation();
+        monitoringOperation.setTaskName(operationCode);
-            monitoringOperation.setTaskName("OPERATION-" + i);
+        monitoringOperation.setRecurrentTimes(2);
-            monitoringOperation.setRecurrentTimes(i);
+        monitoringOperations.add(monitoringOperation);
-            monitoringOperations.add(monitoringOperation);
-        }
         taskConfig.setMonitoringOperation(monitoringOperations);
         return taskConfig;
     }

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

@@ -108,7 +108,10 @@ public class TestDeviceManager implements DeviceManager {
 
     @Override
     public License getLicense(String languageCode) throws LicenseManagementException {
-        return null;
+        License testLicense = new License();
+        testLicense.setText("This is a dummy license for test device type.");
+        testLicense.setLanguage("ENG");
+        return testLicense;
     }
 
     @Override

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

@@ -17,73 +17,34 @@
 */
 package org.wso2.carbon.device.mgt.core;
 
+import org.wso2.carbon.device.mgt.core.task.TestTaskManagerImpl;
 import org.wso2.carbon.ntask.common.TaskException;
 import org.wso2.carbon.ntask.core.TaskInfo;
 import org.wso2.carbon.ntask.core.TaskManager;
 import org.wso2.carbon.ntask.core.service.TaskService;
 
+import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 public class TestTaskServiceImpl implements TaskService {
+    private Set<String> registeredTaskTypes;
+    private TaskManager taskManager;
+
+    public TestTaskServiceImpl() {
+
+        this.registeredTaskTypes = new HashSet<>();
+        this.taskManager = new TestTaskManagerImpl();
+    }
+
+    public void setTaskManager(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
     @Override
     public TaskManager getTaskManager(String s) throws TaskException {
-        return new TaskManager() {
+        return this.taskManager;
-            @Override
-            public void initStartupTasks() throws TaskException {
-
-            }
-
-            @Override
-            public void scheduleTask(String s) throws TaskException {
-
-            }
-
-            @Override
-            public void rescheduleTask(String s) throws TaskException {
-
-            }
-
-            @Override
-            public boolean deleteTask(String s) throws TaskException {
-                return false;
-            }
-
-            @Override
-            public void pauseTask(String s) throws TaskException {
-
-            }
-
-            @Override
-            public void resumeTask(String s) throws TaskException {
-
-            }
-
-            @Override
-            public void registerTask(TaskInfo taskInfo) throws TaskException {
-
-            }
-
-            @Override
-            public TaskState getTaskState(String s) throws TaskException {
-                return null;
-            }
-
-            @Override
-            public TaskInfo getTask(String s) throws TaskException {
-                return null;
-            }
-
-            @Override
-            public List<TaskInfo> getAllTasks() throws TaskException {
-                return null;
-            }
-
-            @Override
-            public boolean isTaskScheduled(String s) throws TaskException {
-                return false;
-            }
-        };
     }
 
     @Override
@@ -93,12 +54,12 @@ public class TestTaskServiceImpl implements TaskService {
 
     @Override
     public void registerTaskType(String s) throws TaskException {
-
+        this.registeredTaskTypes.add(s);
     }
 
     @Override
     public Set<String> getRegisteredTaskTypes() {
-        return null;
+        return this.registeredTaskTypes;
     }
 
     @Override
@@ -108,7 +69,7 @@ public class TestTaskServiceImpl implements TaskService {
 
     @Override
     public boolean isServerInit() {
-        return false;
+        return true;
     }
 
     @Override

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

@@ -22,7 +22,16 @@ import org.apache.commons.logging.LogFactory;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.GroupPaginationRequest;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.registry.core.config.RegistryContext;
+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.core.service.RealmService;
 
+import java.io.InputStream;
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -58,7 +67,6 @@ public class TestUtils {
         }
     }
 
-
     public static DeviceGroup createDeviceGroup1(){
         DeviceGroup group = new DeviceGroup();
         group.setName("TEST_GROUP_01");
@@ -101,11 +109,21 @@ public class TestUtils {
     public static List<DeviceIdentifier> getDeviceIdentifiersList(){
         DeviceIdentifier identifier = new DeviceIdentifier();
         identifier.setId("12345");
-        identifier.setType("Test");
+        identifier.setType(TestDataHolder.TEST_DEVICE_TYPE);
 
         List<DeviceIdentifier> list = new ArrayList<>();
         list.add(identifier);
 
         return list;
     }
+
+    public static RegistryService getRegistryService(Class clazz) throws RegistryException {
+        RealmService realmService = new InMemoryRealmService();
+        RegistryDataHolder.getInstance().setRealmService(realmService);
+        DeviceManagementDataHolder.getInstance().setRealmService(realmService);
+        InputStream is = clazz.getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
+        RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
+        context.setSetup(true);
+        return context.getEmbeddedRegistryService();
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/authorization/DeviceAccessAuthorizationServiceTest.java

@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.device.mgt.core.authorization;
+
+import org.apache.commons.dbcp.BasicDataSource;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.mockito.Mockito;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.wso2.carbon.CarbonConstants;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+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.DeviceNotFoundException;
+import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
+import org.wso2.carbon.device.mgt.common.authorization.DeviceAuthorizationResult;
+import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
+import org.wso2.carbon.device.mgt.common.group.mgt.RoleDoesNotExistException;
+import org.wso2.carbon.device.mgt.common.permission.mgt.PermissionManagementException;
+import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
+import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
+import org.wso2.carbon.registry.core.config.RegistryContext;
+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.api.UserStoreManager;
+import org.wso2.carbon.user.api.Permission;
+import org.wso2.carbon.user.core.service.RealmService;
+import org.wso2.carbon.user.core.tenant.JDBCTenantManager;
+import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Arrays;
+
+/**
+ * Unit tests for DeviceAccessAuthorizationServiceTest
+ */
+public class DeviceAccessAuthorizationServiceTest {
+    private static final Log log = LogFactory.getLog(DeviceAccessAuthorizationServiceTest.class);
+    private static final String DEVICE_TYPE = "AUTH_SERVICE_TEST_TYPE";
+    private static final int NO_OF_DEVICES = 5;
+    private static final String ADMIN_USER = "admin";
+    private static final String NON_ADMIN_ALLOWED_USER = "nonAdmin";
+    private static final String NORMAL_USER = "normal";
+    private static final String ADMIN_ROLE = "adminRole";
+    private static final String NON_ADMIN_ROLE = "nonAdminRole";
+    private static final String DEFAULT_GROUP = "defaultGroup";
+    private static final String DEVICE_ID_PREFIX = "AUTH-SERVICE-TEST-DEVICE-ID-";
+    private static final String USER_CLAIM_EMAIL_ADDRESS = "http://wso2.org/claims/emailaddress";
+    private static final String USER_CLAIM_FIRST_NAME = "http://wso2.org/claims/givenname";
+    private static final String USER_CLAIM_LAST_NAME = "http://wso2.org/claims/lastname";
+    private static final String ADMIN_PERMISSION = "/permission/admin";
+    private static final String NON_ADMIN_PERMISSION = "/permission/admin/manage/device-mgt/devices/owning-device/view";
+    private static final String FIRST_NAME = "firstName";
+    private static final String LAST_NAME = "lastName";
+    private static final String EMAIL = "email";
+    private static final String PASSWORD = "password";
+    private DeviceAccessAuthorizationServiceImpl deviceAccessAuthorizationService;
+    private List<DeviceIdentifier> deviceIds = new ArrayList<>();
+    private List<DeviceIdentifier> groupDeviceIds = new ArrayList<>();
+    private Map<String, String> defaultUserClaims;
+
+    @BeforeClass
+    public void init() throws Exception {
+        DeviceConfigurationManager.getInstance().initConfig();
+        log.info("Initializing test environment to test DeviceAccessAuthorization Class");
+        for (int i = 0; i < NO_OF_DEVICES; i++) {
+            deviceIds.add(new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE));
+        }
+        List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
+        DeviceManagementProviderService deviceMgtService = new DeviceManagementProviderServiceImpl();
+        DeviceManagementServiceComponent.notifyStartupListeners();
+        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
+        DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
+        DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(new
+                GroupManagementProviderServiceImpl());
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
+        deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
+        for (Device device : devices) {
+            deviceMgtService.enrollDevice(device);
+        }
+        List<Device> returnedDevices = deviceMgtService.getAllDevices(DEVICE_TYPE);
+        for (Device device : returnedDevices) {
+            if (!device.getDeviceIdentifier().startsWith(DEVICE_ID_PREFIX)) {
+                throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
+            }
+        }
+        deviceAccessAuthorizationService = Mockito.mock(DeviceAccessAuthorizationServiceImpl.class,
+                Mockito.CALLS_REAL_METHODS);
+        defaultUserClaims = buildDefaultUserClaims(FIRST_NAME, LAST_NAME, EMAIL);
+        initializeTestEnvironment();
+        //Starting tenant flow
+        PrivilegedCarbonContext.startTenantFlow();
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(MultitenantConstants.SUPER_TENANT_ID, true);
+    }
+
+    private RegistryService getRegistryService() throws RegistryException, UserStoreException {
+        RealmService realmService = new InMemoryRealmService();
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        BasicDataSource dataSource = new BasicDataSource();
+        String connectionUrl = "jdbc:h2:./target/databasetest/CARBON_TEST";
+        dataSource.setUrl(connectionUrl);
+        dataSource.setDriverClassName("org.h2.Driver");
+        JDBCTenantManager jdbcTenantManager = new JDBCTenantManager(dataSource,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
+        realmService.setTenantManager(jdbcTenantManager);
+        RegistryDataHolder.getInstance().setRealmService(realmService);
+        DeviceManagementDataHolder.getInstance().setRealmService(realmService);
+        InputStream is = this.getClass().getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
+        RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
+        context.setSetup(true);
+        return context.getEmbeddedRegistryService();
+    }
+
+    private void initializeTestEnvironment() throws UserStoreException, GroupManagementException,
+            RoleDoesNotExistException, DeviceNotFoundException {
+        //creating UI permission
+        Permission adminPermission = new Permission(ADMIN_PERMISSION, CarbonConstants.UI_PERMISSION_ACTION);
+        Permission deviceViewPermission = new Permission(NON_ADMIN_PERMISSION, CarbonConstants.UI_PERMISSION_ACTION);
+        UserStoreManager userStoreManager = DeviceManagementDataHolder.getInstance().getRealmService()
+                .getTenantUserRealm(MultitenantConstants.SUPER_TENANT_ID).getUserStoreManager();
+        //Adding a non Admin User
+        userStoreManager.addUser(NON_ADMIN_ALLOWED_USER, PASSWORD, null, defaultUserClaims, null);
+        //Adding a normal user
+        userStoreManager.addUser(NORMAL_USER, PASSWORD, null, defaultUserClaims, null);
+        //Adding role with permission to Admin user
+        userStoreManager.addRole(ADMIN_ROLE, new String[]{ADMIN_USER}, new Permission[]{adminPermission});
+        //Adding role with permission to non Admin user
+        userStoreManager.addRole(NON_ADMIN_ROLE, new String[]{NON_ADMIN_ALLOWED_USER},
+                new Permission[]{deviceViewPermission});
+        //Creating default group
+        GroupManagementProviderService groupManagementProviderService = DeviceManagementDataHolder.getInstance()
+                .getGroupManagementProviderService();
+        groupManagementProviderService.createDefaultGroup(DEFAULT_GROUP);
+        int groupId = groupManagementProviderService.getGroup(DEFAULT_GROUP).getGroupId();
+        //Sharing group with admin and non admin roles
+        groupManagementProviderService.manageGroupSharing(groupId, new ArrayList<>(Arrays.asList(ADMIN_ROLE,
+                NON_ADMIN_ROLE)));
+        //Adding first 2 devices to the group
+        groupDeviceIds.add(deviceIds.get(0));
+        groupDeviceIds.add(deviceIds.get(1));
+        groupManagementProviderService.addDevices(groupId, groupDeviceIds);
+    }
+
+    private Map<String, String> buildDefaultUserClaims(String firstName, String lastName, String emailAddress) {
+        Map<String, String> defaultUserClaims = new HashMap<>();
+        defaultUserClaims.put(USER_CLAIM_FIRST_NAME, firstName);
+        defaultUserClaims.put(USER_CLAIM_LAST_NAME, lastName);
+        defaultUserClaims.put(USER_CLAIM_EMAIL_ADDRESS, emailAddress);
+        if (log.isDebugEnabled()) {
+            log.debug("Default claim map is created for new user: " + defaultUserClaims.toString());
+        }
+        return defaultUserClaims;
+    }
+
+    //Admin User test cases
+    @Test(description = "Check authorization giving a device identifier and username")
+    public void userAuthDevIdUserName() throws Exception {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        for (DeviceIdentifier deviceId : deviceIds) {
+            Assert.assertTrue(deviceAccessAuthorizationService.isUserAuthorized(deviceId, ADMIN_USER),
+                    "Device access authorization for admin user failed");
+        }
+    }
+
+    @Test(description = "Authorization for multiple device identifiers and username")
+    public void userAuthDevIdUserNameResult() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds, ADMIN_USER);
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 5,
+                "Expected 5 authorized devices for admin user");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 0,
+                "Expected 0 un-authorized devices for admin user");
+    }
+
+    @Test(description = "Authorization by device identifier")
+    public void userAuthDevId() throws Exception {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        for (DeviceIdentifier deviceId : deviceIds) {
+            Assert.assertTrue(deviceAccessAuthorizationService.isUserAuthorized(deviceId),
+                    "Authorize user from device identifier failed");
+        }
+    }
+
+    @Test(description = "Authorization by multiple device identifiers")
+    public void userAuthDevIdResult() throws Exception {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds);
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 5,
+                "Expected 5 authorized devices for admin user");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 0,
+                "Expected 0 un-authorized devices for admin user");
+    }
+
+    @Test(description = "Check current user is a device administrator")
+    public void isDevAdminAdminUser() throws DeviceAccessAuthorizationException, UserStoreException,
+            PermissionManagementException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        Assert.assertTrue(deviceAccessAuthorizationService.isDeviceAdminUser(),
+                "Admin user failed to authorize as admin");
+    }
+
+    //Non admin user tests
+    @Test(description = "Check authorization by device identifier and permission Allowed test case")
+    public void userAuthDevIdPermission() throws DeviceAccessAuthorizationException, UserStoreException,
+            PermissionManagementException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        Assert.assertTrue(deviceAccessAuthorizationService.isUserAuthorized(deviceIds.get(0),
+                new String[]{NON_ADMIN_PERMISSION}), "Non admin user with permissions attempt to access failed");
+    }
+
+    @Test(description = "Check authorization by device identifier and permission Not-allowed test case")
+    public void userAuthFalseDevIdPermission() throws DeviceAccessAuthorizationException, UserStoreException,
+            PermissionManagementException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        Assert.assertFalse(deviceAccessAuthorizationService.isUserAuthorized(deviceIds.get(3),
+                new String[]{NON_ADMIN_PERMISSION}), "Non admin user accessing not allowed device authorized");
+    }
+
+    @Test(description = "Authorization by giving a device identifier, username and permission Allowed test case")
+    public void userAuthDevIdUserNamePermission() throws DeviceAccessAuthorizationException, UserStoreException,
+            PermissionManagementException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        Assert.assertTrue(deviceAccessAuthorizationService.isUserAuthorized(deviceIds.get(0), NON_ADMIN_ALLOWED_USER,
+                new String[]{NON_ADMIN_PERMISSION}), "Non admin user with permissions attempt to access failed");
+    }
+
+    @Test(description = "Authorization by giving a device identifier, username and permission Not-allowed test case")
+    public void userAuthFalseDevIdUserNamePermission() throws DeviceAccessAuthorizationException, UserStoreException,
+            PermissionManagementException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        Assert.assertFalse(deviceAccessAuthorizationService.isUserAuthorized(deviceIds.get(3), NON_ADMIN_ALLOWED_USER,
+                new String[]{NON_ADMIN_PERMISSION}), "Non admin user accessing not allowed device authorized");
+    }
+
+    @Test(description = "Authorization by giving device identifiers and permission")
+    public void userAuthDevIdPermissionResult() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds, new String[]{NON_ADMIN_PERMISSION});
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 2,
+                "Non admin user authentication to 2 devices in a shared group failed");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 3,
+                "Non admin user authentication to 3 devices in a non-shared group failed");
+    }
+
+    @Test(description = "Authorization by giving device identifiers, username and permission")
+    public void userAuthDevIdUserNamePermissionResult() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds, NON_ADMIN_ALLOWED_USER, new String[]{NON_ADMIN_PERMISSION});
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 2,
+                "Non admin user authentication to 2 devices in a shared group failed");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 3,
+                "Non admin user authentication to 3 devices in a non-shared group failed");
+    }
+
+    @Test(description = "Authorization for device admin called by normal user")
+    public void isDevAdminNormalUser() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NORMAL_USER);
+        Assert.assertFalse(deviceAccessAuthorizationService.isDeviceAdminUser(), "Normal user allowed as admin user");
+    }
+
+    //Check branches of isUserAuthorized
+    @Test(description = "Checking branch - user is device owner")
+    public void nonAdminDeviceOwner() throws DeviceAccessAuthorizationException, DeviceManagementException {
+
+        //Creating a temporary device
+        Device device = new Device();
+        EnrolmentInfo enrolmentInfo = new EnrolmentInfo(NON_ADMIN_ALLOWED_USER, EnrolmentInfo.OwnerShip.BYOD, null);
+        device.setEnrolmentInfo(enrolmentInfo);
+        device.setName("temp");
+        device.setType(DEVICE_TYPE);
+        device.setDeviceIdentifier("1234");
+        DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().enrollDevice(device);
+
+        //temporary device identifier
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+        deviceIdentifier.setType(DEVICE_TYPE);
+        deviceIdentifier.setId("1234");
+
+        List<DeviceIdentifier> tempList = new ArrayList<>();
+        tempList.add(deviceIdentifier);
+
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(tempList, NON_ADMIN_ALLOWED_USER, new String[]{NON_ADMIN_PERMISSION});
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 1,
+                "Non admin device owner failed to access device");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 0,
+                "Non admin device owner failed to access device");
+    }
+
+    @Test(description = "Check authorization without giving permissions")
+    public void userAuthWithoutPermissions() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds, NON_ADMIN_ALLOWED_USER, null);
+        Assert.assertEquals(deviceAuthorizationResult.getAuthorizedDevices().size(), 0,
+                "Non admin user try authentication without permission failed");
+        Assert.assertEquals(deviceAuthorizationResult.getUnauthorizedDevices().size(), 5,
+                "Non admin user try authentication without permission failed");
+    }
+
+    //check Exception cases
+    @Test(description = "check a null username in isUserAuthorized method")
+    public void callUserAuthWithoutUsername() throws DeviceAccessAuthorizationException {
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(NON_ADMIN_ALLOWED_USER);
+        DeviceAuthorizationResult deviceAuthorizationResult = deviceAccessAuthorizationService.
+                isUserAuthorized(deviceIds, "", new String[]{NON_ADMIN_PERMISSION});
+        Assert.assertEquals(deviceAuthorizationResult, null,
+                "Not null result for empty username in isUserAuthorized method");
+    }
+
+    @AfterClass
+    public void clearAll() {
+        PrivilegedCarbonContext.endTenantFlow();
+    }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/common/BaseDeviceManagementTest.java

@@ -18,11 +18,13 @@
  */
 package org.wso2.carbon.device.mgt.core.common;
 
+import org.apache.axis2.AxisFault;
+import org.apache.axis2.context.ConfigurationContext;
+import org.apache.axis2.context.ConfigurationContextFactory;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.tomcat.jdbc.pool.PoolProperties;
 import org.testng.Assert;
-import org.testng.annotations.AfterSuite;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeSuite;
 import org.w3c.dom.Document;
@@ -30,17 +32,33 @@ import org.wso2.carbon.base.MultitenantConstants;
 import org.wso2.carbon.context.PrivilegedCarbonContext;
 import org.wso2.carbon.device.mgt.common.DeviceManagementException;
 import org.wso2.carbon.device.mgt.core.TestUtils;
+import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.notification.mgt.dao.NotificationManagementDAOFactory;
 import org.wso2.carbon.device.mgt.core.operation.mgt.dao.OperationManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
+import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
 import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
+import org.wso2.carbon.email.sender.core.service.EmailSenderServiceImpl;
+import org.wso2.carbon.registry.core.config.RegistryContext;
+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.core.service.RealmService;
+import org.wso2.carbon.utils.ConfigurationContextService;
 
 import javax.sql.DataSource;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
 import java.io.File;
+import java.io.InputStream;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
@@ -56,6 +74,7 @@ public abstract class BaseDeviceManagementTest {
         this.initDataSource();
         this.initSQLScript();
         this.initializeCarbonContext();
+        this.initServices();
     }
 
     protected void initDataSource() throws Exception {
@@ -66,6 +85,42 @@ public abstract class BaseDeviceManagementTest {
         NotificationManagementDAOFactory.init(dataSource);
     }
 
+    protected void initServices() throws DeviceManagementException, RegistryException {
+        DeviceConfigurationManager.getInstance().initConfig();
+        DeviceManagementProviderService deviceMgtService = new DeviceManagementProviderServiceImpl();
+        DeviceManagementServiceComponent.notifyStartupListeners();
+        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
+        DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
+        DeviceManagementDataHolder.getInstance().setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
+        DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(new GroupManagementProviderServiceImpl());
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
+        DeviceManagementDataHolder.getInstance().setEmailSenderService(new TestEmailSenderService());
+        DeviceManagementDataHolder.getInstance().setConfigurationContextService(getConfigContextService());
+    }
+
+    private RegistryService getRegistryService() throws RegistryException {
+        RealmService realmService = new InMemoryRealmService();
+        RegistryDataHolder.getInstance().setRealmService(realmService);
+        DeviceManagementDataHolder.getInstance().setRealmService(realmService);
+        InputStream is = this.getClass().getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
+        RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
+        context.setSetup(true);
+        return context.getEmbeddedRegistryService();
+    }
+
+    private ConfigurationContextService getConfigContextService() throws RegistryException {
+        ConfigurationContext context  =
+                null;
+        try {
+            context = ConfigurationContextFactory.createConfigurationContextFromFileSystem
+                    ("src/test/resources/carbon-home/repository/conf/axis2/axis2.xml");
+        } catch (AxisFault axisFault) {
+            axisFault.printStackTrace();
+        }
+        ConfigurationContextService service = new ConfigurationContextService(context, null);
+        return service;
+    }
+
     @BeforeClass
     public abstract void init() throws Exception;
 

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/common/TestDataHolder.java

@@ -18,10 +18,12 @@ package org.wso2.carbon.device.mgt.core.common;
 import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.MonitoringOperation;
+import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
 import org.wso2.carbon.device.mgt.common.app.mgt.Application;
+import org.wso2.carbon.device.mgt.common.device.details.DeviceInfo;
 import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
 import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
-import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
 import org.wso2.carbon.device.mgt.core.dto.DeviceType;
 
 import java.util.ArrayList;
@@ -31,11 +33,12 @@ import java.util.Properties;
 
 public class TestDataHolder {
 
-    public final static String TEST_DEVICE_TYPE = "Test";
+    public final static String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
     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 OWNER = "admin";
+    public static final String OPERATION_CONFIG = "TEST-OPERATION-";
     public static Device initialTestDevice;
     public static DeviceType initialTestDeviceType;
 
@@ -54,6 +57,28 @@ public class TestDataHolder {
         return device;
     }
 
+    public static DeviceInfo generateDummyDeviceInfo() {
+        DeviceInfo deviceInfo = new DeviceInfo();
+        deviceInfo.setIMEI("IMEI-12345");
+        deviceInfo.setIMSI("IMSI-12344");
+        deviceInfo.setDeviceModel("DUMMY_MODEL");
+        deviceInfo.setVendor("WSO2");
+        deviceInfo.setOsVersion("OREO");
+        deviceInfo.setOsBuildDate("24-05-2017");
+        deviceInfo.setBatteryLevel(25.0);
+        deviceInfo.setInternalTotalMemory(1.5);
+        deviceInfo.setInternalAvailableMemory(2.5);
+        deviceInfo.setExternalTotalMemory(16.76);
+        deviceInfo.setExternalAvailableMemory(4.56);
+        deviceInfo.setConnectionType("CON_TYPE");
+        deviceInfo.setSsid("SSID");
+        deviceInfo.setCpuUsage(23.5);
+        deviceInfo.setTotalRAMMemory(1.5);
+        deviceInfo.setAvailableRAMMemory(2.33);
+        deviceInfo.setPluggedIn(true);
+        return deviceInfo;
+    }
+
     public static Notification getNotification(int notificationId, String status, String deviceId,
                                                String description, String deviceName, int operationId,
                                                String deviceType) {
@@ -97,6 +122,21 @@ public class TestDataHolder {
         return devices;
     }
 
+    public static Device generateDummyDeviceData(DeviceIdentifier deviceIdentifier) {
+            Device device = new Device();
+            EnrolmentInfo enrolmentInfo = new EnrolmentInfo();
+            enrolmentInfo.setDateOfEnrolment(new Date().getTime());
+            enrolmentInfo.setDateOfLastUpdate(new Date().getTime());
+            enrolmentInfo.setOwner(OWNER);
+            enrolmentInfo.setOwnership(EnrolmentInfo.OwnerShip.BYOD);
+            enrolmentInfo.setStatus(EnrolmentInfo.Status.CREATED);
+            device.setEnrolmentInfo(enrolmentInfo);
+            device.setDescription("Test Description");
+            device.setDeviceIdentifier(deviceIdentifier.getId());
+            device.setType(deviceIdentifier.getType());
+        return device;
+    }
+
     public static DeviceType generateDeviceTypeData(String devTypeName) {
         DeviceType deviceType = new DeviceType();
         deviceType.setName(devTypeName);
@@ -125,4 +165,29 @@ public class TestDataHolder {
         deviceGroup.setOwner(OWNER);
         return deviceGroup;
     }
+
+    public static OperationMonitoringTaskConfig generateMonitoringTaskConfig(boolean enabled, int frequency,
+            int numberOfOperations) {
+        OperationMonitoringTaskConfig taskConfig = new OperationMonitoringTaskConfig();
+        List<MonitoringOperation> operationList = new ArrayList<>();
+
+        while (--numberOfOperations >= 0) {
+            operationList.add(generateMonitoringOperation(OPERATION_CONFIG + String.valueOf(numberOfOperations),
+                    1 + (int) (Math.random() * 4)));
+        }
+
+        taskConfig.setEnabled(enabled);
+        taskConfig.setFrequency(frequency);
+        taskConfig.setMonitoringOperation(operationList);
+
+        return taskConfig;
+    }
+
+    private static MonitoringOperation generateMonitoringOperation(String name, int recurrentTimes) {
+        MonitoringOperation operation = new MonitoringOperation();
+        operation.setTaskName(name);
+        operation.setRecurrentTimes(recurrentTimes);
+
+        return operation;
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/common/TestEmailSenderService.java

@@ -0,0 +1,30 @@
+/*
+ *   Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ *   WSO2 Inc. licenses this file to you under the Apache License,
+ *   Version 2.0 (the "License"); you may not use this file except
+ *   in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing,
+ *   software distributed under the License is distributed on an
+ *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *   KIND, either express or implied.  See the License for the
+ *   specific language governing permissions and limitations
+ *   under the License.
+ *
+ */
+package org.wso2.carbon.device.mgt.core.common;
+
+import org.wso2.carbon.email.sender.core.EmailContext;
+import org.wso2.carbon.email.sender.core.EmailSendingFailedException;
+import org.wso2.carbon.email.sender.core.EmailTransportNotConfiguredException;
+import org.wso2.carbon.email.sender.core.service.EmailSenderService;
+
+public class TestEmailSenderService implements EmailSenderService {
+    @Override
+    public void sendEmail(EmailContext emailCtx) throws EmailSendingFailedException, EmailTransportNotConfiguredException {
+    }
+}

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

@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+package org.wso2.carbon.device.mgt.core.geo.service;
+
+import org.mockito.Mockito;
+
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.wso2.carbon.device.mgt.common.Device;
+import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
+import org.wso2.carbon.device.mgt.common.DeviceManagementConstants;
+import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.common.geo.service.Alert;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoFence;
+import org.wso2.carbon.device.mgt.common.geo.service.GeoLocationBasedServiceException;
+import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.event.processor.stub.EventProcessorAdminServiceStub;
+import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientException;
+import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
+
+import java.rmi.RemoteException;
+import java.util.List;
+
+public class GeoLocationProviderServiceTest {
+
+    private static final String DEVICE_TYPE = "GL_TEST_TYPE";
+    private static final String DEVICE_ID = "GL-TEST-DEVICE-ID-1";
+    private static final String SAMPLE_GEO_JSON = "12121";
+    private static final String SAMPLE_AREA_NAME = "CUSTOM_NAME";
+    private static final String SAMPLE_QUERY_NAME = "QUERY_NAME";
+    private static final String SAMPLE_PROXIMITY_DISATANCE = "100";
+    private static final String SAMPLE_PROXIMITY_TIME = "50";
+    private static final String SAMPLE_SPEED_ALERT_VALUE = "120";
+    private static final String SAMPLE_STATIONARY_TIME = "1500";
+    private static final String SAMPLE_FLUCTUATION_RADIUS = "2000";
+
+    private EventProcessorAdminServiceStub mockEventProcessorAdminServiceStub;
+    private GeoLocationProviderServiceImpl geoLocationProviderServiceImpl;
+
+    @BeforeClass
+    public void init() throws Exception {
+        initMocks();
+        enrollDevice();
+    }
+
+    @Test (description = "Create a sample geo exit-alert with relevant details.")
+    public void createGeoExitAlert() throws GeoLocationBasedServiceException {
+         Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getExitAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_EXIT);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test (description = "Create a sample geo within-alert with relevant details.")
+    public void createGeoWithinAlert() throws GeoLocationBasedServiceException {
+         Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getWithinAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_WITHIN);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test (description = "Create a sample geo proximity-alert with relevant details.")
+    public void createGeoProximityAlert() throws GeoLocationBasedServiceException {
+        Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getProximityAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_PROXIMITY);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test (description = "Create a sample geo speed-alert with relevant details.")
+    public void createGeoSpeedAlert() throws GeoLocationBasedServiceException {
+        Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getSpeedAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_SPEED);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test (description = "Create a sample geo stationary-alert with relevant details.")
+    public void createGeoStationaryAlert() throws GeoLocationBasedServiceException {
+        Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getStationaryAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_STATIONARY);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test (description = "Create a sample geo traffic-alert with relevant details.")
+    public void createGeoTrafficAlert() throws GeoLocationBasedServiceException {
+        Boolean result = geoLocationProviderServiceImpl.
+                createGeoAlert(getTrafficAlert(), getDeviceIdentifier(), DeviceManagementConstants.GeoServices.ALERT_TYPE_TRAFFIC);
+        Assert.assertEquals(result, Boolean.TRUE);
+    }
+
+    @Test(dependsOnMethods = "createGeoSpeedAlert", description = "retrieve saved geo speed-alert.")
+    public void getGeoSpeedAlerts() throws GeoLocationBasedServiceException {
+        String result;
+        result = geoLocationProviderServiceImpl.getSpeedAlerts(getDeviceIdentifier());
+        Assert.assertNotNull(result);
+        Assert.assertEquals(result, "{'speedLimit':" + SAMPLE_SPEED_ALERT_VALUE + "}");
+    }
+
+    @Test(dependsOnMethods = "createGeoTrafficAlert" , description = "retrieve saved geo exit-alert.")
+    public void getGeoTrafficAlerts() throws GeoLocationBasedServiceException {
+        List<GeoFence> geoFences;
+        geoFences = geoLocationProviderServiceImpl.getTrafficAlerts(getDeviceIdentifier());
+        Assert.assertNotNull(geoFences);
+        GeoFence geoFenceNode = geoFences.get(0);
+        Assert.assertEquals(geoFenceNode.getGeoJson(), "{\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+    }
+
+    @Test(dependsOnMethods = "createGeoStationaryAlert", description = "retrieve saved geo stationary-alert.")
+    public void getGeoStationaryAlerts() throws GeoLocationBasedServiceException {
+        List<GeoFence> geoFences;
+        geoFences = geoLocationProviderServiceImpl.getStationaryAlerts(getDeviceIdentifier());
+        Assert.assertNotNull(geoFences);
+        GeoFence geoFenceNode = geoFences.get(0);
+        Assert.assertEquals(geoFenceNode.getAreaName(), SAMPLE_AREA_NAME);
+        Assert.assertEquals(geoFenceNode.getQueryName(), SAMPLE_QUERY_NAME);
+        Assert.assertEquals(geoFenceNode.getStationaryTime(), SAMPLE_STATIONARY_TIME);
+    }
+
+    private void initMocks() throws JWTClientException, RemoteException {
+        mockEventProcessorAdminServiceStub = Mockito.mock(EventProcessorAdminServiceStub.class);
+        geoLocationProviderServiceImpl = Mockito.mock(GeoLocationProviderServiceImpl.class, Mockito.CALLS_REAL_METHODS);
+        Mockito.doReturn(mockEventProcessorAdminServiceStub).
+                when(geoLocationProviderServiceImpl).getEventProcessorAdminServiceStub();
+        Mockito.doReturn("success").
+                when(mockEventProcessorAdminServiceStub).validateExecutionPlan(Mockito.anyString());
+    }
+
+    private DeviceIdentifier getDeviceIdentifier() {
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+        deviceIdentifier.setId("1234");
+        deviceIdentifier.setType("TEST");
+        return deviceIdentifier;
+    }
+
+    private Alert getWithinAlert() {
+        Alert alert = new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setCepAction("CEP_ACTION");
+        alert.setParseData("{\n" +
+                "  \" " + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+        alert.setCustomName(SAMPLE_AREA_NAME);
+        alert.setExecutionPlan("EXECUTION_PLAN");
+        alert.setQueryName(SAMPLE_QUERY_NAME);
+        return alert;
+    }
+
+    private Alert getExitAlert() {
+        Alert alert = new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setQueryName(SAMPLE_QUERY_NAME);
+        alert.setCustomName(SAMPLE_AREA_NAME);
+        alert.setStationeryTime(SAMPLE_STATIONARY_TIME);
+        alert.setFluctuationRadius(SAMPLE_FLUCTUATION_RADIUS);
+        alert.setParseData("{\n" +
+                "  \" " + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+        alert.setExecutionPlan("EXECUTION_PLAN");
+        return alert;
+    }
+
+    private Alert getProximityAlert() {
+        Alert alert = new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setProximityTime(SAMPLE_PROXIMITY_TIME);
+        alert.setProximityDistance(SAMPLE_PROXIMITY_DISATANCE);
+        alert.setParseData("{\n" +
+                "  \" " + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+        return alert;
+    }
+
+    private Alert getSpeedAlert() {
+        Alert alert =  new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setParseData("{\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\",\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.SPEED_ALERT_VALUE + "\": \"" + SAMPLE_SPEED_ALERT_VALUE + "\"\n" +
+                "}");
+        return alert;
+    }
+
+    private Alert getStationaryAlert() {
+        Alert alert = new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setQueryName(SAMPLE_QUERY_NAME);
+        alert.setCustomName(SAMPLE_AREA_NAME);
+        alert.setStationeryTime(SAMPLE_STATIONARY_TIME);
+        alert.setFluctuationRadius(SAMPLE_FLUCTUATION_RADIUS);
+        alert.setParseData("{\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON + "\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+        return alert;
+    }
+
+    private Alert getTrafficAlert() {
+        Alert alert = new Alert();
+        alert.setDeviceId(DEVICE_ID);
+        alert.setParseData("{\n" +
+                "  \"" + DeviceManagementConstants.GeoServices.GEO_FENCE_GEO_JSON +"\": \"" + SAMPLE_GEO_JSON + "\"\n" +
+                "}");
+        alert.setCustomName(SAMPLE_AREA_NAME);
+        alert.setExecutionPlan("EXECUTION_PLAN");
+        alert.setQueryName(SAMPLE_QUERY_NAME);
+        return alert;
+    }
+
+    private void enrollDevice() throws Exception {
+        DeviceIdentifier deviceIdentifier = new DeviceIdentifier(DEVICE_ID, DEVICE_TYPE);
+        Device device = TestDataHolder.generateDummyDeviceData(deviceIdentifier);
+        DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().
+                getDeviceManagementProvider();
+        deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
+        deviceMgtService.enrollDevice(device);
+
+        Device returnedDevice = deviceMgtService.getDevice(deviceIdentifier);
+
+            if (!returnedDevice.getDeviceIdentifier().equals(deviceIdentifier.getId())) {
+                throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
+            }
+        }
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/notification/mgt/NotificationManagementServiceImplTests.java

@@ -25,6 +25,8 @@ import org.testng.annotations.Test;
 import org.wso2.carbon.device.mgt.common.Device;
 import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
 import org.wso2.carbon.device.mgt.common.EntityDoesNotExistException;
+import org.wso2.carbon.device.mgt.common.PaginationRequest;
+import org.wso2.carbon.device.mgt.common.PaginationResult;
 import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
 import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementException;
 import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
@@ -81,7 +83,8 @@ public class NotificationManagementServiceImplTests {
         deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
                 MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
         for (Device device : devices) {
-            deviceMgtService.enrollDevice(device);
+            Assert.assertTrue(deviceMgtService.enrollDevice(device), "Device with Identifier - " +
+                    device.getDeviceIdentifier() + " is not enrolled.");
         }
         List<Device> returnedDevices = deviceMgtService.getAllDevices(DEVICE_TYPE);
 
@@ -110,7 +113,8 @@ public class NotificationManagementServiceImplTests {
             Notification notification = TestDataHolder.getNotification(i, Notification.Status.NEW.toString(),
                     testDeviceIdentifier.toString(), TEST_NOTIFICATION_DESCRIPTION, DEVICE_ID_PREFIX + i,
                     NOTIFICATION_OPERATION_ID, DEVICE_TYPE);
-            Assert.assertTrue(notificationManagementService.addNotification(testDeviceIdentifier, notification));
+            Assert.assertTrue(notificationManagementService.addNotification(testDeviceIdentifier, notification),
+                    "Adding notification failed for [" + notification.toString() + "]");
         }
     }
 
@@ -125,15 +129,26 @@ public class NotificationManagementServiceImplTests {
                 DEVICE_TYPE), notification);
     }
 
+    @Test(expectedExceptions = NotificationManagementException.class, description = "This tests the method getDevice which" +
+            " is called internally in addNotification for DeviceManagementException exception passing null device Id.")
+    public void getDevice() throws NotificationManagementException {
+        DeviceIdentifier testDeviceIdentifier = new DeviceIdentifier(DEVICE_ID_PREFIX + 123, DEVICE_TYPE);
+        Notification notification = TestDataHolder.getNotification(1, Notification.Status.NEW.toString(),
+                testDeviceIdentifier.toString(), TEST_NOTIFICATION_DESCRIPTION, DEVICE_ID_PREFIX + 123,
+                NOTIFICATION_OPERATION_ID, DEVICE_TYPE);
+        notificationManagementService.addNotification(null, notification);
+    }
+
     @Test(dependsOnMethods = "addNotification", description = "This tests the updateNotification Method" +
             " and check whether it returns true ( got updated )")
     public void updateNotification() throws NotificationManagementException {
         for (int i = 1; i <= NO_OF_DEVICES; i++) {
             DeviceIdentifier testDeviceIdentifier = new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE);
             Notification notification = TestDataHolder.getNotification(i, Notification.Status.CHECKED.toString(),
-                    testDeviceIdentifier.toString(), TEST_NOTIFICATION_DESCRIPTION, DEVICE_ID_PREFIX + i, NOTIFICATION_OPERATION_ID,
+                    testDeviceIdentifier.toString(), TEST_NOTIFICATION_DESCRIPTION, DEVICE_ID_PREFIX + i,
-                    DEVICE_TYPE);
+                    NOTIFICATION_OPERATION_ID, DEVICE_TYPE);
-            Assert.assertTrue(notificationManagementService.updateNotification(notification));
+            Assert.assertTrue(notificationManagementService.updateNotification(notification), "Notification " +
+                    "update failed for [" + notification.toString() + "]");
         }
     }
 
@@ -141,7 +156,8 @@ public class NotificationManagementServiceImplTests {
             "and check whether it got updated")
     public void updateNotificationStatus() throws NotificationManagementException {
         for (int i = 1; i <= NO_OF_DEVICES; i++) {
-            Assert.assertTrue(notificationManagementService.updateNotificationStatus(i, Notification.Status.CHECKED));
+            Assert.assertTrue(notificationManagementService.updateNotificationStatus(i, Notification.Status.CHECKED),
+                    "Notification update status failed for notification id:- " + i);
         }
     }
 
@@ -149,7 +165,8 @@ public class NotificationManagementServiceImplTests {
             " method by listing down all the notifications.")
     public void getAllNotifications() throws NotificationManagementException {
         List<Notification> returnedNotifications = notificationManagementService.getAllNotifications();
-        Assert.assertEquals(returnedNotifications.size(), NO_OF_DEVICES);
+        Assert.assertEquals(returnedNotifications.size(), NO_OF_DEVICES, "No. of notifications added is not " +
+                "equal to no. of notifications retrieved.");
     }
 
     @Test(dependsOnMethods = "updateNotificationStatus", description = "this method retries notification by id" +
@@ -157,17 +174,46 @@ public class NotificationManagementServiceImplTests {
     public void getNotification() throws NotificationManagementException {
         for (int i = 1; i <= NO_OF_DEVICES; i++) {
             Notification returnedNotification = notificationManagementService.getNotification(i);
-            Assert.assertEquals(returnedNotification.getNotificationId(), i);
+            Assert.assertEquals(returnedNotification.getNotificationId(), i, "Returned notification ID is not " +
-            Assert.assertEquals(returnedNotification.getStatus(), Notification.Status.CHECKED);
+                    "same as added notification Id.");
-            Assert.assertEquals(returnedNotification.getDescription(), TEST_NOTIFICATION_DESCRIPTION);
+            Assert.assertEquals(returnedNotification.getStatus(), Notification.Status.CHECKED, "Returned " +
-            Assert.assertEquals(returnedNotification.getOperationId(), NOTIFICATION_OPERATION_ID);
+                    "notification status is not same as added notification status.");
+            Assert.assertEquals(returnedNotification.getDescription(), TEST_NOTIFICATION_DESCRIPTION, "Returned" +
+                    " notification description is not same as added notification description.");
+            Assert.assertEquals(returnedNotification.getOperationId(), NOTIFICATION_OPERATION_ID, "Returned " +
+                    "notification operation ID is not same as added notification operation Id.");
         }
     }
 
     @Test(dependsOnMethods = "updateNotificationStatus", description = "this method gets all notification by status checked")
     public void getNotificationsByStatus() throws NotificationManagementException {
-        List<Notification> returnedNotifications = notificationManagementService.getNotificationsByStatus(Notification.Status.CHECKED);
+        List<Notification> returnedNotifications = notificationManagementService.getNotificationsByStatus(Notification.
-        Assert.assertEquals(returnedNotifications.size(), NO_OF_NOTIFICATIONS);
+                Status.CHECKED);
+        Assert.assertEquals(returnedNotifications.size(), NO_OF_NOTIFICATIONS, "Returned no. of notification is " +
+                "not same as added no. of notifications.");
+    }
+
+    @Test(dependsOnMethods = "addNotification", description = "this tests for getAllNotification method by passing " +
+            "pagination request and validates the no. of total records and filtered records. ")
+    public void getAllNotificationsWithPaginationRequest() throws NotificationManagementException {
+        PaginationRequest request = new PaginationRequest(1, 2);
+        PaginationResult result = notificationManagementService.getAllNotifications(request);
+        Assert.assertEquals(result.getRecordsFiltered(), NO_OF_NOTIFICATIONS, "Returned filtered records is " +
+                "not same as added filtered records.");
+        Assert.assertEquals(result.getRecordsTotal(), NO_OF_NOTIFICATIONS, "Returned no. of records is not " +
+                "same as added no. of records.");
+    }
+
+    @Test(dependsOnMethods = "updateNotificationStatus", description = "this tests for getAllNotification method by" +
+            " passing pagination request & status and validates the no. of total records and filtered records. ")
+    public void getAllNotificationsWithPaginationRequestAndStatus() throws NotificationManagementException {
+        PaginationRequest request = new PaginationRequest(1, 2);
+        PaginationResult result = notificationManagementService.getNotificationsByStatus(Notification.Status.CHECKED,
+                request);
+        Assert.assertEquals(result.getRecordsFiltered(), NO_OF_NOTIFICATIONS, "Returned filtered records is not " +
+                "same as added filtered records.");
+        Assert.assertEquals(result.getRecordsTotal(), NO_OF_NOTIFICATIONS, "Returned no. of records is not same" +
+                " as added no. of records.");
     }
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/operation/OperationManagementTests.java

@@ -25,6 +25,7 @@ import org.wso2.carbon.context.PrivilegedCarbonContext;
 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.EnrolmentInfo;
 import org.wso2.carbon.device.mgt.common.InvalidDeviceException;
 import org.wso2.carbon.device.mgt.common.PaginationRequest;
 import org.wso2.carbon.device.mgt.common.PaginationResult;
@@ -36,38 +37,28 @@ import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
 import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
-import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
+import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
 import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
-import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
-import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.operation.mgt.CommandOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.ConfigOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
 import org.wso2.carbon.device.mgt.core.operation.mgt.PolicyOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.ProfileOperation;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
-import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
-import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
-import org.wso2.carbon.registry.core.config.RegistryContext;
-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.core.service.RealmService;
 import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
 
-import java.io.InputStream;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 
 /**
  * This is the testcase which covers the methods from {@link OperationManager}
  */
-public class OperationManagementTests {
+public class OperationManagementTests extends BaseDeviceManagementTest {
 
     private static final String DEVICE_TYPE = "OP_TEST_TYPE";
     private static final String DEVICE_ID_PREFIX = "OP-TEST-DEVICE-ID-";
@@ -79,26 +70,22 @@ public class OperationManagementTests {
     private static final int NO_OF_DEVICES = 5;
     private static final String ADMIN_USER = "admin";
     private static final String NON_ADMIN_USER = "test";
+    private static final String INVALID_DEVICE = "ThisIsInvalid";
 
     private List<DeviceIdentifier> deviceIds = new ArrayList<>();
     private OperationManager operationMgtService;
+    private DeviceManagementProviderService deviceMgmtProvider;
     private Activity commandActivity;
     private long commandActivityBeforeUpdatedTimestamp;
 
     @BeforeClass
     public void init() throws Exception {
-        DeviceConfigurationManager.getInstance().initConfig();
         for (int i = 0; i < NO_OF_DEVICES; i++) {
             deviceIds.add(new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE));
         }
         List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
-        DeviceManagementProviderService deviceMgtService = new DeviceManagementProviderServiceImpl();
+        DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().
-        DeviceManagementServiceComponent.notifyStartupListeners();
+                getDeviceManagementProvider();
-        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
-        DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
-        DeviceManagementDataHolder.getInstance().setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
-        DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(new GroupManagementProviderServiceImpl());
-        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
         deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
                 MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
         for (Device device : devices) {
@@ -110,39 +97,65 @@ public class OperationManagementTests {
                 throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
             }
         }
+        this.deviceMgmtProvider = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider();
         NotificationStrategy notificationStrategy = new TestNotificationStrategy();
         this.operationMgtService = new OperationManagerImpl(DEVICE_TYPE, notificationStrategy);
     }
 
-    private RegistryService getRegistryService() throws RegistryException {
-        RealmService realmService = new InMemoryRealmService();
-        RegistryDataHolder.getInstance().setRealmService(realmService);
-        DeviceManagementDataHolder.getInstance().setRealmService(realmService);
-        InputStream is = this.getClass().getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
-        RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
-        context.setSetup(true);
-        return context.getEmbeddedRegistryService();
-    }
-
     @Test
-    public void addCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addCommandOperation() throws DeviceManagementException, OperationManagementException,
-        this.commandActivity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+            InvalidDeviceException {
+        this.commandActivity = this.operationMgtService.addOperation(
+                getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
                 this.deviceIds);
         validateOperationResponse(this.commandActivity, ActivityStatus.Status.PENDING);
     }
 
+    @Test
+    public void addCommandOperationInvalidDeviceIds() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
+        startTenantFlowAsNonAdmin();
+        try {
+            ArrayList<DeviceIdentifier> invalidDevices = new ArrayList<>();
+            for (int i = 0; i < 3; i++) {
+                invalidDevices.add(new DeviceIdentifier(INVALID_DEVICE + i, DEVICE_TYPE));
+            }
+            invalidDevices.addAll(this.deviceIds);
+            Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
+                    Operation.Type.COMMAND, COMMAND_OPERATON_CODE), invalidDevices);
+            Assert.assertEquals(activity.getActivityStatus().size(), invalidDevices.size(),
+                    "The operation response for add operation only have - " + activity.getActivityStatus().size());
+            for (int i = 0; i < activity.getActivityStatus().size(); i++) {
+                ActivityStatus status = activity.getActivityStatus().get(i);
+                if (i < 3) {
+                    Assert.assertEquals(status.getStatus(), ActivityStatus.Status.INVALID);
+                } else {
+                    Assert.assertEquals(status.getStatus(), ActivityStatus.Status.UNAUTHORIZED);
+                }
+            }
+        } finally {
+            PrivilegedCarbonContext.endTenantFlow();
+        }
+    }
+
+
     @Test(expectedExceptions = InvalidDeviceException.class)
-    public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
-        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+            InvalidDeviceException {
+        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
+                COMMAND_OPERATON_CODE),
                 new ArrayList<>());
     }
 
     @Test(expectedExceptions = InvalidDeviceException.class)
-    public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException,
+            OperationManagementException,
+            InvalidDeviceException {
         DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
         List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
         deviceIdentifiers.add(deviceIdentifier);
-        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
+                COMMAND_OPERATON_CODE),
                 deviceIdentifiers);
     }
 
@@ -150,7 +163,8 @@ public class OperationManagementTests {
     public void addNonAdminUserDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
             InvalidDeviceException {
         startTenantFlowAsNonAdmin();
-        Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+        Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
+                Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
                 deviceIds);
         PrivilegedCarbonContext.endTenantFlow();
         validateOperationResponse(activity, ActivityStatus.Status.UNAUTHORIZED);
@@ -163,27 +177,33 @@ public class OperationManagementTests {
     }
 
     @Test(dependsOnMethods = "addCommandOperation")
-    public void addPolicyOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addPolicyOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(), Operation.Type.POLICY, POLICY_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(),
+                Operation.Type.POLICY, POLICY_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
     @Test(dependsOnMethods = "addPolicyOperation")
-    public void addConfigOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addConfigOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(), Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(),
+                Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
     @Test(dependsOnMethods = "addConfigOperation")
-    public void addProfileOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addProfileOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(), Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(),
+                Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
-    private Operation getOperation(Operation operation, Operation.Type type, String code) {
+    static Operation getOperation(Operation operation, Operation.Type type, String code) {
         String date = new SimpleDateFormat(DATE_FORMAT_NOW).format(new Date());
         operation.setCreatedTimeStamp(date);
         operation.setType(type);
@@ -192,8 +212,8 @@ public class OperationManagementTests {
     }
 
     private void validateOperationResponse(Activity activity, ActivityStatus.Status expectedStatus) {
-        Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation reponse for add operation only have - " +
+        Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation response for add " +
-                activity.getActivityStatus().size());
+                "operation only have - " + activity.getActivityStatus().size());
         for (ActivityStatus status : activity.getActivityStatus()) {
             Assert.assertEquals(status.getStatus(), expectedStatus);
         }
@@ -208,7 +228,8 @@ public class OperationManagementTests {
     }
 
     @Test(dependsOnMethods = "addProfileOperation", expectedExceptions = OperationManagementException.class)
-    public void getOperationsAsNonAdmin() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void getOperationsAsNonAdmin() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
         try {
             startTenantFlowAsNonAdmin();
             for (DeviceIdentifier deviceIdentifier : deviceIds) {
@@ -220,15 +241,18 @@ public class OperationManagementTests {
     }
 
     @Test(dependsOnMethods = "getOperations")
-    public void getPendingOperations() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void getPendingOperations() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
         for (DeviceIdentifier deviceIdentifier : deviceIds) {
             List operations = this.operationMgtService.getPendingOperations(deviceIdentifier);
-            Assert.assertEquals(operations.size(), 4, "The pending operations should be 4, but found only " + operations.size());
+            Assert.assertEquals(operations.size(), 4, "The pending operations should be 4, but found only "
+                    + operations.size());
         }
     }
 
     @Test(dependsOnMethods = "getOperations", expectedExceptions = OperationManagementException.class)
-    public void getPendingOperationsAsNonAdmin() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void getPendingOperationsAsNonAdmin() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
         try {
             startTenantFlowAsNonAdmin();
             for (DeviceIdentifier deviceIdentifier : deviceIds) {
@@ -328,17 +352,30 @@ public class OperationManagementTests {
         Assert.assertTrue(operation.getType().equals(Operation.Type.POLICY));
     }
 
+    @Test(dependsOnMethods = "updateOperation", expectedExceptions = OperationManagementException.class)
+    public void getNextPendingOperationAsNonAdmin() throws OperationManagementException {
+        startTenantFlowAsNonAdmin();
+        try {
+            DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
+            this.operationMgtService.getNextPendingOperation(deviceIdentifier);
+        } finally {
+            PrivilegedCarbonContext.endTenantFlow();
+        }
+    }
+
     @Test(dependsOnMethods = "getNextPendingOperation")
     public void getOperationByDeviceAndOperationId() throws OperationManagementException {
         DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
-        String operationId = this.commandActivity.getActivityId().
-                replace(DeviceManagementConstants.OperationAttributes.ACTIVITY, "");
         Operation operation = this.operationMgtService.getOperationByDeviceAndOperationId(deviceIdentifier,
-                Integer.parseInt(operationId));
+                getOperationId(this.commandActivity.getActivityId()));
         Assert.assertTrue(operation.getStatus().equals(Operation.Status.COMPLETED));
         Assert.assertTrue(operation.getType().equals(Operation.Type.COMMAND));
     }
 
+    private int getOperationId(String activityId) {
+        return Integer.parseInt(activityId.replace(DeviceManagementConstants.OperationAttributes.ACTIVITY, ""));
+    }
+
     @Test(dependsOnMethods = "getNextPendingOperation", expectedExceptions = OperationManagementException.class)
     public void getOperationByDeviceAndOperationIdNonAdmin() throws OperationManagementException {
         startTenantFlowAsNonAdmin();
@@ -356,12 +393,14 @@ public class OperationManagementTests {
     @Test(dependsOnMethods = "getOperationByDeviceAndOperationId")
     public void getOperationsByDeviceAndStatus() throws OperationManagementException, DeviceManagementException {
         DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
-        List operation = this.operationMgtService.getOperationsByDeviceAndStatus(deviceIdentifier, Operation.Status.PENDING);
+        List operation = this.operationMgtService.getOperationsByDeviceAndStatus(deviceIdentifier,
+                Operation.Status.PENDING);
         Assert.assertEquals(operation.size(), 3);
     }
 
     @Test(dependsOnMethods = "getOperationByDeviceAndOperationId", expectedExceptions = OperationManagementException.class)
-    public void getOperationsByDeviceAndStatusByNonAdmin() throws OperationManagementException, DeviceManagementException {
+    public void getOperationsByDeviceAndStatusByNonAdmin() throws OperationManagementException,
+            DeviceManagementException {
         startTenantFlowAsNonAdmin();
         try {
             DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
@@ -438,4 +477,180 @@ public class OperationManagementTests {
         Assert.assertTrue(this.operationMgtService.getNotificationStrategy() != null);
     }
 
+    @Test(dependsOnMethods = {"getOperationByActivityIdAndDevice", "getOperationByActivityIdAndDeviceAsNonAdmin"})
+    public void getOperationForInactiveDevice() throws DeviceManagementException, OperationManagementException {
+        boolean disEnrolled = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().
+                disenrollDevice(deviceIds.get(0));
+        Assert.assertTrue(disEnrolled);
+        List operations = this.operationMgtService.getOperations(deviceIds.get(0));
+        Assert.assertTrue(operations == null);
+    }
+
+    @Test(dependsOnMethods = "getOperationForInactiveDevice", expectedExceptions = OperationManagementException.class)
+    public void getPaginatedOperationDeviceForInvalidDevice() throws DeviceManagementException,
+            OperationManagementException {
+        PrivilegedCarbonContext.startTenantFlow();
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(MultitenantConstants.SUPER_TENANT_ID, true);
+        PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
+        try {
+            PaginationRequest request = new PaginationRequest(1, 2);
+            request.setDeviceType(DEVICE_TYPE);
+            request.setOwner(ADMIN_USER);
+            PaginationResult result = this.operationMgtService.getOperations
+                    (new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE), request);
+            Assert.assertEquals(result.getRecordsFiltered(), 4);
+            Assert.assertEquals(result.getData().size(), 2);
+            Assert.assertEquals(result.getRecordsTotal(), 4);
+        } finally {
+            PrivilegedCarbonContext.endTenantFlow();
+        }
+    }
+
+    @Test(dependsOnMethods = "getOperationForInactiveDevice", expectedExceptions = OperationManagementException.class)
+    public void getPendingOperationDeviceForInvalidDevice() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getPendingOperations(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE));
+    }
+
+    @Test(dependsOnMethods = "getPendingOperationDeviceForInvalidDevice",
+            expectedExceptions = OperationManagementException.class)
+    public void getNextPendingOperationDeviceForInvalidDevice() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getNextPendingOperation(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE));
+    }
+
+    @Test(dependsOnMethods = "getNextPendingOperationDeviceForInvalidDevice",
+            expectedExceptions = OperationManagementException.class)
+    public void getUpdateOperationForInvalidDevice() throws DeviceManagementException, OperationManagementException {
+        this.operationMgtService.updateOperation(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE),
+                getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE));
+    }
+
+    @Test(dependsOnMethods = "getUpdateOperationForInvalidDevice",
+            expectedExceptions = OperationManagementException.class)
+    public void getOperationByDeviceAndOperationIdInvalidDevice() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getOperationByDeviceAndOperationId(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE),
+                getOperationId(this.commandActivity.getActivityId()));
+    }
+
+    @Test(dependsOnMethods = "getOperationByDeviceAndOperationIdInvalidDevice",
+            expectedExceptions = OperationManagementException.class)
+    public void getOperationsByDeviceAndStatusInvalidDevice() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getOperationsByDeviceAndStatus(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE),
+                Operation.Status.PENDING);
+    }
+
+    @Test(dependsOnMethods = "getOperationsByDeviceAndStatusInvalidDevice",
+            expectedExceptions = OperationManagementException.class)
+    public void getOperationsInvalidOperationId() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getOperation(123445);
+    }
+
+    @Test(dependsOnMethods = "getOperationsInvalidOperationId", expectedExceptions = IllegalArgumentException.class)
+    public void getOperationsByActivityIdInvalidActivityId() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getOperationByActivityId(DeviceManagementConstants.OperationAttributes.ACTIVITY + 0);
+    }
+
+    @Test(dependsOnMethods = "getOperationsByActivityIdInvalidActivityId",
+            expectedExceptions = IllegalArgumentException.class)
+    public void getOperationByActivityIdAndDeviceInvalidActivityId() throws DeviceManagementException,
+            OperationManagementException {
+        this.operationMgtService.getOperationByActivityIdAndDevice(
+                DeviceManagementConstants.OperationAttributes.ACTIVITY + 0,
+                new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE));
+    }
+
+    @Test(dependsOnMethods = "getOperationByActivityIdAndDeviceInvalidActivityId")
+    public void getPendingOperationsInactiveEnrollment() throws DeviceManagementException,
+            OperationManagementException {
+        changeStatus(EnrolmentInfo.Status.INACTIVE);
+        List operations = this.operationMgtService.getPendingOperations(this.deviceIds.get(1));
+        Assert.assertTrue(operations != null);
+        Assert.assertEquals(operations.size(), 4);
+        changeStatus(EnrolmentInfo.Status.ACTIVE);
+    }
+
+    private void changeStatus(EnrolmentInfo.Status status) throws DeviceManagementException,
+            OperationManagementException {
+        Device device = this.deviceMgmtProvider.getDevice(this.deviceIds.get(1));
+        Assert.assertTrue(device != null);
+        Assert.assertEquals(device.getType(), DEVICE_TYPE);
+        Assert.assertTrue(device.getEnrolmentInfo() != null);
+        device.getEnrolmentInfo().setStatus(status);
+        boolean modified = this.deviceMgmtProvider.changeDeviceStatus(this.deviceIds.get(1), status);
+        Assert.assertTrue(modified);
+        device = this.deviceMgmtProvider.getDevice(this.deviceIds.get(1));
+        Assert.assertEquals(device.getEnrolmentInfo().getStatus(), status);
+    }
+
+    @Test(dependsOnMethods = "getPendingOperationsInactiveEnrollment")
+    public void getNextPendingOperationInactiveEnrollment() throws DeviceManagementException,
+            OperationManagementException {
+        changeStatus(EnrolmentInfo.Status.INACTIVE);
+        Operation operation = this.operationMgtService.getNextPendingOperation(this.deviceIds.get(1));
+        Assert.assertTrue(operation != null);
+        changeStatus(EnrolmentInfo.Status.ACTIVE);
+    }
+
+    @Test(dependsOnMethods = "getNextPendingOperationInactiveEnrollment")
+    public void getNextPendingOperationForAllOperations() throws DeviceManagementException,
+            OperationManagementException {
+        for (int i = 0; i < 4; i++) {
+            Operation operation = this.operationMgtService.getNextPendingOperation(this.deviceIds.get(1));
+            operation.setStatus(Operation.Status.COMPLETED);
+            this.operationMgtService.updateOperation(deviceIds.get(1), operation);
+        }
+        Assert.assertTrue(this.operationMgtService.getNextPendingOperation(this.deviceIds.get(1)) == null);
+    }
+
+    @Test(dependsOnMethods = "getNextPendingOperationForAllOperations")
+    public void getOperationByDeviceAndOperationIdForAllOperations() throws DeviceManagementException,
+            OperationManagementException {
+        for (int i = 1; i <= 4; i++) {
+            Operation operation = this.operationMgtService.getOperationByDeviceAndOperationId(this.deviceIds.get(1), i);
+            Assert.assertEquals(operation.getStatus(), Operation.Status.COMPLETED);
+        }
+    }
+
+    @Test(dependsOnMethods = "getOperationByDeviceAndOperationIdForAllOperations")
+    public void getOperationForAllOperations() throws DeviceManagementException,
+            OperationManagementException {
+        for (int i = 1; i <= 4; i++) {
+            Operation operation = this.operationMgtService.getOperation(i);
+            Assert.assertTrue(operation != null);
+        }
+    }
+
+    @Test(dependsOnMethods = "getOperationForAllOperations")
+    public void addCustomPolicyOperation() throws OperationManagementException, InvalidDeviceException {
+        this.addCustomOperation(Operation.Type.POLICY, DeviceManagementConstants.AuthorizationSkippedOperationCodes.
+                POLICY_OPERATION_CODE);
+    }
+
+    @Test(dependsOnMethods = "getOperationForAllOperations")
+    public void addCustomMonitorOperation() throws OperationManagementException, InvalidDeviceException {
+        this.addCustomOperation(Operation.Type.COMMAND, DeviceManagementConstants.AuthorizationSkippedOperationCodes.
+                MONITOR_OPERATION_CODE);
+    }
+
+    @Test(dependsOnMethods = "getOperationForAllOperations")
+    public void addCustomPolicyRevokeOperation() throws OperationManagementException, InvalidDeviceException {
+        this.addCustomOperation(Operation.Type.POLICY, DeviceManagementConstants.AuthorizationSkippedOperationCodes.
+                POLICY_REVOKE_OPERATION_CODE);
+    }
+
+    private void addCustomOperation(Operation.Type type, String operationCode) throws OperationManagementException, InvalidDeviceException {
+        Operation operation = new Operation();
+        operation.setCode(operationCode);
+        operation.setType(type);
+        Activity activity = this.operationMgtService.addOperation(operation, Collections.singletonList(this.deviceIds.get(2)));
+        Assert.assertEquals(activity.getActivityStatus().size(), 1);
+        for (ActivityStatus status : activity.getActivityStatus()) {
+            Assert.assertEquals(status.getStatus(), ActivityStatus.Status.PENDING);
+        }
+    }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/operation/ScheduledTaskOperationTests.java

@@ -0,0 +1,117 @@
+/*
+*  Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+*  WSO2 Inc. licenses this file to you under the Apache License,
+*  Version 2.0 (the "License"); you may not use this file except
+*  in compliance with the License.
+*  You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*
+*/
+package org.wso2.carbon.device.mgt.core.operation;
+
+import org.mockito.Mockito;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+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.InvalidDeviceException;
+import org.wso2.carbon.device.mgt.common.operation.mgt.Activity;
+import org.wso2.carbon.device.mgt.common.operation.mgt.Operation;
+import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
+import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
+import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
+import org.wso2.carbon.device.mgt.core.TestTaskServiceImpl;
+import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.operation.mgt.CommandOperation;
+import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerService;
+import org.wso2.carbon.device.mgt.core.task.impl.DeviceTaskManagerServiceImpl;
+import org.wso2.carbon.ntask.core.internal.TasksDSComponent;
+import org.wso2.carbon.ntask.core.service.TaskService;
+import org.wso2.carbon.ntask.core.service.impl.TaskServiceImpl;
+import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.wso2.carbon.device.mgt.core.operation.OperationManagementTests.getOperation;
+
+/**
+ * This class tests the tasks based operations of {@link OperationManager}
+ */
+public class ScheduledTaskOperationTests extends BaseDeviceManagementTest {
+    private static final String DEVICE_TYPE = "OP_SCHEDULE_TEST_TYPE";
+    private static final String DEVICE_ID_PREFIX = "OP-SCHEDULED_TEST-DEVICE-ID-";
+    private static final String COMMAND_OPERATON_CODE = "COMMAND-TEST";
+    private static final int NO_OF_DEVICES = 5;
+    private static final String DS_TASK_COMPONENT_FIELD = "taskService";
+    private static final String CDM_CONFIG_LOCATION = "src" + File.separator + "test" + File.separator + "resources" +
+            File.separator + "config" + File.separator + "operation" + File.separator + "cdm-config.xml";
+
+    private List<DeviceIdentifier> deviceIds = new ArrayList<>();
+    private OperationManager operationMgtService;
+
+    @BeforeClass
+    public void init() throws Exception {
+        for (int i = 0; i < NO_OF_DEVICES; i++) {
+            deviceIds.add(new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE));
+        }
+        List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
+        DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider();
+        initTaskService();
+        deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME, COMMAND_OPERATON_CODE));
+        for (Device device : devices) {
+            deviceMgtService.enrollDevice(device);
+        }
+        List<Device> returnedDevices = deviceMgtService.getAllDevices(DEVICE_TYPE);
+        for (Device device : returnedDevices) {
+            if (!device.getDeviceIdentifier().startsWith(DEVICE_ID_PREFIX)) {
+                throw new Exception("Incorrect device with ID - " + device.getDeviceIdentifier() + " returned!");
+            }
+        }
+        DeviceConfigurationManager.getInstance().initConfig(CDM_CONFIG_LOCATION);
+        TestNotificationStrategy notificationStrategy = new TestNotificationStrategy();
+        this.operationMgtService = new OperationManagerImpl(DEVICE_TYPE, notificationStrategy);
+    }
+
+
+    private void initTaskService() throws NoSuchFieldException, IllegalAccessException {
+        TaskService taskService = new TestTaskServiceImpl();
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        DeviceTaskManagerService deviceTaskManager = new DeviceTaskManagerServiceImpl();
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(deviceTaskManager);
+        Field taskServiceField = TasksDSComponent.class.getDeclaredField(DS_TASK_COMPONENT_FIELD);
+        taskServiceField.setAccessible(true);
+        taskServiceField.set(null, Mockito.mock(TaskServiceImpl.class, Mockito.RETURNS_MOCKS));
+
+    }
+
+    @Test
+    public void addCommandOperation() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException, NoSuchFieldException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+                this.deviceIds);
+        Assert.assertEquals(activity.getActivityStatus(), null);
+        Assert.assertEquals(activity.getType(), Activity.Type.COMMAND);
+    }
+
+
+
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/operation/TestNotificationStrategy.java

@@ -22,7 +22,14 @@ import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
 import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationExecutionFailedException;
 
+import java.util.HashMap;
+
 public class TestNotificationStrategy implements NotificationStrategy {
+    private PushNotificationConfig pushNotificationConfig;
+
+    public TestNotificationStrategy(){
+       this.pushNotificationConfig = new PushNotificationConfig("TEST", true, new HashMap<>());
+    }
 
     @Override
     public void init() {
@@ -46,6 +53,6 @@ public class TestNotificationStrategy implements NotificationStrategy {
 
     @Override
     public PushNotificationConfig getConfig() {
-        return null;
+        return pushNotificationConfig;
     }
 }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/push/notification/mgt/task/PushNotificationSchedulerTaskTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.device.mgt.core.push.notification.mgt.task;
+
+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;
+import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
+import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
+import org.wso2.carbon.device.mgt.core.operation.TestNotificationStrategy;
+import org.wso2.carbon.device.mgt.core.operation.mgt.OperationMapping;
+import org.wso2.carbon.device.mgt.core.operation.mgt.dao.OperationDAO;
+import org.wso2.carbon.device.mgt.core.operation.mgt.dao.OperationManagementDAOException;
+import org.wso2.carbon.device.mgt.core.operation.mgt.dao.OperationManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
+import org.wso2.carbon.registry.core.exceptions.RegistryException;
+
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This class contains unit tests to test {@link PushNotificationSchedulerTask} class.
+ */
+public class PushNotificationSchedulerTaskTest extends BaseDeviceManagementTest {
+    private static final Log log = LogFactory.getLog(PushNotificationSchedulerTask.class);
+    private DeviceManagementProviderService deviceMgtProviderService;
+    private PushNotificationSchedulerTask pushNotificationSchedulerTask;
+    private OperationDAO operationDAO;
+
+    @BeforeClass
+    public void init() throws DeviceManagementException, RegistryException {
+        DeviceConfigurationManager.getInstance().initConfig();
+        log.info("Initializing Push Notification Scheduler Test Class");
+        DeviceManagementServiceComponent.notifyStartupListeners();
+        this.deviceMgtProviderService = Mockito.mock(DeviceManagementProviderServiceImpl.class, Mockito.CALLS_REAL_METHODS);
+        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(this.deviceMgtProviderService);
+        this.operationDAO = OperationManagementDAOFactory.getOperationDAO();
+        this.pushNotificationSchedulerTask = new PushNotificationSchedulerTask();
+    }
+
+    @Test(description = "Tests the push notification scheduling for devices")
+    public void testPushNotificationScheduler()
+            throws DeviceManagementException, OperationManagementException, SQLException,
+            OperationManagementDAOException {
+        try {
+            log.info("Attempting to execute push notification task scheduler");
+            Mockito.doReturn(new TestNotificationStrategy()).when(this.deviceMgtProviderService)
+                    .getNotificationStrategyByDeviceType(Mockito.anyString());
+            Mockito.doReturn(new org.wso2.carbon.device.mgt.common.operation.mgt.Operation())
+                    .when(this.deviceMgtProviderService).getOperation(Mockito.anyString(), Mockito.anyInt());
+            this.pushNotificationSchedulerTask.run();
+            OperationManagementDAOFactory.openConnection();
+            Map<Integer, List<OperationMapping>> operationMappingsTenantMap = operationDAO
+                    .getOperationMappingsByStatus(Operation.Status.PENDING, Operation.PushNotificationStatus.SCHEDULED,
+                            DeviceConfigurationManager.getInstance().getDeviceManagementConfig()
+                                    .getPushNotificationConfiguration().getSchedulerBatchSize());
+            Assert.assertEquals(operationMappingsTenantMap.size(), 0);
+            log.info("Push notification task execution complete.");
+        } finally {
+            OperationManagementDAOFactory.closeConnection();
+        }
+    }
+}

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

@@ -24,11 +24,19 @@ 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.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.PaginationRequest;
+import org.wso2.carbon.device.mgt.common.TransactionManagementException;
+import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException;
+import org.wso2.carbon.device.mgt.common.license.mgt.License;
 import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
 import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
 import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
 import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
 import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
+import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsDAO;
+import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsMgtDAOException;
+import org.wso2.carbon.device.mgt.core.dto.DeviceType;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.registry.core.config.RegistryContext;
@@ -40,13 +48,17 @@ import org.wso2.carbon.user.core.service.RealmService;
 import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
 
 import java.io.InputStream;
+import java.util.Calendar;
 import java.util.Date;
+import java.util.List;
+import java.util.Properties;
 
 public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTest {
 
     private static final Log log = LogFactory.getLog(DeviceManagementProviderServiceTest.class);
     private DeviceManagementProviderService providerService;
     private static final String DEVICE_TYPE = "RANDOM_DEVICE_TYPE";
+    private DeviceDetailsDAO deviceDetailsDAO = DeviceManagementDAOFactory.getDeviceDetailsDAO();
 
     DeviceManagementProviderService deviceMgtService;
 
@@ -64,7 +76,6 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
         deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
                 MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
-
     }
 
     private RegistryService getRegistryService() throws RegistryException {
@@ -77,6 +88,17 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         return context.getEmbeddedRegistryService();
     }
 
+    @Test
+    public void testGetAvailableDeviceTypes() {
+        try {
+            List<DeviceType> deviceTypes = deviceMgtService.getDeviceTypes();
+            Assert.assertTrue(deviceTypes.size() > 0);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while getting the device types";
+            Assert.fail(msg, e);
+        }
+    }
+
     @Test
     public void testNullDeviceEnrollment() {
         try {
@@ -87,17 +109,50 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
     }
 
     @Test
-    public void testSuccessfullDeviceEnrollment() {
+    public void testSuccessfulDeviceEnrollment() {
         Device device = TestDataHolder.generateDummyDeviceData(DEVICE_TYPE);
         try {
             boolean enrollmentStatus = deviceMgtService.enrollDevice(device);
             Assert.assertTrue(enrollmentStatus);
         } catch (DeviceManagementException e) {
-            String msg = "Error Occured while enrolling device";
+            String msg = "Error occurred while enrolling device";
             Assert.fail(msg, e);
         }
     }
 
+    @Test(dependsOnMethods = "testSuccessfulDeviceEnrollment")
+    public void testIsEnrolled() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId(TestDataHolder.initialDeviceIdentifier);
+            deviceIdentifier.setType(DEVICE_TYPE);
+            boolean enrollmentStatus = deviceMgtService.isEnrolled(deviceIdentifier);
+            Assert.assertTrue(enrollmentStatus);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while checking enrollment status.";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test
+    public void testIsEnrolledForNonExistingDevice() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId("34535235235235235");
+            deviceIdentifier.setType(DEVICE_TYPE);
+            boolean enrollmentStatus = deviceMgtService.isEnrolled(deviceIdentifier);
+            Assert.assertFalse(enrollmentStatus);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while checking enrollment status.";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(expectedExceptions = DeviceManagementException.class)
+    public void testIsEnrolledForNullDevice() throws DeviceManagementException {
+        deviceMgtService.isEnrolled(null);
+    }
+
     @Test
     public void testNonExistentDeviceType() {
         Device device = TestDataHolder.generateDummyDeviceData("abc");
@@ -105,13 +160,13 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
             boolean enrollmentStatus = deviceMgtService.enrollDevice(device);
             Assert.assertFalse(enrollmentStatus);
         } catch (DeviceManagementException e) {
-            String msg = "Error Occured while enrolling device";
+            String msg = "Error occurred while enrolling device";
             Assert.fail(msg, e);
         }
     }
 
 
-    @Test(dependsOnMethods = {"testSuccessfullDeviceEnrollment"})
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
     public void testReEnrollmentofSameDeviceUnderSameUser() {
         Device device = TestDataHolder.generateDummyDeviceData(DEVICE_TYPE);
 
@@ -119,48 +174,47 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
             boolean enrollment = deviceMgtService.enrollDevice(device);
 
             Assert.assertTrue(enrollment);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while enrolling device";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceUnderSameUser"})
+    public void testReEnrollmentofSameDeviceWithOtherUser() {
+
+        EnrolmentInfo enrolmentInfo = new EnrolmentInfo();
+        enrolmentInfo.setDateOfEnrolment(new Date().getTime());
+        enrolmentInfo.setDateOfLastUpdate(new Date().getTime());
+        enrolmentInfo.setOwner("user1");
+        enrolmentInfo.setOwnership(EnrolmentInfo.OwnerShip.BYOD);
+        enrolmentInfo.setStatus(EnrolmentInfo.Status.CREATED);
+
+        Device alternateDevice = TestDataHolder.generateDummyDeviceData("12345", DEVICE_TYPE,
+                enrolmentInfo);
+
+        try {
+            Device retrievedDevice1 = deviceMgtService.getDevice(new DeviceIdentifier("12345", DEVICE_TYPE));
+
+            deviceMgtService.enrollDevice(alternateDevice);
+            Device retrievedDevice2 = deviceMgtService.getDevice(new DeviceIdentifier(alternateDevice
+                    .getDeviceIdentifier(), alternateDevice.getType()));
+
+            log.info(retrievedDevice1.getEnrolmentInfo().getOwner());
+            log.info(retrievedDevice2.getEnrolmentInfo().getOwner());
+
+            Assert.assertFalse(retrievedDevice1.getEnrolmentInfo().getOwner().equalsIgnoreCase
+                    (retrievedDevice2.getEnrolmentInfo().getOwner()));
         } catch (DeviceManagementException e) {
             String msg = "Error Occured while enrolling device";
             Assert.fail(msg, e);
         }
     }
 
-//    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceUnderSameUser"})
-//    public void testReEnrollmentofSameDeviceWithOtherUser() {
-//
-//        EnrolmentInfo enrolmentInfo = new EnrolmentInfo();
-//        enrolmentInfo.setDateOfEnrolment(new Date().getTime());
-//        enrolmentInfo.setDateOfLastUpdate(new Date().getTime());
-//        enrolmentInfo.setOwner("user1");
-//        enrolmentInfo.setOwnership(EnrolmentInfo.OwnerShip.BYOD);
-//        enrolmentInfo.setStatus(EnrolmentInfo.Status.CREATED);
-//
-//        Device alternateDevice = TestDataHolder.generateDummyDeviceData("12345", DEVICE_TYPE,
-//                enrolmentInfo);
-//
-//        try {
-//            Device retrievedDevice1 = deviceMgtService.getDevice(new DeviceIdentifier("12345", DEVICE_TYPE));
-//
-//            deviceMgtService.enrollDevice(alternateDevice);
-//            Device retrievedDevice2 = deviceMgtService.getDevice(new DeviceIdentifier(alternateDevice
-//                    .getDeviceIdentifier(), alternateDevice.getType()));
-//
-//            log.info(retrievedDevice1.getEnrolmentInfo().getOwner());
-//            log.info(retrievedDevice2.getEnrolmentInfo().getOwner());
-//
-//            Assert.assertFalse(retrievedDevice1.getEnrolmentInfo().getOwner().equalsIgnoreCase
-//                    (retrievedDevice2.getEnrolmentInfo().getOwner()));
-//        } catch (DeviceManagementException e) {
-//            String msg = "Error Occured while enrolling device";
-//            Assert.fail(msg, e);
-//        }
-//    }
 
-
+    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceWithOtherUser"})
-    @Test(dependsOnMethods = {"testReEnrollmentofSameDeviceUnderSameUser"})
     public void testDisenrollment() {
         Device device = TestDataHolder.generateDummyDeviceData(DEVICE_TYPE);
-
         try {
             boolean disenrollmentStatus = deviceMgtService.disenrollDevice(new DeviceIdentifier
                     (device
@@ -170,9 +224,293 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
 
             Assert.assertTrue(disenrollmentStatus);
         } catch (DeviceManagementException e) {
-            String msg = "Error Occured while enrolling device";
+            String msg = "Error occurred while enrolling device";
             Assert.fail(msg, e);
         }
     }
 
-}
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceCount() {
+        try {
+            int count = deviceMgtService.getDeviceCount();
+            Assert.assertTrue(count > 0);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while getting the device count";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceCountForUser() {
+        try {
+            int count = deviceMgtService.getDeviceCount(TestDataHolder.OWNER);
+            Assert.assertTrue(count > 0);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while getting the device count";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test
+    public void testGetDeviceCountForNonExistingUser() {
+        try {
+            int count = deviceMgtService.getDeviceCount("ABCD");
+            Assert.assertEquals(count, 0);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while getting the device count";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(expectedExceptions = DeviceManagementException.class)
+    public void testGetDeviceCountForNullUser() throws DeviceManagementException {
+        deviceMgtService.getDeviceCount(null);
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testIsActive() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId(TestDataHolder.initialDeviceIdentifier);
+            deviceIdentifier.setType(DEVICE_TYPE);
+            Assert.assertTrue(deviceMgtService.isActive(deviceIdentifier));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while checking the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test
+    public void testIsActiveForNonExistingDevice() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId("34535235235235235");
+            deviceIdentifier.setType("TEST_TYPE");
+            Assert.assertFalse(deviceMgtService.isActive(deviceIdentifier));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while checking the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testSetActive() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId(TestDataHolder.initialDeviceIdentifier);
+            deviceIdentifier.setType(DEVICE_TYPE);
+            Assert.assertFalse(deviceMgtService.setActive(deviceIdentifier, true));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test
+    public void testSetActiveForNonExistingDevice() {
+        try {
+            DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
+            deviceIdentifier.setId("34535235235235235");
+            deviceIdentifier.setType("TEST_TYPE");
+            Assert.assertFalse(deviceMgtService.setActive(deviceIdentifier, true));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status for non-existing device";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceEnrolledTenants() {
+        try {
+            List<Integer> tenants = deviceMgtService.getDeviceEnrolledTenants();
+            Assert.assertEquals(tenants.size(), 1);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDevice() {
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345",DEVICE_TYPE));
+            Assert.assertTrue(device.getDeviceIdentifier().equalsIgnoreCase("12345"));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceWithInfo() {
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345", DEVICE_TYPE)
+                    , true);
+            Assert.assertTrue(device.getDeviceInfo() != null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetDeviceWithOutInfo() {
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345", DEVICE_TYPE)
+                    , false);
+            Assert.assertTrue(device.getDeviceInfo() == null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetAllDevicesOfRole() {
+        try {
+            List<Device> devices = deviceMgtService.getAllDevicesOfRole("admin");
+            Assert.assertTrue(devices.size() > 0);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testDeviceByOwner() {
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345",
+                    DEVICE_TYPE), "admin", true);
+            Assert.assertTrue(device != null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testDeviceByDate() {
+        try {
+            Device initialDevice = deviceMgtService.getDevice(new DeviceIdentifier("12345",
+                    DEVICE_TYPE));
+
+            DeviceManagementDAOFactory.beginTransaction();
+
+            //Device details table will be reffered when looking for last updated time
+            //This dao entry is to mimic a device info operation
+            deviceDetailsDAO.addDeviceInformation(initialDevice.getId(), TestDataHolder
+                    .generateDummyDeviceInfo());
+        } catch (DeviceManagementException e) {
+            e.printStackTrace();
+        } catch (TransactionManagementException e) {
+            e.printStackTrace();
+        } catch (DeviceDetailsMgtDAOException e) {
+            e.printStackTrace();
+        } finally {
+            DeviceManagementDAOFactory.closeConnection();
+        }
+
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345",
+                    DEVICE_TYPE), yesterday());
+            Assert.assertTrue(device != null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testDeviceByDate"})
+    public void testDeviceByDateAndOwner() {
+        try {
+            Device device = deviceMgtService.getDevice(new DeviceIdentifier("12345",
+                    DEVICE_TYPE), "admin", yesterday(), true);
+            Assert.assertTrue(device != null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test
+    public void testGetAvaliableDeviceTypes() {
+        try {
+            List<String> deviceTypes = deviceMgtService.getAvailableDeviceTypes();
+            Assert.assertTrue(!deviceTypes.isEmpty());
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testSuccessfulDeviceEnrollment"})
+    public void testGetAllDevices() {
+        try {
+            List<Device> devices = deviceMgtService.getAllDevices();
+            Assert.assertTrue(!devices.isEmpty());
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testDeviceByDate"})
+    public void testGetAllDevicesWithInfo() {
+        try {
+            List<Device> devices = deviceMgtService.getAllDevices(true);
+            Assert.assertTrue(!devices.isEmpty());
+            Assert.assertTrue(devices.get(0).getDeviceInfo() != null);
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(dependsOnMethods = {"testDeviceByDate"})
+    public void testGetLicense() {
+        try {
+            License license = deviceMgtService.getLicense(DEVICE_TYPE, "ENG");
+            Assert.assertTrue(license.getLanguage().equalsIgnoreCase("ENG"));
+        } catch (DeviceManagementException e) {
+            String msg = "Error occurred while updating the device status";
+            Assert.fail(msg, e);
+        }
+    }
+
+    @Test(expectedExceptions = DeviceManagementException.class)
+    public void testSendRegistrationEmailNoMetaInfo() throws ConfigurationManagementException, DeviceManagementException {
+        deviceMgtService.sendRegistrationEmail(null);
+        Assert.assertTrue(false);
+    }
+
+    @Test
+    public void testSendRegistrationEmailSuccessFlow() {
+        try {
+            String recipient = "test-user@wso2.com";
+            Properties props = new Properties();
+            props.setProperty("first-name", "Test");
+            props.setProperty("username", "User");
+            props.setProperty("password", "!@#$$$%");
+
+            EmailMetaInfo metaInfo = new EmailMetaInfo(recipient, props);
+
+            deviceMgtService.sendRegistrationEmail(metaInfo);
+            Assert.assertTrue(true);
+        }  catch (ConfigurationManagementException e) {
+            Assert.assertTrue(false, "Error in sending registration email : Configration " +
+                    "related error" + e.getMessage());
+        } catch (DeviceManagementException e) {
+            Assert.assertTrue(false, "Error in sending registration email" +
+                    e.getMessage());
+        }
+    }
+
+    private Date yesterday() {
+        final Calendar cal = Calendar.getInstance();
+        cal.add(Calendar.DATE, -1);
+        return cal.getTime();
+    }
+
+
+}

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

@@ -34,6 +34,7 @@ import org.wso2.carbon.device.mgt.common.group.mgt.GroupNotExistException;
 import org.wso2.carbon.device.mgt.common.group.mgt.RoleDoesNotExistException;
 import org.wso2.carbon.device.mgt.core.TestUtils;
 import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
 import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.config.cache.DeviceCacheConfiguration;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
@@ -269,7 +270,7 @@ public class GroupManagementProviderServiceTest extends BaseDeviceManagementTest
     public void getGroupsByDeviceIdentifier() throws GroupManagementException {
         DeviceIdentifier identifier = new DeviceIdentifier();
         identifier.setId("12345");
-        identifier.setType("Test");
+        identifier.setType(TestDataHolder.TEST_DEVICE_TYPE);
         List<DeviceGroup> groups = groupManagementProviderService.getGroups(identifier);
         Assert.assertNotNull(groups);
     }

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/task/DeviceTaskManagerServiceTest.java

@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.device.mgt.core.task;
+
+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;
+import org.wso2.carbon.device.mgt.core.TestTaskServiceImpl;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.task.impl.DeviceTaskManagerServiceImpl;
+import org.wso2.carbon.ntask.common.TaskException;
+import org.wso2.carbon.ntask.core.TaskInfo;
+import org.wso2.carbon.ntask.core.TaskManager;
+import org.wso2.carbon.ntask.core.internal.TasksDSComponent;
+import org.wso2.carbon.ntask.core.service.TaskService;
+import org.wso2.carbon.ntask.core.service.impl.TaskServiceImpl;
+
+import java.lang.reflect.Field;
+
+public class DeviceTaskManagerServiceTest {
+    private static final Log log = LogFactory.getLog(DeviceTaskManagerService.class);
+    private static final String TASK_TYPE = "DEVICE_MONITORING";
+    private DeviceTaskManagerService deviceTaskManagerService;
+    private TaskService taskService;
+
+    @BeforeClass
+    public void init() throws Exception {
+        DeviceConfigurationManager.getInstance().initConfig();
+        log.info("Initializing Device Task Manager Service Test Suite");
+        this.taskService = new TestTaskServiceImpl();
+        DeviceManagementDataHolder.getInstance().setTaskService(this.taskService);
+        this.deviceTaskManagerService = new DeviceTaskManagerServiceImpl();
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(this.deviceTaskManagerService);
+        Field taskServiceField = TasksDSComponent.class.getDeclaredField("taskService");
+        taskServiceField.setAccessible(true);
+        taskServiceField.set(null, Mockito.mock(TaskServiceImpl.class, Mockito.RETURNS_MOCKS));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group")
+    public void testStartTask() {
+        try {
+            log.debug("Attempting to start task from testStartTask");
+            this.deviceTaskManagerService.startTask(TestDataHolder.TEST_DEVICE_TYPE,
+                    TestDataHolder.generateMonitoringTaskConfig(true, 60000, 1));
+            TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
+            Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
+            Assert.assertNotNull(taskManager
+                    .getTask(TestDataHolder.TEST_DEVICE_TYPE +
+                            String.valueOf(TestDataHolder.SUPER_TENANT_ID)));
+            log.debug("Task Successfully started");
+        } catch (DeviceMgtTaskException | TaskException e) {
+            Assert.fail("Exception occurred when starting the task", e);
+        }
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testStartTask")
+    public void testUpdateTask() {
+        try {
+            log.debug("Attempting to update task from testStartTask");
+            TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
+            this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                    TestDataHolder.generateMonitoringTaskConfig(true, 30000, 1));
+            Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
+            Assert.assertEquals(taskManager.getAllTasks().size(), 1);
+            log.debug("Task Successfully updated");
+        } catch (DeviceMgtTaskException | TaskException e) {
+            Assert.fail("Exception occurred when updating the task", e);
+        }
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateTask")
+    public void testStopTask() {
+        log.debug("Attempting to stop task from testStopTask");
+        try {
+            this.deviceTaskManagerService.stopTask(TestDataHolder.TEST_DEVICE_TYPE,
+                    TestDataHolder.generateMonitoringTaskConfig(true, 30000, 1));
+            TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
+            Assert.assertEquals(taskManager.getAllTasks().size(), 0);
+        } catch (DeviceMgtTaskException | TaskException e) {
+            Assert.fail("Exception occurred when stopping the task", e);
+        }
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testStopTask", expectedExceptions = {
+            DeviceMgtTaskException.class })
+    public void testUpdateUnscheduledTask() throws DeviceMgtTaskException {
+        log.debug("Attempting to update unscheduled task");
+        this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 1));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask", expectedExceptions = {
+            DeviceMgtTaskException.class })
+    public void testStartTaskWhenUnableToRetrieveTaskManager()
+            throws DeviceMgtTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to get TaskManager", TaskException.Code.UNKNOWN)).when(taskService)
+                .getTaskManager(TASK_TYPE);
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.startTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask", expectedExceptions = {
+            DeviceMgtTaskException.class })
+    public void testUpdateTaskWhenUnableToRetrieveTaskManager()
+            throws DeviceMgtTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to get TaskManager", TaskException.Code.UNKNOWN)).when(taskService)
+                .getTaskManager(TASK_TYPE);
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testStartTaskWhenFailedToRegisterTaskType()
+            throws DeviceMgtTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to register task type", TaskException.Code.UNKNOWN)).when(taskService)
+                .registerTaskType(TASK_TYPE);
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.startTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testStartTaskWhenFailedToRegisterTask()
+            throws DeviceMgtTaskException, TaskException {
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
+        taskService.setTaskManager(taskManager);
+        Mockito.doThrow(new TaskException("Unable to register task", TaskException.Code.UNKNOWN)).when(taskManager)
+                .registerTask(Mockito.any(TaskInfo.class));
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.startTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testUpdateTaskWhenFailedToRegisterTask()
+            throws DeviceMgtTaskException, TaskException {
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
+        taskService.setTaskManager(taskManager);
+        Mockito.doThrow(new TaskException("Unable to register task", TaskException.Code.UNKNOWN)).when(taskManager)
+                .registerTask(Mockito.any(TaskInfo.class));
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testUpdateTaskWhenFailedToRescheduleTask()
+            throws DeviceMgtTaskException, TaskException {
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
+        taskService.setTaskManager(taskManager);
+        Mockito.doThrow(new TaskException("Unable to reschedule task", TaskException.Code.UNKNOWN)).when(taskManager)
+                .rescheduleTask(Mockito.any(String.class));
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testUpdateTaskWhenFailedToDeleteTask()
+            throws DeviceMgtTaskException, TaskException {
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
+        taskService.setTaskManager(taskManager);
+        Mockito.doThrow(new TaskException("Unable to delete task", TaskException.Code.UNKNOWN)).when(taskManager)
+                .deleteTask(Mockito.any(String.class));
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.updateTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {DeviceMgtTaskException.class })
+    public void testStopTaskWhenFailedToDeleteTask()
+            throws DeviceMgtTaskException, TaskException {
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
+        taskService.setTaskManager(taskManager);
+        Mockito.doThrow(new TaskException("Unable to delete task", TaskException.Code.UNKNOWN)).when(taskManager)
+                .deleteTask(Mockito.any(String.class));
+        DeviceManagementDataHolder.getInstance().setTaskService(taskService);
+        this.deviceTaskManagerService.stopTask(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 2));
+    }
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/task/DeviceTaskManagerTest.java

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.device.mgt.core.task;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+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.operation.mgt.Operation;
+import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManagementException;
+import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
+import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
+import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
+import org.wso2.carbon.device.mgt.core.TestUtils;
+import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
+import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
+import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
+import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
+import org.wso2.carbon.device.mgt.core.operation.TestNotificationStrategy;
+import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
+import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
+import org.wso2.carbon.device.mgt.core.task.impl.DeviceDetailsRetrieverTask;
+import org.wso2.carbon.device.mgt.core.task.impl.DeviceTaskManagerImpl;
+import org.wso2.carbon.registry.core.exceptions.RegistryException;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * This is a test class to test the functionality in {@link DeviceTaskManager}.
+ */
+public class DeviceTaskManagerTest extends BaseDeviceManagementTest {
+
+    private static final Log log = LogFactory.getLog(DeviceTaskManagerTest.class);
+    private static final String NEW_DEVICE_TYPE = "NEW-DEVICE-TYPE";
+    private static final String DEVICE_DETAIL_RETRIEVER_OPPCONFIG = "{\"isEnabled\":true,\"frequency\":60000," +
+            "\"monitoringOperation\":[{\"taskName\":\"DEVICE_INFO\",\"recurrentTimes\":2}]}";
+    private List<DeviceIdentifier> deviceIds;
+    private DeviceTaskManager deviceTaskManager;
+    private DeviceManagementProviderService deviceMgtProviderService;
+    private OperationManager operationManager;
+
+    @BeforeClass
+    public void init() throws DeviceManagementException, RegistryException {
+        log.info("Initializing Device Task Manager Test Suite");
+        this.deviceIds = new ArrayList<>();
+        for (int i = 0; i < 5; i++) {
+            deviceIds.add(new DeviceIdentifier(UUID.randomUUID().toString(), TestDataHolder.TEST_DEVICE_TYPE));
+        }
+        List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
+        this.deviceMgtProviderService = new DeviceManagementProviderServiceImpl();
+
+        DeviceManagementServiceComponent.notifyStartupListeners();
+        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(this.deviceMgtProviderService);
+        DeviceManagementDataHolder.getInstance()
+                .setRegistryService(TestUtils.getRegistryService(DeviceTaskManagerTest.class));
+        DeviceManagementDataHolder.getInstance()
+                .setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
+        NotificationStrategy notificationStrategy = new TestNotificationStrategy();
+        this.operationManager = new OperationManagerImpl(TestDataHolder.TEST_DEVICE_TYPE, notificationStrategy);
+        this.deviceMgtProviderService.registerDeviceType(
+                new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE, TestDataHolder.SUPER_TENANT_DOMAIN));
+        for (Device device : devices) {
+            this.deviceMgtProviderService.enrollDevice(device);
+        }
+        this.deviceTaskManager = new DeviceTaskManagerImpl(TestDataHolder.TEST_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 60000, 3));
+    }
+
+    @Test(groups = "Device Task Manager Test Group", description = "Getting the task frequency from the scheduler")
+    public void testGetTaskFrequency() throws DeviceMgtTaskException {
+        log.info("Attempting to retrieve task frequency.");
+        Assert.assertEquals(this.deviceTaskManager.getTaskFrequency(), 60000);
+        log.info("Successfully retrieved task frequency.");
+    }
+
+    @Test(groups = "Device Task Manager Test Group", description = "Testing if the task is enabled")
+    public void testIsTaskEnabled() throws DeviceMgtTaskException {
+        log.info("Attempting to retrieve task status.");
+        Assert.assertTrue(this.deviceTaskManager.isTaskEnabled());
+        log.info("Successfully retrieved task status.");
+    }
+
+    @Test(groups = "Device Task Manager Test Group", description = "Testing adding operations to devices.")
+    public void testAddOperation() throws DeviceMgtTaskException, OperationManagementException {
+        log.info("Attempting to add operations for devices.");
+        this.deviceTaskManager.addOperations();
+        for (DeviceIdentifier deviceId : deviceIds) {
+            List<? extends Operation> operationList = this.operationManager.getOperations(deviceId);
+            Assert.assertNotNull(operationList);
+            Assert.assertEquals(operationList.size(), 3);
+        }
+        log.info("Successfully added operations for devices.");
+    }
+
+    @Test(groups = "Device Task Manager Test Group",
+            description = "Testing adding operations when no devices are available")
+    public void testAddOperationsWithoutDevices() throws DeviceManagementException, DeviceMgtTaskException {
+        this.deviceMgtProviderService.registerDeviceType(
+                new TestDeviceManagementService(NEW_DEVICE_TYPE, TestDataHolder.SUPER_TENANT_DOMAIN));
+        DeviceTaskManager taskManager = new DeviceTaskManagerImpl(NEW_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 50000, 3));
+        taskManager.addOperations();
+    }
+
+    @Test(groups = "Device Task Manager Test Group", dependsOnMethods = "testAddOperationsWithoutDevices",
+            description = "Testing adding operations when no operations are scheduled")
+    public void testAddOperationsWithoutOperations() throws DeviceMgtTaskException {
+        DeviceTaskManager taskManager = new DeviceTaskManagerImpl(NEW_DEVICE_TYPE,
+                TestDataHolder.generateMonitoringTaskConfig(true, 50000, 3));
+        taskManager.addOperations();
+    }
+
+    @Test(groups = "Device Task Manager Test Group", description = "Testing device detail retriever task execution")
+    public void testDeviceDetailRetrieverTaskExecute() throws OperationManagementException {
+        DeviceDetailsRetrieverTask deviceDetailsRetrieverTask = new DeviceDetailsRetrieverTask();
+        Map<String, String> map = new HashMap<>();
+        map.put("DEVICE_TYPE", TestDataHolder.TEST_DEVICE_TYPE);
+        map.put("OPPCONFIG", DEVICE_DETAIL_RETRIEVER_OPPCONFIG);
+        deviceDetailsRetrieverTask.setProperties(map);
+        deviceDetailsRetrieverTask.execute();
+        for (DeviceIdentifier deviceId : deviceIds) {
+            List<? extends Operation> operationList = this.operationManager.getOperations(deviceId);
+            Assert.assertNotNull(operationList);
+            Assert.assertEquals(operationList.size(), 4,
+                    "Expected number of operations is 4 after adding the device detail retriever operation");
+            Assert.assertEquals(operationList.get(0).getCode(), "DEVICE_INFO",
+                    "Operation code of the device detail retriever task should be DEVICE_LOCATION");
+        }
+    }
+
+    @Test(groups = "Device Task Manager Test Group",
+            description = "Testing device detail retriever task execution for tenants")
+    public void testDeviceDetailRetrieverTaskExecuteForAllTenants() throws OperationManagementException {
+        DeviceDetailsRetrieverTask deviceDetailsRetrieverTask = new DeviceDetailsRetrieverTask();
+        System.setProperty("is.cloud", "true");
+        Map<String, String> map = new HashMap<>();
+        map.put("DEVICE_TYPE", TestDataHolder.TEST_DEVICE_TYPE);
+        map.put("OPPCONFIG", DEVICE_DETAIL_RETRIEVER_OPPCONFIG);
+        deviceDetailsRetrieverTask.setProperties(map);
+        deviceDetailsRetrieverTask.execute();
+        for (DeviceIdentifier deviceId : deviceIds) {
+            List<? extends Operation> operationList = this.operationManager.getOperations(deviceId);
+            Assert.assertNotNull(operationList);
+            Assert.assertEquals(operationList.size(), 4);
+            Assert.assertEquals(operationList.get(0).getCode(), "DEVICE_INFO",
+                    "Operation code of the device detail retriever task should be DEVICE_LOCATION");
+        }
+    }
+
+    @AfterClass
+    public void cleanup() throws DeviceManagementException {
+        for (DeviceIdentifier deviceId: deviceIds) {
+            this.deviceMgtProviderService.disenrollDevice(deviceId);
+        }
+    }
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/java/org/wso2/carbon/device/mgt/core/task/TestTaskManagerImpl.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * you may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.wso2.carbon.device.mgt.core.task;
+
+import org.wso2.carbon.ntask.common.TaskException;
+import org.wso2.carbon.ntask.core.TaskInfo;
+import org.wso2.carbon.ntask.core.TaskManager;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestTaskManagerImpl implements TaskManager {
+    private List<TaskInfo> registeredTasks;
+
+    public TestTaskManagerImpl() {
+        this.registeredTasks = new ArrayList<>();
+    }
+
+    @Override
+    public void initStartupTasks() throws TaskException {
+
+    }
+
+    @Override
+    public void scheduleTask(String taskName) throws TaskException {
+
+    }
+
+    @Override
+    public void rescheduleTask(String taskName) throws TaskException {
+
+    }
+
+    @Override
+    public boolean deleteTask(String taskName) throws TaskException {
+        for (TaskInfo task : this.registeredTasks) {
+            if (task.getName().contains(taskName)) {
+                this.registeredTasks.remove(task);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void pauseTask(String taskName) throws TaskException {
+
+    }
+
+    @Override
+    public void resumeTask(String taskName) throws TaskException {
+
+    }
+
+    @Override
+    public void registerTask(TaskInfo taskInfo) throws TaskException {
+        this.registeredTasks.add(taskInfo);
+    }
+
+    @Override
+    public TaskState getTaskState(String taskName) throws TaskException {
+        return null;
+    }
+
+    @Override
+    public TaskInfo getTask(String taskName) throws TaskException {
+        for (TaskInfo task : this.registeredTasks) {
+            if (task.getName().contains(taskName)) {
+                return task;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public List<TaskInfo> getAllTasks() throws TaskException {
+        return this.registeredTasks;
+    }
+
+    @Override
+    public boolean isTaskScheduled(String taskName) throws TaskException {
+        return this.registeredTasks.size() > 0;
+    }
+}

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/resources/carbon-home/repository/conf/etc/tasks-config.xml

@@ -0,0 +1,51 @@
+<tasks-configuration xmlns:svns="http://org.wso2.securevault/configuration">
+
+    <!--
+      The currently running server mode; possible values are:-
+      STANDALONE, CLUSTERED, REMOTE, AUTO.
+      In AUTO mode, the server startup checks whether clustering is enabled in the system,
+      if so, CLUSTERED mode will be used, or else, the the server mode will be STANDALONE.
+    -->
+    <taskServerMode>STANDALONE</taskServerMode>
+
+    <!--
+      To be used in CLUSTERED mode to notify how many servers are there in
+      the task server cluster, the servers wait till this amount of servers
+      are activated before the tasks are scheduled -->
+    <taskServerCount>2</taskServerCount>
+
+    <!-- The default location resolver configuration -->
+    <defaultLocationResolver>
+        <locationResolverClass>org.wso2.carbon.ntask.core.impl.RoundRobinTaskLocationResolver</locationResolverClass>
+    </defaultLocationResolver>
+
+    <!--
+      if task-type-pattern matches and task-name-pattern matches, check existing addresses of address-pattern,
+      and if addresses exist, select address in round-robin fashion, if not move onto next rule in sequence.
+      <property name="rule-[order]">[task-type-pattern],[task-name-pattern],[address-pattern]</property>
+    -->
+    <!--defaultLocationResolver>
+        <locationResolverClass>org.wso2.carbon.ntask.core.impl.RuleBasedLocationResolver</locationResolverClass>
+        <properties>
+            <property name="rule-1">HIVE_TASK,.*,192.168.2.*</property>
+            <property name="rule-5">.*,.*,.*</property>
+        </properties>
+    </defaultLocationResolver-->
+
+    <!-- The address to which the remote task server should dispatch the trigger messages to,
+      usually this would be an endpoint to a load balancer -->
+    <taskClientDispatchAddress>https://localhost:9448</taskClientDispatchAddress>
+
+    <!-- The address of the remote task server -->
+    <remoteServerAddress>https://localhost:9443</remoteServerAddress>
+
+    <!-- The username to authenticate to the remote task server -->
+    <remoteServerUsername>admin</remoteServerUsername>
+
+    <!-- The password to authenticate to the remote task server -->
+    <remoteServerPassword>admin</remoteServerPassword>
+
+    <!-- Below contain a sample to be used when using with secure vault -->
+    <!--remoteServerPassword svns:secretAlias="remote.task.server.password"></remoteServerPassword-->
+
+</tasks-configuration>

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/resources/config/operation/cdm-config.xml

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+  ~
+  ~ WSO2 Inc. licenses this file to you under the Apache License,
+  ~ Version 2.0 (the "License"); you may not use this file except
+  ~ in compliance with the License.
+  ~ you may obtain a copy of the License at
+  ~
+  ~   http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing,
+  ~ software distributed under the License is distributed on an
+  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  ~ KIND, either express or implied.  See the License for the
+  ~ specific language governing permissions and limitations
+  ~ under the License.
+  -->
+
+<DeviceMgtConfiguration>
+    <ManagementRepository>
+        <DataSourceConfiguration>
+            <JndiLookupDefinition>
+                <Name>jdbc/DM_DS</Name>
+            </JndiLookupDefinition>
+        </DataSourceConfiguration>
+    </ManagementRepository>
+    <PushNotificationConfiguration>
+        <SchedulerBatchSize>2</SchedulerBatchSize>
+        <SchedulerBatchDelayMills>2000</SchedulerBatchDelayMills>
+        <SchedulerTaskInitialDelay>2000</SchedulerTaskInitialDelay>
+        <SchedulerTaskEnabled>true</SchedulerTaskEnabled>
+        <PushNotificationProviders>
+            <Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.fcm.FCMBasedPushNotificationProvider</Provider>
+            <!--<Provider>org.wso2.carbon.device.mgt.mobile.impl.ios.apns.APNSBasedPushNotificationProvider</Provider>-->
+            <Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.mqtt.MQTTBasedPushNotificationProvider</Provider>
+			<Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.http.HTTPBasedPushNotificationProvider</Provider>
+            <Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.xmpp.XMPPBasedPushNotificationProvider</Provider>
+        </PushNotificationProviders>
+    </PushNotificationConfiguration>
+	<PullNotificationConfiguration>
+		<Enabled>false</Enabled>
+	</PullNotificationConfiguration>
+    <IdentityConfiguration>
+        <ServerUrl>https://localhost:9443</ServerUrl>
+        <AdminUsername>admin</AdminUsername>
+        <AdminPassword>admin</AdminPassword>
+    </IdentityConfiguration>
+    <PolicyConfiguration>
+        <MonitoringClass>org.wso2.carbon.policy.mgt</MonitoringClass>
+        <MonitoringEnable>true</MonitoringEnable>
+        <MonitoringFrequency>60000</MonitoringFrequency>
+        <MaxRetries>5</MaxRetries>
+        <MinRetriesToMarkUnreachable>8</MinRetriesToMarkUnreachable>
+        <MinRetriesToMarkInactive>20</MinRetriesToMarkInactive>
+        <!--Set the policy evaluation point name-->
+        <!--Simple ->  Simple policy evaluation point-->
+        <!--Merged ->  Merged policy evaluation point -->
+        <PolicyEvaluationPoint>Simple</PolicyEvaluationPoint>
+    </PolicyConfiguration>
+    <!-- Default Page size configuration for paginated DM APIs-->
+    <PaginationConfiguration>
+        <DeviceListPageSize>20</DeviceListPageSize>
+        <GroupListPageSize>20</GroupListPageSize>
+        <NotificationListPageSize>20</NotificationListPageSize>
+        <ActivityListPageSize>20</ActivityListPageSize>
+        <OperationListPageSize>20</OperationListPageSize>
+        <TopicListPageSize>20</TopicListPageSize>
+    </PaginationConfiguration>
+    <!--This specifies whether to enable the DeviceStatus Task in this node. In clustered setup only master node
+     should  have to run this task.-->
+    <DeviceStatusTaskConfig>
+        <Enable>true</Enable>
+    </DeviceStatusTaskConfig>
+    <!--This controls the in-memory device cache which is local to this node. Setting it enable will activate the
+    device caching for upto configured expiry-time in seconds. In clustered setup all worker nodes can enable the
+    device-cache to improve performance. -->
+    <DeviceCacheConfiguration>
+        <Enable>false</Enable>
+        <ExpiryTime>600</ExpiryTime>
+        <!--This configuration specifies the number of cache entries in device cache. default capacity is 10000 entries.
+        This can be configured to higher number if cache eviction happens due to large number of devices in the
+        server environment-->
+        <Capacity>10000</Capacity>
+    </DeviceCacheConfiguration>
+    <CertificateCacheConfiguration>
+        <Enable>false</Enable>
+        <ExpiryTime>86400</ExpiryTime>
+    </CertificateCacheConfiguration>
+    <GeoLocationConfiguration>
+        <isEnabled>false</isEnabled>
+        <PublishLocationOperationResponse>false</PublishLocationOperationResponse>
+    </GeoLocationConfiguration>
+    <DefaultGroupsConfiguration>BYOD,COPE</DefaultGroupsConfiguration>
+</DeviceMgtConfiguration>
+

components/device-mgt/org.wso2.carbon.device.mgt.core/src/test/resources/testng.xml

@@ -42,8 +42,14 @@
             <class name="org.wso2.carbon.device.mgt.core.app.mgt.ApplicationManagementProviderServiceTest"/>
             <class name="org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceTest"/>
             <class name="org.wso2.carbon.device.mgt.core.operation.OperationManagementTests"/>
+            <class name="org.wso2.carbon.device.mgt.core.geo.service.GeoLocationProviderServiceTest"/>
+            <class name="org.wso2.carbon.device.mgt.core.operation.ScheduledTaskOperationTests"/>
             <class name="org.wso2.carbon.device.mgt.core.permission.mgt.PermissionManagerServiceTest" />
             <class name="org.wso2.carbon.device.mgt.core.notification.mgt.NotificationManagementServiceImplTests"/>
+            <class name="org.wso2.carbon.device.mgt.core.push.notification.mgt.task.PushNotificationSchedulerTaskTest"/>
+            <class name="org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerServiceTest"/>
+            <class name="org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerTest"/>
+            <class name="org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceTest"/>
         </classes>
     </test>
 </suite>

components/device-mgt/org.wso2.carbon.device.mgt.extensions/pom.xml

@@ -22,7 +22,7 @@
     <parent>
         <artifactId>device-mgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.119-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -96,6 +96,12 @@
             <groupId>org.wso2.carbon.governance</groupId>
             <artifactId>org.wso2.carbon.governance.registry.extensions</artifactId>
             <scope>test</scope>
+            <exclusions>
+            <exclusion>
+                <groupId>jaxen</groupId>
+                <artifactId>jaxen</artifactId>
+            </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>org.wso2.carbon.registry</groupId>
@@ -106,6 +112,14 @@
                     <groupId>org.slf4j</groupId>
                     <artifactId>jcl-over-slf4j</artifactId>
                 </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>log4j-over-slf4j</artifactId>
+                </exclusion>
             </exclusions>
         </dependency>
     </dependencies>

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

@@ -130,6 +130,17 @@ public class DeviceTypeManager implements DeviceManager {
             //Check whether device dao definition exist.
             String tableName = deviceTypeConfiguration.getDeviceDetails().getTableId();
             if (tableName != null && !tableName.isEmpty()) {
+                DataSource dataSource = deviceTypeConfiguration.getDataSource();
+                if (dataSource == null) {
+                    throw new DeviceTypeDeployerPayloadException("Could not find the datasource related with the "
+                            + "table id " +  tableName + " for the device type " + deviceType);
+                }
+                TableConfig tableConfig = dataSource.getTableConfig();
+
+                if (tableConfig == null) {
+                    throw new DeviceTypeDeployerPayloadException("Could not find the table config with the "
+                            + "table id " +  tableName + " for the device type " + deviceType);
+                }
                 List<Table> tables = deviceTypeConfiguration.getDataSource().getTableConfig().getTable();
                 Table deviceDefinitionTable = null;
                 for (Table table : tables) {
@@ -189,6 +200,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 +260,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 +330,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 +367,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/config/exception/DeviceTypeConfigurationException.java

@@ -21,33 +21,10 @@ package org.wso2.carbon.device.mgt.extensions.device.type.template.config.except
 public class DeviceTypeConfigurationException extends Exception {
 
     private static final long serialVersionUID = -3151279431229070297L;
-
+    
-    public DeviceTypeConfigurationException(int errorCode, String message) {
-        super(message);
-    }
-
-    public DeviceTypeConfigurationException(int errorCode, String message, Throwable cause) {
-        super(message, cause);
-    }
-
     public DeviceTypeConfigurationException(String msg, Exception nestedEx) {
         super(msg, nestedEx);
     }
 
-    public DeviceTypeConfigurationException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public DeviceTypeConfigurationException(String msg) {
-        super(msg);
-    }
-
-    public DeviceTypeConfigurationException() {
-        super();
-    }
-
-    public DeviceTypeConfigurationException(Throwable cause) {
-        super(cause);
-    }
 
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/config/exception/InvalidConfigurationStateException.java

@@ -1,53 +0,0 @@
-/*
- *   Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
- *
- *   WSO2 Inc. licenses this file to you under the Apache License,
- *   Version 2.0 (the "License"); you may not use this file except
- *   in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing,
- *   software distributed under the License is distributed on an
- *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- *   KIND, either express or implied.  See the License for the
- *   specific language governing permissions and limitations
- *   under the License.
- *
- */
-package org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception;
-
-public class InvalidConfigurationStateException extends RuntimeException {
-
-    private static final long serialVersionUID = -3151279411229070297L;
-
-    public InvalidConfigurationStateException(int errorCode, String message) {
-        super(message);
-    }
-
-    public InvalidConfigurationStateException(int errorCode, String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public InvalidConfigurationStateException(String msg, Exception nestedEx) {
-        super(msg, nestedEx);
-    }
-
-    public InvalidConfigurationStateException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public InvalidConfigurationStateException(String msg) {
-        super(msg);
-    }
-
-    public InvalidConfigurationStateException() {
-        super();
-    }
-
-    public InvalidConfigurationStateException(Throwable cause) {
-        super(cause);
-    }
-
-}

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

@@ -41,17 +41,26 @@ public class DeviceDAODefinition {
 
 
     public DeviceDAODefinition(Table table) {
+        if (table == null) {
+            throw new DeviceTypeDeployerPayloadException("Table is null. Cannot create DeviceDAODefinition");
+        }
         deviceTableName = table.getName();
         primarykey = table.getPrimaryKey();
-        List<String> attributes = table.getAttributes().getAttribute();
+
         if (deviceTableName == null || deviceTableName.isEmpty()) {
             throw new DeviceTypeDeployerPayloadException("Missing deviceTableName");
         }
 
         if (primarykey == null || primarykey.isEmpty()) {
-            throw new DeviceTypeDeployerPayloadException("Missing primaryKey ");
+            throw new DeviceTypeDeployerPayloadException("Missing primaryKey for the table " + deviceTableName);
         }
 
+        if (table.getAttributes() == null) {
+            throw new DeviceTypeDeployerPayloadException("Table " + deviceTableName + " attributes are not specified. "
+                    + "Cannot created DeviceDAODefinition");
+        }
+
+        List<String> attributes = table.getAttributes().getAttribute();
         if (attributes == null || attributes.size() == 0) {
             throw new DeviceTypeDeployerPayloadException("Missing Attributes ");
         }

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/main/java/org/wso2/carbon/device/mgt/extensions/device/type/template/exception/DeviceTypeDeployerPayloadException.java

@@ -26,20 +26,9 @@ public class DeviceTypeDeployerPayloadException extends RuntimeException {
         super(msg, nestedEx);
     }
 
-    public DeviceTypeDeployerPayloadException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
     public DeviceTypeDeployerPayloadException(String msg) {
         super(msg);
     }
 
-    public DeviceTypeDeployerPayloadException() {
-        super();
-    }
-
-    public DeviceTypeDeployerPayloadException(Throwable cause) {
-        super(cause);
-    }
 
 }

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

@@ -26,20 +26,4 @@ public class DeviceTypeMgtPluginException extends Exception{
         super(msg, nestedEx);
     }
 
-    public DeviceTypeMgtPluginException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public DeviceTypeMgtPluginException(String msg) {
-        super(msg);
-    }
-
-    public DeviceTypeMgtPluginException() {
-        super();
-    }
-
-    public DeviceTypeMgtPluginException(Throwable cause) {
-        super(cause);
-    }
-
 }

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/main/java/org/wso2/carbon/device/mgt/extensions/license/mgt/file/FileSystemBasedLicenseManager.java

@@ -39,9 +39,15 @@ public class FileSystemBasedLicenseManager implements LicenseManager {
             String licenseConfigPath =
                     PATH_MOBILE_PLUGIN_CONF_DIR + File.separator + deviceType + File.separator + "license.xml";
             File licenseConfig = new File(licenseConfigPath);
+
+            if (!licenseConfig.exists()) {
+                throw new LicenseManagementException(
+                        "License file not found in the path for the device type " + deviceType);
+            }
             JAXBContext context = JAXBContext.newInstance(License.class);
             Unmarshaller unmarshaller = context.createUnmarshaller();
             return (License) unmarshaller.unmarshal(licenseConfig);
+
         } catch (JAXBException e) {
             throw new LicenseManagementException("Error occurred while un-marshalling license configuration " +
                     "used for '" + deviceType + "' platform from file system", e);

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

@@ -51,7 +51,7 @@ public class BaseExtensionsTest {
     @BeforeSuite
     public void init() throws RegistryException, IOException {
         ClassLoader classLoader = getClass().getClassLoader();
-        URL resourceUrl = classLoader.getResource("license.rxt");
+        URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "license.rxt");
         String rxt = null;
         File carbonHome;
         if (resourceUrl != null) {

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

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.device.mgt.extensions.device.type.template;
+
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+import org.wso2.carbon.base.MultitenantConstants;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DataSource;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeDeployerPayloadException;
+import org.wso2.carbon.device.mgt.extensions.utils.Utils;
+import org.xml.sax.SAXException;
+
+import javax.xml.bind.JAXBException;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+
+/**
+ * This class tests the negative scenarios in {@link DeviceTypeManager} initialization;
+ */
+public class DeviceTypeManagerNegativeTest {
+    private DeviceTypeConfiguration defectiveDeviceTypeConfiguration1;
+    private DeviceTypeConfiguration defectiveDeviceTypeConfiguration2;
+    private DeviceTypeConfiguration androidDeviceTypeConfiguration;
+    private DeviceTypeConfigIdentifier deviceTypeConfigIdentifier;
+    private final String DEFECTIVE_DEVICE_TYPE = "defectiveDeviceType";
+    private final String TABLE_NAME = "DEFECTIVE_DEVICE";
+
+    @BeforeTest
+    public void setup()
+            throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException,
+            IOException {
+        ClassLoader classLoader = getClass().getClassLoader();
+        URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype.xml");
+        File configurationFile = null;
+        if (resourceUrl != null) {
+            configurationFile = new File(resourceUrl.getFile());
+        }
+        if (configurationFile != null) {
+            defectiveDeviceTypeConfiguration1 = Utils.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile());
+        }
+        deviceTypeConfigIdentifier = new DeviceTypeConfigIdentifier(DEFECTIVE_DEVICE_TYPE,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
+
+        resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype2.xml");
+        if (resourceUrl != null) {
+            configurationFile = new File(resourceUrl.getFile());
+        }
+        if (configurationFile != null) {
+            defectiveDeviceTypeConfiguration2 = Utils.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile());
+        }
+
+        resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android.xml");
+        if (resourceUrl != null) {
+            configurationFile = new File(resourceUrl.getFile());
+        }
+        if (configurationFile != null) {
+            androidDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile());
+        }
+    }
+
+    @Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without defining the "
+            + "datasource but by specifying the table id", expectedExceptions = { DeviceTypeDeployerPayloadException
+            .class}, expectedExceptionsMessageRegExp = "Could not find the datasource related with the table id "
+            + TABLE_NAME + " for the device type " + DEFECTIVE_DEVICE_TYPE)
+    public void testWithoutDataSource() {
+        new DeviceTypeManager(deviceTypeConfigIdentifier, defectiveDeviceTypeConfiguration1);
+
+    }
+
+    @Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without defining the "
+            + "table config",expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Could not find the table config with the table id " + TABLE_NAME
+                    + " for the device type " + DEFECTIVE_DEVICE_TYPE,
+            dependsOnMethods = {"testWithoutDataSource"})
+    public void testWithoutTableConfig() {
+        DataSource dataSource = new DataSource();
+        defectiveDeviceTypeConfiguration1.setDataSource(dataSource);
+        new DeviceTypeManager(deviceTypeConfigIdentifier, defectiveDeviceTypeConfiguration1);
+    }
+
+    @Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without defining the "
+            + "correct table as per the device details",
+            expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Could not find definition for table: " + TABLE_NAME)
+    public void testWithoutTable() {
+        new DeviceTypeManager(deviceTypeConfigIdentifier, defectiveDeviceTypeConfiguration2);
+    }
+
+    @Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without having the "
+            + "actual datasource", expectedExceptions = {DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Error while looking up the data source.*")
+    public void testWithoutProperDataSource() {
+        new DeviceTypeManager(deviceTypeConfigIdentifier, androidDeviceTypeConfiguration);
+    }
+
+    @Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without having the "
+            + "actual datasource", expectedExceptions = {DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Error while looking up the data source.*")
+    public void testWithSetupParameters() {
+        System.setProperty("setup", "true");
+        new DeviceTypeManager(deviceTypeConfigIdentifier, androidDeviceTypeConfiguration);
+
+    }
+}

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

@@ -124,7 +124,7 @@ public class DeviceTypeManagerServiceTest {
         operationMonitoringConfigs.set(rasberrypiDeviceTypeManagerService, new OperationMonitoringTaskConfig());
         initialOperationConfig.set(rasberrypiDeviceTypeManagerService, new InitialOperationConfig());
 
-        URL resourceUrl = classLoader.getResource("android.xml");
+        URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android.xml");
 
         File androidConfiguration = null;
         if (resourceUrl != null) {
@@ -132,7 +132,7 @@ public class DeviceTypeManagerServiceTest {
         }
         androidDeviceConfiguration = Utils.getDeviceTypeConfiguration(androidConfiguration);
 
-        resourceUrl = classLoader.getResource("raspberrypi.xml");
+        resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "raspberrypi.xml");
         File raspberrypiConfiguration = null;
         if (resourceUrl != null) {
             raspberrypiConfiguration = new File(resourceUrl.getFile());
@@ -304,13 +304,13 @@ public class DeviceTypeManagerServiceTest {
             throws RegistryException, IOException, SAXException, ParserConfigurationException,
             DeviceTypeConfigurationException, JAXBException {
         ClassLoader classLoader = getClass().getClassLoader();
-        URL resourceUrl = classLoader.getResource("arduino.xml");
+        URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "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,46 +51,63 @@ 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"};
+    private final String SQL_FOLDER = "sql-files" + File.separator;
 
     @BeforeTest(description = "Mocking the classes for testing")
     public void setup() throws NoSuchFieldException, IllegalAccessException, IOException, SQLException, SAXException,
             ParserConfigurationException, DeviceTypeConfigurationException, JAXBException {
         ClassLoader classLoader = getClass().getClassLoader();
-        URL resourceUrl = classLoader.getResource("android_h2.sql");
+        URL resourceUrl = classLoader.getResource(SQL_FOLDER + "android_h2.sql");
         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()) {
+        resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android.xml");
-            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 +117,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 +134,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 +155,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 +199,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 +222,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 +243,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 +266,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 +276,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(SQL_FOLDER + "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,14 +21,10 @@ 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.ConfigurationEntry;
 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;
@@ -36,19 +32,10 @@ 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 +46,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 +54,7 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
     private HTTPDeviceTypeManagerService httpDeviceTypeManagerService;
     private DeviceTypeGeneratorServiceImpl deviceTypeGeneratorService;
     private String androidSenseDeviceType = "androidsense";
-    private String sampleDeviceType = "sample";
+    private DeviceManagementService generatedDeviceManagementService;
 
     @BeforeTest
     public void setup() throws RegistryException, IOException, SAXException, ParserConfigurationException,
@@ -100,12 +85,63 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
 
     @Test(description = "This test case tests the populate device management service method")
     public void testPopulateDeviceManagementService() {
-        DeviceManagementService deviceManagementService = deviceTypeGeneratorService
+        String sampleDeviceType = "sample";
+        generatedDeviceManagementService = deviceTypeGeneratorService
                 .populateDeviceManagementService(sampleDeviceType, deviceTypeMetaDefinition);
-        Assert.assertEquals(deviceManagementService.getType(), sampleDeviceType,
+        Assert.assertEquals(generatedDeviceManagementService.getType(), sampleDeviceType,
                 "DeviceTypeGeneration for the " + "sample device type failed");
     }
 
+    @Test(description = "This test case tests the get configuration of the populated device management service though"
+            + " DeviceTypeGeneratorService", dependsOnMethods = {"testPopulateDeviceManagementService"})
+    public void testGetConfiguration() throws DeviceManagementException, ClassNotFoundException, JAXBException {
+        PlatformConfiguration platformConfiguration = generatedDeviceManagementService.getDeviceManager()
+                .getConfiguration();
+        Assert.assertNotNull(platformConfiguration,
+                "Default platform configuration is not added to sample device " + "type from the file system");
+
+        List<ConfigurationEntry> configurationEntries = platformConfiguration.getConfiguration();
+        Assert.assertNotNull(configurationEntries,
+                "Platform Configuration entries are not parsed and saved " + "correctly for device type sample");
+        Assert.assertEquals(configurationEntries.size(), 1,
+                "Platform configuration is not saved correctly for " + "device type sample");
+
+        ConfigurationEntry configurationEntry = configurationEntries.get(0);
+
+        Assert.assertEquals(configurationEntry.getName(), "test",
+                "Platform Configuration for device type " + "sample is not saved correctly");
+
+        String contentType = configurationEntry.getContentType();
+        Assert.assertEquals(contentType, "String",
+                "Content type added in default platform configuration is different from the retrieved value");
+
+    }
+
+
+    @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.
@@ -118,7 +154,7 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
             throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException,
             IOException {
         ClassLoader classLoader = getClass().getClassLoader();
-        URL resourceUrl = classLoader.getResource("android_sense.xml");
+        URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android_sense.xml");
         File androidSenseConfiguration = null;
 
         if (resourceUrl != null) {

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.device.mgt.extensions.device.type.template.dao;
+
+import org.testng.annotations.Test;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Table;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeDeployerPayloadException;
+
+/**
+ * This class tests the negative scenarios related with {@link DeviceDAODefinition}
+ */
+public class DeviceDAODefinitionNegativeTest {
+    private final String DEVICE_TABLE_NAME = "DEVICE_TABLE";
+
+    @Test(description = "This test case tests the behavior of the DeviceDAODefinition when the table is null",
+            expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Table is null. Cannot create DeviceDAODefinition")
+    public void testWhenTableIsNull() {
+        new DeviceDAODefinition(null);
+    }
+
+    @Test(description = "This test case tests the behavior of the DeviceDAODefinition when the table name is null",
+            expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Missing deviceTableName")
+    public void testWhenTableNameIsNull() {
+        new DeviceDAODefinition(new Table());
+    }
+
+    @Test(description = "This test case tests the behavior of the DeviceDAODefinition when the primary key is null",
+            expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Missing primaryKey for the table " + DEVICE_TABLE_NAME)
+    public void testWhenPrimaryKeyIsEmpty() {
+        Table deviceTable = new Table();
+        deviceTable.setName(DEVICE_TABLE_NAME);
+        deviceTable.setPrimaryKey("");
+        new DeviceDAODefinition(deviceTable);
+    }
+
+    @Test(description = "This test case tests the behavior of the DeviceDAODefinition when the attributes is null",
+            expectedExceptions = { DeviceTypeDeployerPayloadException.class},
+            expectedExceptionsMessageRegExp = "Table " + DEVICE_TABLE_NAME + " attributes are not specified. "
+                    + "Cannot created DeviceDAODefinition")
+    public void testWhenAttributesIsNull() {
+        Table deviceTable = new Table();
+        deviceTable.setName(DEVICE_TABLE_NAME);
+        deviceTable.setPrimaryKey("primaryKey");
+        new DeviceDAODefinition(deviceTable);
+    }
+}

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/java/org/wso2/carbon/device/mgt/extensions/utils/Utils.java

@@ -21,7 +21,6 @@ package org.wso2.carbon.device.mgt.extensions.utils;
 
 import org.h2.jdbcx.JdbcDataSource;
 import org.w3c.dom.Document;
-import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceDetails;
 import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
@@ -56,16 +55,18 @@ import java.util.List;
  * This class handles the test utility tasks.
  */
 public class Utils {
+    public static final String DEVICE_TYPE_FOLDER = "device-types" + File.separator;
 
     /**
      * To get the device type configuration based on the configuration file
+     *
      * @param configurationFile Relevant configuration file of a device type
      * @return the DeviceTypeConfiguration object of the relevant Device Type
      * @throws DeviceTypeConfigurationException DeviceType Configuration Exception
-     * @throws IOException IO Exception
+     * @throws IOException                      IO Exception
-     * @throws SAXException SAX Exception
+     * @throws SAXException                     SAX Exception
-     * @throws ParserConfigurationException Parser Configuration Exception
+     * @throws ParserConfigurationException     Parser Configuration Exception
-     * @throws JAXBException JAXB Exception
+     * @throws JAXBException                    JAXB Exception
      */
     public static  DeviceTypeConfiguration getDeviceTypeConfiguration(File configurationFile)
             throws DeviceTypeConfigurationException, IOException, SAXException, ParserConfigurationException,

components/device-mgt/org.wso2.carbon.device.mgt.extensions/src/test/java/org/wso2/carbon/device/mgt/extensions/utils/UtilsTest.java

@@ -0,0 +1,84 @@
+/*
+ *   Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ *   WSO2 Inc. licenses this file to you under the Apache License,
+ *   Version 2.0 (the "License"); you may not use this file except
+ *   in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing,
+ *   software distributed under the License is distributed on an
+ *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *   KIND, either express or implied.  See the License for the
+ *   specific language governing permissions and limitations
+ *   under the License.
+ *
+ */
+
+package org.wso2.carbon.device.mgt.extensions.utils;
+
+import org.testng.Assert;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+import org.wso2.carbon.base.MultitenantConstants;
+import org.wso2.carbon.device.mgt.common.license.mgt.License;
+import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException;
+import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceSchemaInitializer;
+import org.wso2.carbon.device.mgt.extensions.license.mgt.file.FileSystemBasedLicenseManager;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * This is a test case for testing common utilities used.
+ */
+public class UtilsTest {
+    private FileSystemBasedLicenseManager fileSystemBasedLicenseManager;
+
+    @BeforeTest
+    public void setup() {
+        fileSystemBasedLicenseManager = new FileSystemBasedLicenseManager();
+    }
+
+    @Test(description = "This testcase tests the functionality of the DeviceSchemaInitializer")
+    public void testDeviceSchemaInitializer()
+            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        String deviceType = "sample2";
+        String expectedDBLocation =
+                System.getProperty("carbon.home") + File.separator + "dbscripts" + File.separator + "cdm"
+                        + File.separator + "plugins" + File.separator + deviceType + File.separator + "h2.sql";
+        DeviceSchemaInitializer deviceSchemaInitializer = new DeviceSchemaInitializer(null, deviceType,
+                MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
+        Method getDbScriptLocation = DeviceSchemaInitializer.class
+                .getDeclaredMethod("getDbScriptLocation", String.class);
+        getDbScriptLocation.setAccessible(true);
+
+        String dbLocation = (String) getDbScriptLocation.invoke(deviceSchemaInitializer, "h2");
+        Assert.assertEquals(dbLocation, expectedDBLocation,
+                "Expected DB location for the device type is not retrieved");
+    }
+
+    @Test(description = "This test case tests the getLicense method of the FileBasedLicenseManager")
+    public void testFileBasedLicenseManagerGetLicense() throws LicenseManagementException {
+        License fileBasedLicense = fileSystemBasedLicenseManager.getLicense("test","en_US");
+        Assert.assertEquals(fileBasedLicense.getText(), "This is a file based license",
+                "FileBased License cannot " + "be retrieved by FileBasedLicenseManager");
+    }
+
+    @Test(description = "This test case tests the behaviour of file based license manager when the relevant license "
+            + "is missing in file system", expectedExceptions = {LicenseManagementException.class},
+            expectedExceptionsMessageRegExp = "License file not found in the path for the device type test2")
+    public void testFileBasedLicenseManagerGetNonExistingLicense() throws LicenseManagementException {
+       fileSystemBasedLicenseManager.getLicense("test2","en_US");
+    }
+
+    @Test(description = "This test case make sure the File Based License cannot be added without adding directly to "
+            + "file system", expectedExceptions = {UnsupportedOperationException.class},
+            expectedExceptionsMessageRegExp = "'addLicense' method is not supported in FileSystemBasedLicenseManager")
+    public void testFileBasedLicenseManagerAddLicense() throws LicenseManagementException {
+       fileSystemBasedLicenseManager.addLicense("test", null);
+    }
+}