Merge branch 'wso2-master' into origin-wso2-master

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.131-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.131-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.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
-    <version>3.0.131-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.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
-    <version>3.0.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-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.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -163,11 +163,6 @@
             <groupId>org.wso2.carbon.devicemgt</groupId>
             <artifactId>org.wso2.carbon.device.mgt.common</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.powermock</groupId>
-            <artifactId>powermock-api-mockito</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.wso2.carbon.devicemgt</groupId>
             <artifactId>org.wso2.carbon.device.mgt.analytics.data.publisher</artifactId>

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

@@ -38,6 +38,10 @@ public class TestTaskServiceImpl implements TaskService {
         this.taskManager = new TestTaskManagerImpl();
     }
 
+    public void setTaskManager(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
     @Override
     public TaskManager getTaskManager(String s) throws TaskException {
         return this.taskManager;

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

@@ -22,6 +22,7 @@ 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;
@@ -108,7 +109,7 @@ 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);

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

@@ -18,6 +18,9 @@
  */
 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;
@@ -41,12 +44,14 @@ 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;
@@ -89,6 +94,8 @@ public abstract class BaseDeviceManagementTest {
         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 {
@@ -101,6 +108,19 @@ public abstract class BaseDeviceManagementTest {
         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,12 +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.PaginationRequest;
+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;
@@ -33,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;
 
@@ -61,8 +62,8 @@ public class TestDataHolder {
         deviceInfo.setIMEI("IMEI-12345");
         deviceInfo.setIMSI("IMSI-12344");
         deviceInfo.setDeviceModel("DUMMY_MODEL");
-        deviceInfo.setVendor("Google");
+        deviceInfo.setVendor("WSO2");
-        deviceInfo.setOsVersion("Oreo");
+        deviceInfo.setOsVersion("OREO");
         deviceInfo.setOsBuildDate("24-05-2017");
         deviceInfo.setBatteryLevel(25.0);
         deviceInfo.setInternalTotalMemory(1.5);
@@ -164,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/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,7 +24,10 @@ 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;
@@ -48,6 +51,7 @@ 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 {
 
@@ -429,6 +433,79 @@ public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTes
         }
     }
 
+    @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);

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

@@ -27,6 +27,7 @@ import org.wso2.carbon.device.mgt.common.*;
 import org.wso2.carbon.device.mgt.common.group.mgt.*;
 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.dao.GroupManagementDAOFactory;
@@ -266,7 +267,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

@@ -1,48 +1,50 @@
+/*
+ * 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.Mock;
 import org.mockito.Mockito;
-import org.opensaml.xml.signature.P;
-import org.powermock.api.mockito.PowerMockito;
-import org.quartz.impl.StdSchedulerFactory;
 import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
-import org.wso2.carbon.device.mgt.common.MonitoringOperation;
-import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
 import org.wso2.carbon.device.mgt.core.TestTaskServiceImpl;
-import org.wso2.carbon.device.mgt.core.TestUtils;
 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.permission.mgt.PermissionUtils;
-import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
 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.TaskUtils;
-import org.wso2.carbon.ntask.core.impl.QuartzCachedThreadPool;
 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.registry.core.exceptions.RegistryException;
 
 import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Properties;
 
 public class DeviceTaskManagerServiceTest {
     private static final Log log = LogFactory.getLog(DeviceTaskManagerService.class);
     private static final String TASK_TYPE = "DEVICE_MONITORING";
     private DeviceTaskManagerService deviceTaskManagerService;
-    @Mock private TaskService taskService;
+    private TaskService taskService;
 
-    @BeforeClass public void init() throws Exception {
+    @BeforeClass
+    public void init() throws Exception {
         DeviceConfigurationManager.getInstance().initConfig();
         log.info("Initializing Device Task Manager Service Test Suite");
         this.taskService = new TestTaskServiceImpl();
@@ -54,30 +56,31 @@ public class DeviceTaskManagerServiceTest {
         taskServiceField.set(null, Mockito.mock(TaskServiceImpl.class, Mockito.RETURNS_MOCKS));
     }
 
-    @Test(groups = "Device Task Manager")
+    @Test(groups = "Device Task Manager Service Test Group")
     public void testStartTask() {
         try {
             log.debug("Attempting to start task from testStartTask");
-            this.deviceTaskManagerService
+            this.deviceTaskManagerService.startTask(TestDataHolder.TEST_DEVICE_TYPE,
-                    .startTask(TestDataHolder.TEST_DEVICE_TYPE, generateValidMonitoringTaskConfig("DEVICE_INFO"));
+                    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)));
+                    .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", dependsOnMethods = "testStartTask")
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testStartTask")
     public void testUpdateTask() {
         try {
             log.debug("Attempting to update task from testStartTask");
-            this.deviceTaskManagerService
-                    .updateTask(TestDataHolder.TEST_DEVICE_TYPE, generateValidMonitoringTaskConfig("DEVICE_LOCATION"));
-            Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
             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) {
@@ -85,12 +88,12 @@ public class DeviceTaskManagerServiceTest {
         }
     }
 
-    @Test(groups = "Device Task Manager", dependsOnMethods = "testUpdateTask")
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateTask")
     public void testStopTask() {
         log.debug("Attempting to stop task from testStopTask");
         try {
-            this.deviceTaskManagerService
+            this.deviceTaskManagerService.stopTask(TestDataHolder.TEST_DEVICE_TYPE,
-                    .stopTask(TestDataHolder.TEST_DEVICE_TYPE, generateValidMonitoringTaskConfig("DEVICE_LOCATION"));
+                    TestDataHolder.generateMonitoringTaskConfig(true, 30000, 1));
             TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
             Assert.assertEquals(taskManager.getAllTasks().size(), 0);
         } catch (DeviceMgtTaskException | TaskException e) {
@@ -98,27 +101,117 @@ public class DeviceTaskManagerServiceTest {
         }
     }
 
+    @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));
+    }
 
-    private OperationMonitoringTaskConfig generateValidMonitoringTaskConfig(String operationConfig) {
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
-        OperationMonitoringTaskConfig validTaskConfig = new OperationMonitoringTaskConfig();
+            expectedExceptions = {DeviceMgtTaskException.class })
-        List<MonitoringOperation> operationList = new ArrayList<>();
+    public void testUpdateTaskWhenFailedToRegisterTask()
-        MonitoringOperation operation = new MonitoringOperation();
+            throws DeviceMgtTaskException, TaskException {
-        operation.setTaskName(operationConfig);
+        TestTaskServiceImpl taskService = new TestTaskServiceImpl();
-        operation.setRecurrentTimes(1);
+        TaskManager taskManager = Mockito.mock(TestTaskManagerImpl.class);
-        operationList.add(operation);
+        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));
+    }
 
-        validTaskConfig.setEnabled(true);
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
-        validTaskConfig.setFrequency(60000);
+            expectedExceptions = {DeviceMgtTaskException.class })
-        validTaskConfig.setMonitoringOperation(operationList);
+    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));
+    }
 
-        return validTaskConfig;
+    @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));
     }
 
-    private Properties getStandardQuartzProps() {
+    @Test(groups = "Device Task Manager Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
-        Properties result = new Properties();
+            expectedExceptions = {DeviceMgtTaskException.class })
-        result.put("org.quartz.scheduler.skipUpdateCheck", "true");
+    public void testStopTaskWhenFailedToDeleteTask()
-        result.put("org.quartz.threadPool.class", QuartzCachedThreadPool.class.getName());
+            throws DeviceMgtTaskException, TaskException {
-        return result;
+        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

@@ -1,3 +1,20 @@
+/*
+ * 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;

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

@@ -46,7 +46,9 @@
             <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>

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.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

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

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

components/device-mgt/org.wso2.carbon.device.mgt.url.printer/pom.xml

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

components/device-mgt/pom.xml

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

components/email-sender/org.wso2.carbon.email.sender.core/pom.xml

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

components/email-sender/pom.xml

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

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

@@ -22,13 +22,13 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>identity-extensions</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.device.mgt.oauth.extensions</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - OAuth Extensions</name>
     <url>http://wso2.org</url>

components/identity-extensions/org.wso2.carbon.identity.authenticator.backend.oauth/pom.xml

@@ -21,7 +21,7 @@
     <parent>
         <artifactId>identity-extensions</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>

components/identity-extensions/org.wso2.carbon.identity.jwt.client.extension/pom.xml

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

components/identity-extensions/pom.xml

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

components/policy-mgt/org.wso2.carbon.complex.policy.decision.point/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>policy-mgt</artifactId>
-        <version>3.0.131-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>org.wso2.carbon.complex.policy.decision.point</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Policy Decision Point</name>
     <description>WSO2 Carbon - Policy Decision Point</description>

components/policy-mgt/org.wso2.carbon.policy.decision.point/pom.xml

@@ -3,14 +3,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>policy-mgt</artifactId>
-        <version>3.0.131-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>org.wso2.carbon.policy.decision.point</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Policy Decision Point</name>
     <description>WSO2 Carbon - Policy Decision Point</description>

components/policy-mgt/org.wso2.carbon.policy.information.point/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>policy-mgt</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -11,7 +11,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.wso2.carbon.devicemgt</groupId>
     <artifactId>org.wso2.carbon.policy.information.point</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Policy Information Point</name>
     <description>WSO2 Carbon - Policy Information Point</description>

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

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>policy-mgt</artifactId>
-        <version>3.0.131-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>org.wso2.carbon.policy.mgt.common</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Policy Management Common</name>
     <description>WSO2 Carbon - Policy Management Common</description>

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

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>policy-mgt</artifactId>
-        <version>3.0.131-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>org.wso2.carbon.policy.mgt.core</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Policy Management Core</name>
     <description>WSO2 Carbon - Policy Management Core</description>
@@ -77,6 +77,7 @@
                             !org.wso2.carbon.policy.mgt.core.internal,
                             org.wso2.carbon.policy.mgt.core.*
                         </Export-Package>
+                        <DynamicImport-Package>*</DynamicImport-Package>
                     </instructions>
                 </configuration>
             </plugin>
@@ -205,6 +206,28 @@
             <scope>test</scope>
         </dependency>
 
+
+        <dependency>
+            <groupId>commons-dbcp.wso2</groupId>
+            <artifactId>commons-dbcp</artifactId>
+            <version>1.4.0.wso2v1</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-pool.wso2</groupId>
+            <artifactId>commons-pool</artifactId>
+            <version>1.5.6.wso2v1</version>
+            <scope>test</scope>
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>2.10.0</version>
+        </dependency>
+
     </dependencies>
 
 </project>

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/main/java/org/wso2/carbon/policy/mgt/core/mgt/impl/PolicyManagerImpl.java

@@ -232,7 +232,7 @@ public class PolicyManagerImpl implements PolicyManager {
                 policyDAO.addDeviceGroupsToPolicy(policy);
             }
 
-            if (policy.getPolicyCriterias() != null) {
+            if (policy.getPolicyCriterias() != null && !policy.getPolicyCriterias().isEmpty()) {
                 List<PolicyCriterion> criteria = policy.getPolicyCriterias();
                 for (PolicyCriterion criterion : criteria) {
                     if (!policyDAO.checkCriterionExists(criterion.getName())) {
@@ -794,7 +794,7 @@ public class PolicyManagerImpl implements PolicyManager {
         List<Device> deviceList = new ArrayList<>();
         List<Integer> deviceIds;
         try {
-            DeviceManagementProviderService service = new DeviceManagementProviderServiceImpl();
+            DeviceManagementProviderService service = PolicyManagementDataHolder.getInstance().getDeviceManagementService();
             List<Device> allDevices = service.getAllDevices();
             PolicyManagementDAOFactory.openConnection();
             deviceIds = policyDAO.getPolicyAppliedDevicesIds(policyId);
@@ -1092,9 +1092,9 @@ public class PolicyManagerImpl implements PolicyManager {
             String type = null;
             if (deviceIdentifiers.size() > 0) {
                 type = deviceIdentifiers.get(0).getType();
+                PolicyManagementDataHolder.getInstance().getDeviceManagementService().addOperation(type,
+                        this.getPolicyRevokeOperation(), deviceIdentifiers);
             }
-            PolicyManagementDataHolder.getInstance().getDeviceManagementService().addOperation(type,
-                    this.getPolicyRevokeOperation(), deviceIdentifiers);
         } catch (InvalidDeviceException e) {
             String msg = "Invalid DeviceIdentifiers found.";
             log.error(msg, e);

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/BasePolicyManagementDAOTest.java

@@ -122,7 +122,7 @@ public abstract class BasePolicyManagementDAOTest {
         }
     }
 
-    private void initSQLScript() throws Exception {
+    protected void initSQLScript() throws Exception {
         Connection conn = null;
         Statement stmt = null;
         try {

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/PolicyManagerServiceImplTest.java

@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2016, 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.policy.mgt.core;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+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.group.mgt.DeviceGroup;
+import org.wso2.carbon.device.mgt.common.group.mgt.GroupAlreadyExistException;
+import org.wso2.carbon.device.mgt.common.group.mgt.GroupManagementException;
+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.policy.mgt.DeviceGroupWrapper;
+import org.wso2.carbon.device.mgt.common.policy.mgt.Policy;
+import org.wso2.carbon.device.mgt.common.policy.mgt.Profile;
+import org.wso2.carbon.device.mgt.common.policy.mgt.ProfileFeature;
+import org.wso2.carbon.device.mgt.common.policy.mgt.monitor.ComplianceFeature;
+import org.wso2.carbon.device.mgt.common.policy.mgt.monitor.PolicyComplianceException;
+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.internal.DeviceManagementDataHolder;
+import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
+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.GroupManagementProviderService;
+import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
+import org.wso2.carbon.policy.mgt.common.PolicyEvaluationPoint;
+import org.wso2.carbon.policy.mgt.common.PolicyManagementException;
+import org.wso2.carbon.policy.mgt.core.enforcement.DelegationTask;
+import org.wso2.carbon.policy.mgt.core.internal.PolicyManagementDataHolder;
+import org.wso2.carbon.policy.mgt.core.mock.TypeADeviceManagementService;
+import org.wso2.carbon.policy.mgt.core.services.SimplePolicyEvaluationTest;
+import org.wso2.carbon.policy.mgt.core.task.MonitoringTask;
+import org.wso2.carbon.policy.mgt.core.util.PolicyManagementConstants;
+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.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PolicyManagerServiceImplTest extends BasePolicyManagementDAOTest {
+
+    private static final Log log = LogFactory.getLog(PolicyManagerServiceImpl.class);
+
+    private static final String DEVICE_TYPE_A = "deviceTypeA";
+    private static final String DEVICE1 = "device1";
+    private static final String GROUP1 = "group1";
+    private static final String POLICY1 = "policy1";
+    private static final String POLICY1_FEATURE1_CODE = "DISALLOW_ADJUST_VOLUME";
+    private static final String ADMIN_USER = "admin";
+
+    private DeviceManagementProviderService deviceMgtService;
+    private GroupManagementProviderService groupMgtService;
+    private OperationManager operationManager;
+    private PolicyManagerService policyManagerService;
+
+    private Policy policy1;
+
+    @BeforeClass
+    public void init() throws Exception {
+        super.initSQLScript();
+
+        DeviceConfigurationManager.getInstance().initConfig();
+        log.info("Initializing policy tests");
+
+        deviceMgtService = new DeviceManagementProviderServiceImpl();
+        groupMgtService = new GroupManagementProviderServiceImpl();
+
+        DeviceManagementServiceComponent.notifyStartupListeners();
+        DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
+        DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
+        DeviceManagementDataHolder.getInstance().setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
+        DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(groupMgtService);
+        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
+
+        PolicyEvaluationPoint policyEvaluationPoint = new SimplePolicyEvaluationTest();
+        PolicyManagementDataHolder.getInstance().setPolicyEvaluationPoint("Simple", policyEvaluationPoint);
+        PolicyManagementDataHolder.getInstance().setDeviceManagementService(deviceMgtService);
+    }
+
+    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 boolean enrollDevice(String deviceName, String deviceType) {
+        boolean success = false;
+        EnrolmentInfo enrolmentInfo = new EnrolmentInfo(
+                ADMIN_USER, EnrolmentInfo.OwnerShip.BYOD, EnrolmentInfo.Status.ACTIVE);
+        Device device1 = new Device(deviceName, deviceType, deviceName, deviceName, enrolmentInfo, null, null);
+        try {
+            success = deviceMgtService.enrollDevice(device1);
+        } catch (DeviceManagementException e) {
+            String msg = "Failed to enroll a device.";
+            log.error(msg, e);
+            Assert.fail();
+        }
+        return success;
+    }
+
+    private void createDeviceGroup(String groupName) {
+        DeviceGroup deviceGroup = new DeviceGroup(groupName);
+        deviceGroup.setDescription(groupName);
+        deviceGroup.setOwner(ADMIN_USER);
+        try {
+            groupMgtService.createGroup(deviceGroup, null, null);
+        } catch (GroupAlreadyExistException | GroupManagementException e) {
+            String msg = "Failed to create group: " + groupName;
+            log.error(msg, e);
+            Assert.fail(msg);
+        }
+    }
+
+    private void addDeviceToGroup(DeviceIdentifier deviceIdentifier, String groupName) {
+        List<DeviceIdentifier> groupDevices = new ArrayList<>();
+        groupDevices.add(deviceIdentifier);
+        try {
+            DeviceGroup group = groupMgtService.getGroup(groupName);
+            groupMgtService.addDevices(group.getGroupId(), groupDevices);
+        } catch (DeviceNotFoundException | GroupManagementException e) {
+            String msg = "Failed to add device " + deviceIdentifier.getId() + " to group " + groupName;
+            log.error(msg, e);
+            Assert.fail(msg);
+        }
+    }
+
+    @Test
+    public void addPolicy() throws DeviceManagementException, GroupManagementException, PolicyManagementException {
+        int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
+        policyManagerService = new PolicyManagerServiceImpl();
+
+        deviceMgtService.registerDeviceType(new TypeADeviceManagementService());
+        operationManager = new OperationManagerImpl(DEVICE_TYPE_A);
+        enrollDevice(DEVICE1, DEVICE_TYPE_A);
+        createDeviceGroup(GROUP1);
+        DeviceGroup group1 = groupMgtService.getGroup(GROUP1);
+        addDeviceToGroup(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A), GROUP1);
+
+        Profile profile = new Profile();
+        profile.setTenantId(tenantId);
+        profile.setCreatedDate(new Timestamp(System.currentTimeMillis()));
+        profile.setDeviceType(DEVICE_TYPE_A);
+
+        List<ProfileFeature> profileFeatures = new ArrayList<ProfileFeature>();
+        ProfileFeature profileFeature = new ProfileFeature();
+        profileFeature.setContent("{'enable':'true'}");
+        profileFeature.setDeviceType(DEVICE_TYPE_A);
+        profileFeature.setFeatureCode(POLICY1_FEATURE1_CODE);
+        profileFeatures.add(profileFeature);
+        profile.setProfileFeaturesList(profileFeatures);
+        profile.setProfileName("tp_profile1");
+        profile.setUpdatedDate(new Timestamp(System.currentTimeMillis()));
+
+        DeviceGroupWrapper deviceGroupWrapper = new DeviceGroupWrapper();
+        deviceGroupWrapper.setId(group1.getGroupId());
+        deviceGroupWrapper.setName(GROUP1);
+        deviceGroupWrapper.setOwner(ADMIN_USER);
+        deviceGroupWrapper.setTenantId(tenantId);
+        List<DeviceGroupWrapper> deviceGroupWrappers = new ArrayList<>();
+        deviceGroupWrappers.add(deviceGroupWrapper);
+
+        policy1 = new Policy();
+        policy1.setPolicyName(POLICY1);
+        policy1.setDescription(POLICY1);
+        policy1.setProfile(profile);
+        policy1.setOwnershipType("BYOD");
+        policy1.setActive(false);
+        policy1.setRoles(new ArrayList<>());
+        policy1.setUsers(new ArrayList<>());
+        policy1.setCompliance(PolicyManagementConstants.ENFORCE);
+        policy1.setDeviceGroups(deviceGroupWrappers);
+        List<Device> devices = new ArrayList<Device>();
+        policy1.setDevices(devices);
+        policy1.setTenantId(PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId());
+        policy1 = policyManagerService.addPolicy(policy1);
+
+        int policyCount = policyManagerService.getPolicyCount();
+        Assert.assertEquals(policyCount, 1, "Policy count should be 1");
+
+        List<Policy> allPolicies = policyManagerService.getPolicies(DEVICE_TYPE_A);
+        boolean policyFound = false;
+        for (Policy policy : allPolicies) {
+            String policyName = policy.getPolicyName();
+            if (POLICY1.equals(policyName)) {
+                policyFound = true;
+                break;
+            }
+        }
+        Assert.assertTrue(policyFound, POLICY1 + " was not added.");
+    }
+
+    @Test(dependsOnMethods = "addPolicy")
+    public void activatePolicy() throws PolicyManagementException {
+        policyManagerService.getPAP().activatePolicy(policy1.getId());
+        Policy effectivePolicy = policyManagerService.getEffectivePolicy(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+        Assert.assertEquals(effectivePolicy.getPolicyName(), POLICY1, POLICY1 + " was not activated for " + DEVICE1);
+    }
+
+    @Test(dependsOnMethods = "activatePolicy")
+    public void applyPolicy() throws PolicyManagementException, OperationManagementException {
+        new DelegationTask().execute();
+        Policy appliedPolicy = policyManagerService.getAppliedPolicyToDevice(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+        Assert.assertEquals(appliedPolicy.getPolicyName(), POLICY1, POLICY1 + " was not applied on " + DEVICE1);
+
+        List<? extends Operation> operations = operationManager.getPendingOperations(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+        boolean policyOperationFound = false;
+        for (Operation operation : operations) {
+            if (policyOperationFound) {
+                break;
+            }
+            if (PolicyOperation.POLICY_OPERATION_CODE.equals(operation.getCode())) {
+                Object o = operation.getPayLoad();
+                if (o instanceof ArrayList) {
+                    ArrayList profileOps = (ArrayList) o;
+                    for (Object op : profileOps) {
+                        if (op instanceof ProfileOperation) {
+                            ProfileOperation profileOperation = (ProfileOperation) op;
+                            if (POLICY1_FEATURE1_CODE.equals(profileOperation.getCode())) {
+                                policyOperationFound = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Assert.assertTrue(policyOperationFound, "Policy operation for " + POLICY1 + " was not added to " + DEVICE1);
+    }
+
+    @Test(dependsOnMethods = "applyPolicy")
+    public void checkCompliance() throws PolicyComplianceException {
+        new MonitoringTask().execute();
+
+        List<ComplianceFeature> complianceFeatures = new ArrayList<>();
+        ComplianceFeature complianceFeature = new ComplianceFeature();
+        ProfileFeature profileFeature = new ProfileFeature();
+        profileFeature.setContent("{'enable':'false'}");
+        profileFeature.setDeviceType(DEVICE_TYPE_A);
+        profileFeature.setFeatureCode(POLICY1_FEATURE1_CODE);
+        complianceFeature.setFeature(profileFeature);
+        complianceFeature.setFeatureCode(profileFeature.getFeatureCode());
+        complianceFeature.setMessage("Test message");
+        complianceFeature.setCompliance(true);
+        complianceFeatures.add(complianceFeature);
+        policyManagerService.checkCompliance(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A), complianceFeatures);
+        boolean deviceCompliance = policyManagerService.isCompliant(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+
+        Assert.assertTrue(deviceCompliance, "Policy was not compliant");
+    }
+
+    @Test(dependsOnMethods = "checkCompliance")
+    public void checkNonCompliance() throws PolicyComplianceException {
+        new MonitoringTask().execute();
+
+        List<ComplianceFeature> complianceFeatures = new ArrayList<>();
+        ComplianceFeature complianceFeature = new ComplianceFeature();
+        ProfileFeature profileFeature = new ProfileFeature();
+        profileFeature.setContent("{'enable':'false'}");
+        profileFeature.setDeviceType(DEVICE_TYPE_A);
+        profileFeature.setFeatureCode(POLICY1_FEATURE1_CODE);
+        complianceFeature.setFeature(profileFeature);
+        complianceFeature.setFeatureCode(profileFeature.getFeatureCode());
+        complianceFeature.setMessage("Test message");
+        complianceFeature.setCompliance(false);
+        complianceFeatures.add(complianceFeature);
+        policyManagerService.checkCompliance(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A), complianceFeatures);
+        boolean deviceCompliance = policyManagerService.isCompliant(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+
+        Assert.assertFalse(deviceCompliance, "Policy was compliant even though the response was not compliant");
+    }
+
+    @Test(dependsOnMethods = "inactivatePolicy")
+    public void updatePolicy() throws PolicyManagementException {
+        Policy policy1Temp = policyManagerService.getPAP().getPolicy(policy1.getId());
+        policy1Temp.setDescription("Updated policy1");
+        policy1Temp = policyManagerService.updatePolicy(policy1Temp);
+
+        Policy policy1Updated = policyManagerService.getPAP().getPolicy(policy1.getId());
+        Assert.assertEquals(policy1Updated.getDescription(), policy1Temp.getDescription(), "Policy was not updated successfully.");
+    }
+
+    @Test(dependsOnMethods = "checkNonCompliance")
+    public void inactivatePolicy() throws PolicyManagementException {
+        policyManagerService.getPAP().inactivatePolicy(policy1.getId());
+        new DelegationTask().execute();
+        Policy effectivePolicy = policyManagerService.getEffectivePolicy(new DeviceIdentifier(DEVICE1, DEVICE_TYPE_A));
+        Assert.assertNull(effectivePolicy, POLICY1 + " (after inactivation) is still applied for " + DEVICE1);
+    }
+
+    @Test(dependsOnMethods = "updatePolicy")
+    public void deletePolicy() throws PolicyManagementException {
+        policyManagerService.deletePolicy(policy1.getId());
+        Policy tempPolicy = policyManagerService.getPAP().getPolicy(policy1.getId());
+        Assert.assertNull(tempPolicy, "Policy was not deleted successfully");
+    }
+}

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/mock/TestPolicyMonitoringManager.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2016, 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.policy.mgt.core.mock;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
+import org.wso2.carbon.device.mgt.common.policy.mgt.Policy;
+import org.wso2.carbon.device.mgt.common.policy.mgt.PolicyMonitoringManager;
+import org.wso2.carbon.device.mgt.common.policy.mgt.monitor.ComplianceFeature;
+import org.wso2.carbon.device.mgt.common.policy.mgt.monitor.NonComplianceData;
+import org.wso2.carbon.device.mgt.common.policy.mgt.monitor.PolicyComplianceException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestPolicyMonitoringManager implements PolicyMonitoringManager {
+
+    private static Log log = LogFactory.getLog(TestPolicyMonitoringManager.class);
+    @Override
+    public NonComplianceData checkPolicyCompliance(DeviceIdentifier deviceIdentifier, Policy policy, Object response)
+            throws PolicyComplianceException {
+        if (log.isDebugEnabled()) {
+            log.debug("Checking policy compliance status of device '" + deviceIdentifier.getId() + "'");
+        }
+        NonComplianceData nonComplianceData = new NonComplianceData();
+        if (response == null || policy == null) {
+            return nonComplianceData;
+        }
+
+        List<ComplianceFeature> complianceFeatures = (List<ComplianceFeature>) response;
+        List<ComplianceFeature> nonComplianceFeatures = new ArrayList<>();
+
+        for (ComplianceFeature complianceFeature : complianceFeatures) {
+            if (!complianceFeature.isCompliant()) {
+                nonComplianceFeatures.add(complianceFeature);
+                nonComplianceData.setStatus(false);
+                break;
+            }
+        }
+        nonComplianceData.setComplianceFeatures(nonComplianceFeatures);
+
+        return nonComplianceData;
+    }
+}

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/mock/TypeADeviceManagementService.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2016, 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.policy.mgt.core.mock;
+
+import org.wso2.carbon.device.mgt.common.DeviceManagementException;
+import org.wso2.carbon.device.mgt.common.DeviceManager;
+import org.wso2.carbon.device.mgt.common.DeviceStatusTaskPluginConfig;
+import org.wso2.carbon.device.mgt.common.InitialOperationConfig;
+import org.wso2.carbon.device.mgt.common.MonitoringOperation;
+import org.wso2.carbon.device.mgt.common.OperationMonitoringTaskConfig;
+import org.wso2.carbon.device.mgt.common.ProvisioningConfig;
+import org.wso2.carbon.device.mgt.common.app.mgt.ApplicationManager;
+import org.wso2.carbon.device.mgt.common.policy.mgt.PolicyMonitoringManager;
+import org.wso2.carbon.device.mgt.common.pull.notification.PullNotificationSubscriber;
+import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
+import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
+
+import java.util.ArrayList;
+
+public class TypeADeviceManagementService implements DeviceManagementService {
+
+    public static String DEVICE_TYPE = "deviceTypeA";
+
+    public TypeADeviceManagementService() {
+        super();
+    }
+
+    @Override
+    public void init() throws DeviceManagementException {
+
+    }
+
+    @Override
+    public String getType() {
+        return DEVICE_TYPE;
+    }
+
+    @Override
+    public OperationMonitoringTaskConfig getOperationMonitoringConfig() {
+        OperationMonitoringTaskConfig operationMonitoringTaskConfig = new OperationMonitoringTaskConfig();
+        operationMonitoringTaskConfig.setMonitoringOperation(new ArrayList<MonitoringOperation>());
+        return operationMonitoringTaskConfig;
+    }
+
+    @Override
+    public DeviceManager getDeviceManager() {
+        return new TypeADeviceManager();
+    }
+
+    @Override
+    public ApplicationManager getApplicationManager() {
+        return null;
+    }
+
+    @Override
+    public ProvisioningConfig getProvisioningConfig() {
+        return new ProvisioningConfig("carbon.super", true);
+    }
+
+    @Override
+    public PushNotificationConfig getPushNotificationConfig() {
+        return null;
+    }
+
+    @Override
+    public PolicyMonitoringManager getPolicyMonitoringManager() {
+        return new TestPolicyMonitoringManager();
+    }
+
+    @Override
+    public InitialOperationConfig getInitialOperationConfig() {
+        return null;
+    }
+
+    @Override
+    public PullNotificationSubscriber getPullNotificationSubscriber() {
+        return null;
+    }
+
+    @Override
+    public DeviceStatusTaskPluginConfig getDeviceStatusTaskPluginConfig() {
+        return null;
+    }
+}

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/mock/TypeADeviceManager.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2016, 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.policy.mgt.core.mock;
+
+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.DeviceManager;
+import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
+import org.wso2.carbon.device.mgt.common.FeatureManager;
+import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
+import org.wso2.carbon.device.mgt.common.license.mgt.License;
+import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException;
+
+import java.util.List;
+
+public class TypeADeviceManager implements DeviceManager {
+
+    @Override
+    public FeatureManager getFeatureManager() {
+        return null;
+    }
+
+    @Override
+    public boolean saveConfiguration(PlatformConfiguration configuration)
+            throws DeviceManagementException {
+        return false;
+    }
+
+    @Override public PlatformConfiguration getConfiguration() throws DeviceManagementException {
+        return null;
+    }
+
+    @Override
+    public boolean enrollDevice(Device device) throws DeviceManagementException {
+        return true;
+    }
+
+    @Override
+    public boolean modifyEnrollment(Device device) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean isActive(DeviceIdentifier deviceId) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean setActive(DeviceIdentifier deviceId, boolean status) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public List<Device> getAllDevices() throws DeviceManagementException {
+        return null;
+    }
+
+    @Override
+    public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
+        return null;
+    }
+
+    @Override
+    public boolean updateDeviceInfo(DeviceIdentifier deviceIdentifier, Device device)
+            throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean setOwnership(DeviceIdentifier deviceId, String ownershipType)
+            throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean isClaimable(DeviceIdentifier deviceId) throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public boolean setStatus(DeviceIdentifier deviceId, String currentOwner, EnrolmentInfo.Status status)
+            throws DeviceManagementException {
+        return false;
+    }
+
+    @Override
+    public License getLicense(String languageCode) throws LicenseManagementException {
+        return null;
+    }
+
+    @Override
+    public void addLicense(License license) throws LicenseManagementException {
+
+    }
+
+    @Override
+    public boolean requireDeviceAuthorization() {
+        return false;
+    }
+}

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/task/TaskSchedulerServiceImplTest.java

@@ -0,0 +1,210 @@
+/*
+ * 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.policy.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.config.DeviceConfigurationManager;
+import org.wso2.carbon.device.mgt.core.config.policy.PolicyConfiguration;
+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 org.wso2.carbon.policy.mgt.common.PolicyMonitoringTaskException;
+import org.wso2.carbon.policy.mgt.core.internal.PolicyManagementDataHolder;
+import org.wso2.carbon.policy.mgt.core.util.PolicyManagementConstants;
+import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
+
+import java.lang.reflect.Field;
+
+public class TaskSchedulerServiceImplTest {
+    private static final Log log = LogFactory.getLog(TaskSchedulerServiceImplTest.class);
+    private static final String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
+    private TaskScheduleService policyTaskSchedulerService;
+    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();
+        PolicyManagementDataHolder.getInstance().setTaskService(this.taskService);
+        Field taskServiceField = TasksDSComponent.class.getDeclaredField("taskService");
+        taskServiceField.setAccessible(true);
+        taskServiceField.set(null, Mockito.mock(TaskServiceImpl.class, Mockito.RETURNS_MOCKS));
+        PolicyConfiguration policyConfiguration = new PolicyConfiguration();
+        policyConfiguration.setMonitoringEnable(true);
+        DeviceConfigurationManager.getInstance().getDeviceManagementConfig()
+                .setPolicyConfiguration(policyConfiguration);
+        this.policyTaskSchedulerService = new TaskScheduleServiceImpl();
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group")
+    public void testStartTask() {
+        try {
+            log.debug("Attempting to start task from testStartTask");
+            this.policyTaskSchedulerService.startTask(60000);
+            TaskManager taskManager = this.taskService.getTaskManager(PolicyManagementConstants.MONITORING_TASK_TYPE);
+            Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
+            Assert.assertNotNull(taskManager.getTask(PolicyManagementConstants.MONITORING_TASK_NAME + "_" + String
+                    .valueOf(MultitenantConstants.SUPER_TENANT_ID)));
+            log.debug("Task Successfully started");
+        } catch (PolicyMonitoringTaskException | TaskException e) {
+            Assert.fail("Exception occurred when starting the task", e);
+        }
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testStartTask")
+    public void testIsTaskScheduled() {
+        try {
+            Assert.assertTrue(this.policyTaskSchedulerService.isTaskScheduled());
+        } catch (PolicyMonitoringTaskException e) {
+            Assert.fail("Exception occurred when trying to check if task is scheduled.");
+        }
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testStartTask")
+    public void testUpdateTask() {
+        try {
+            log.debug("Attempting to update task from testStartTask");
+            TaskManager taskManager = this.taskService.getTaskManager(PolicyManagementConstants.MONITORING_TASK_TYPE);
+            this.policyTaskSchedulerService.updateTask(30000);
+            Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
+            Assert.assertEquals(taskManager.getAllTasks().size(), 1);
+            log.debug("Task Successfully updated");
+        } catch (PolicyMonitoringTaskException | TaskException e) {
+            Assert.fail("Exception occurred when updating the task", e);
+        }
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateTask")
+    public void testStopTask() {
+        log.debug("Attempting to stop task from testStopTask");
+        try {
+            this.policyTaskSchedulerService.stopTask();
+            TaskManager taskManager = this.taskService.getTaskManager(PolicyManagementConstants.MONITORING_TASK_TYPE);
+            Assert.assertEquals(taskManager.getAllTasks().size(), 0);
+        } catch (PolicyMonitoringTaskException | TaskException e) {
+            Assert.fail("Exception occurred when stopping the task", e);
+        }
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testStopTask", expectedExceptions = {
+            PolicyMonitoringTaskException.class })
+    public void testUpdateUnscheduledTask() throws PolicyMonitoringTaskException {
+        log.debug("Attempting to update unscheduled task");
+        this.policyTaskSchedulerService.updateTask(50000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testStartTaskWhenUnableToRetrieveTaskManager() throws PolicyMonitoringTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to get TaskManager", TaskException.Code.UNKNOWN)).when(taskService)
+                .getTaskManager(PolicyManagementConstants.MONITORING_TASK_TYPE);
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.startTask(10000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testUpdateTaskWhenUnableToRetrieveTaskManager() throws PolicyMonitoringTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to get TaskManager", TaskException.Code.UNKNOWN)).when(taskService)
+                .getTaskManager(PolicyManagementConstants.MONITORING_TASK_TYPE);
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.updateTask(20000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testStartTaskWhenFailedToRegisterTaskType() throws PolicyMonitoringTaskException, TaskException {
+        TaskService taskService = Mockito.mock(TestTaskServiceImpl.class);
+        Mockito.doThrow(new TaskException("Unable to register task type", TaskException.Code.UNKNOWN)).when(taskService)
+                .registerTaskType(PolicyManagementConstants.MONITORING_TASK_TYPE);
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.startTask(20000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testStartTaskWhenFailedToRegisterTask() throws PolicyMonitoringTaskException, 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));
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.startTask(30000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testUpdateTaskWhenFailedToRegisterTask() throws PolicyMonitoringTaskException, 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));
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.updateTask(18000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testUpdateTaskWhenFailedToRescheduleTask() throws PolicyMonitoringTaskException, 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));
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.updateTask(40000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testUpdateTaskWhenFailedToDeleteTask() throws PolicyMonitoringTaskException, 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));
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.updateTask(12000);
+    }
+
+    @Test(groups = "Policy Task Schedule Service Test Group", dependsOnMethods = "testUpdateUnscheduledTask",
+            expectedExceptions = {PolicyMonitoringTaskException.class })
+    public void testStopTaskWhenFailedToDeleteTask() throws PolicyMonitoringTaskException, 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));
+        PolicyManagementDataHolder.getInstance().setTaskService(taskService);
+        this.policyTaskSchedulerService.stopTask();
+    }
+}

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

@@ -0,0 +1,100 @@
+/*
+ * 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.policy.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 (taskName.equals(task.getName())) {
+                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 (taskName.contains(task.getName())) {
+                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/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/java/org/wso2/carbon/policy/mgt/core/task/TestTaskServiceImpl.java

@@ -0,0 +1,81 @@
+/*
+ * 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.policy.mgt.core.task;
+
+import org.wso2.carbon.ntask.common.TaskException;
+import org.wso2.carbon.ntask.core.TaskManager;
+import org.wso2.carbon.ntask.core.service.TaskService;
+
+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();
+    }
+
+    @Override
+    public TaskManager getTaskManager(String s) throws TaskException {
+        return this.taskManager;
+    }
+
+    @Override
+    public List<TaskManager> getAllTenantTaskManagersForType(String s) throws TaskException {
+        return null;
+    }
+
+    @Override
+    public void registerTaskType(String s) throws TaskException {
+        this.registeredTaskTypes.add(s);
+    }
+
+    @Override
+    public Set<String> getRegisteredTaskTypes() {
+        return this.registeredTaskTypes;
+    }
+
+    @Override
+    public void serverInitialized() {
+
+    }
+
+    @Override
+    public boolean isServerInit() {
+        return true;
+    }
+
+    @Override
+    public TaskServiceConfiguration getServerConfiguration() {
+        return null;
+    }
+
+    @Override
+    public void runAfterRegistrationActions() throws TaskException {
+
+    }
+
+    public void setTaskManager(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+}

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/resources/carbon-home/dbscripts/h2.sql

@@ -0,0 +1,429 @@
+CREATE TABLE IF NOT EXISTS REG_CLUSTER_LOCK (
+             REG_LOCK_NAME VARCHAR (20),
+             REG_LOCK_STATUS VARCHAR (20),
+             REG_LOCKED_TIME TIMESTAMP,
+             REG_TENANT_ID INTEGER DEFAULT 0,
+             PRIMARY KEY (REG_LOCK_NAME)
+);
+
+CREATE TABLE IF NOT EXISTS REG_LOG (
+             REG_LOG_ID INTEGER AUTO_INCREMENT,
+             REG_PATH VARCHAR (2000),
+             REG_USER_ID VARCHAR (31) NOT NULL,
+             REG_LOGGED_TIME TIMESTAMP NOT NULL,
+             REG_ACTION INTEGER NOT NULL,
+             REG_ACTION_DATA VARCHAR (500),
+             REG_TENANT_ID INTEGER DEFAULT 0,
+             PRIMARY KEY (REG_LOG_ID, REG_TENANT_ID)
+);
+
+CREATE INDEX IF NOT EXISTS REG_LOG_IND_BY_REG_LOGTIME ON REG_LOG(REG_LOGGED_TIME, REG_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS REG_PATH(
+             REG_PATH_ID INTEGER NOT NULL AUTO_INCREMENT,
+             REG_PATH_VALUE VARCHAR(2000) NOT NULL,
+             REG_PATH_PARENT_ID INT,
+             REG_TENANT_ID INTEGER DEFAULT 0,
+             CONSTRAINT PK_REG_PATH PRIMARY KEY(REG_PATH_ID, REG_TENANT_ID)
+);
+CREATE INDEX IF NOT EXISTS REG_PATH_IND_BY_NAME ON REG_PATH(REG_PATH_VALUE, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_PATH_IND_BY_PARENT_ID ON REG_PATH(REG_PATH_PARENT_ID, REG_TENANT_ID);
+
+
+CREATE TABLE IF NOT EXISTS REG_CONTENT (
+             REG_CONTENT_ID INTEGER NOT NULL AUTO_INCREMENT,
+             REG_CONTENT_DATA LONGBLOB,
+             REG_TENANT_ID INTEGER DEFAULT 0,
+             CONSTRAINT PK_REG_CONTENT PRIMARY KEY(REG_CONTENT_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_CONTENT_HISTORY (
+             REG_CONTENT_ID INTEGER NOT NULL,
+             REG_CONTENT_DATA LONGBLOB,
+             REG_DELETED   SMALLINT,
+             REG_TENANT_ID INTEGER DEFAULT 0,
+             CONSTRAINT PK_REG_CONTENT_HISTORY PRIMARY KEY(REG_CONTENT_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE (
+            REG_PATH_ID         INTEGER NOT NULL,
+            REG_NAME            VARCHAR(256),
+            REG_VERSION         INTEGER NOT NULL AUTO_INCREMENT,
+            REG_MEDIA_TYPE      VARCHAR(500),
+            REG_CREATOR         VARCHAR(31) NOT NULL,
+            REG_CREATED_TIME    TIMESTAMP NOT NULL,
+            REG_LAST_UPDATOR    VARCHAR(31),
+            REG_LAST_UPDATED_TIME    TIMESTAMP NOT NULL,
+            REG_DESCRIPTION     VARCHAR(1000),
+            REG_CONTENT_ID      INTEGER,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            REG_UUID VARCHAR(100) NOT NULL,
+            CONSTRAINT PK_REG_RESOURCE PRIMARY KEY(REG_VERSION, REG_TENANT_ID)
+);
+
+ALTER TABLE REG_RESOURCE ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_FK_BY_CONTENT_ID FOREIGN KEY (REG_CONTENT_ID, REG_TENANT_ID) REFERENCES REG_CONTENT (REG_CONTENT_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_IND_BY_NAME ON REG_RESOURCE(REG_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_IND_BY_PATH_ID_NAME ON REG_RESOURCE(REG_PATH_ID, REG_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_IND_BY_UUID ON REG_RESOURCE(REG_UUID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_IND_BY_TENANT ON REG_RESOURCE(REG_TENANT_ID, REG_UUID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_IND_BY_TYPE ON REG_RESOURCE(REG_TENANT_ID, REG_MEDIA_TYPE);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE_HISTORY (
+            REG_PATH_ID         INTEGER NOT NULL,
+            REG_NAME            VARCHAR(256),
+            REG_VERSION         INTEGER NOT NULL,
+            REG_MEDIA_TYPE      VARCHAR(500),
+            REG_CREATOR         VARCHAR(31) NOT NULL,
+            REG_CREATED_TIME    TIMESTAMP NOT NULL,
+            REG_LAST_UPDATOR    VARCHAR(31),
+            REG_LAST_UPDATED_TIME    TIMESTAMP NOT NULL,
+            REG_DESCRIPTION     VARCHAR(1000),
+            REG_CONTENT_ID      INTEGER,
+            REG_DELETED         SMALLINT,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            REG_UUID VARCHAR(100) NOT NULL,
+            CONSTRAINT PK_REG_RESOURCE_HISTORY PRIMARY KEY(REG_VERSION, REG_TENANT_ID)
+);
+
+ALTER TABLE REG_RESOURCE_HISTORY ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_HIST_FK_BY_PATHID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE_HISTORY ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_HIST_FK_BY_CONTENT_ID FOREIGN KEY (REG_CONTENT_ID, REG_TENANT_ID) REFERENCES REG_CONTENT_HISTORY (REG_CONTENT_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_HISTORY_IND_BY_NAME ON REG_RESOURCE_HISTORY(REG_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_HISTORY_IND_BY_PATH_ID_NAME ON REG_RESOURCE(REG_PATH_ID, REG_NAME, REG_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS REG_COMMENT (
+            REG_ID        INTEGER NOT NULL AUTO_INCREMENT,
+            REG_COMMENT_TEXT      VARCHAR(500) NOT NULL,
+            REG_USER_ID           VARCHAR(31) NOT NULL,
+            REG_COMMENTED_TIME    TIMESTAMP NOT NULL,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            CONSTRAINT PK_REG_COMMENT PRIMARY KEY(REG_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE_COMMENT (
+            REG_COMMENT_ID          INTEGER NOT NULL,
+            REG_VERSION             INTEGER,
+            REG_PATH_ID             INTEGER,
+            REG_RESOURCE_NAME       VARCHAR(256),
+            REG_TENANT_ID INTEGER DEFAULT 0
+);
+
+ALTER TABLE REG_RESOURCE_COMMENT ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_COMMENT_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE_COMMENT ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_COMMENT_FK_BY_COMMENT_ID FOREIGN KEY (REG_COMMENT_ID, REG_TENANT_ID) REFERENCES REG_COMMENT (REG_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_COMMENT_IND_BY_PATH_ID_AND_RESOURCE_NAME ON REG_RESOURCE_COMMENT(REG_PATH_ID, REG_RESOURCE_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_COMMENT_IND_BY_VERSION ON REG_RESOURCE_COMMENT(REG_VERSION, REG_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS REG_RATING (
+            REG_ID     INTEGER NOT NULL AUTO_INCREMENT,
+            REG_RATING        INTEGER NOT NULL,
+            REG_USER_ID       VARCHAR(31) NOT NULL,
+            REG_RATED_TIME    TIMESTAMP NOT NULL,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            CONSTRAINT PK_REG_RATING PRIMARY KEY(REG_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE_RATING (
+            REG_RATING_ID           INTEGER NOT NULL,
+            REG_VERSION             INTEGER,
+            REG_PATH_ID             INTEGER,
+            REG_RESOURCE_NAME       VARCHAR(256),
+            REG_TENANT_ID INTEGER DEFAULT 0
+);
+
+ALTER TABLE REG_RESOURCE_RATING ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_RATING_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE_RATING ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_RATING_FK_BY_RATING_ID FOREIGN KEY (REG_RATING_ID, REG_TENANT_ID) REFERENCES REG_RATING (REG_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_RATING_IND_BY_PATH_ID_AND_RESOURCE_NAME ON REG_RESOURCE_RATING(REG_PATH_ID, REG_RESOURCE_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_RATING_IND_BY_VERSION ON REG_RESOURCE_RATING(REG_VERSION, REG_TENANT_ID);
+
+
+CREATE TABLE IF NOT EXISTS REG_TAG (
+            REG_ID         INTEGER NOT NULL AUTO_INCREMENT,
+            REG_TAG_NAME       VARCHAR(500) NOT NULL,
+            REG_USER_ID        VARCHAR(31) NOT NULL,
+            REG_TAGGED_TIME    TIMESTAMP NOT NULL,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            CONSTRAINT PK_REG_TAG PRIMARY KEY(REG_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE_TAG (
+            REG_TAG_ID              INTEGER NOT NULL,
+            REG_VERSION             INTEGER,
+            REG_PATH_ID             INTEGER,
+            REG_RESOURCE_NAME       VARCHAR(256),
+            REG_TENANT_ID INTEGER DEFAULT 0
+);
+
+ALTER TABLE REG_RESOURCE_TAG ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_TAG_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE_TAG ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_TAG_FK_BY_TAG_ID FOREIGN KEY (REG_TAG_ID, REG_TENANT_ID) REFERENCES REG_TAG (REG_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_TAG_IND_BY_PATH_ID_AND_RESOURCE_NAME ON REG_RESOURCE_TAG(REG_PATH_ID, REG_RESOURCE_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_TAG_IND_BY_VERSION ON REG_RESOURCE_TAG(REG_VERSION, REG_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS REG_PROPERTY (
+            REG_ID         INTEGER NOT NULL AUTO_INCREMENT,
+            REG_NAME       VARCHAR(100) NOT NULL,
+            REG_VALUE        VARCHAR(1000),
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            CONSTRAINT PK_REG_PROPERTY PRIMARY KEY(REG_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_RESOURCE_PROPERTY (
+            REG_PROPERTY_ID         INTEGER NOT NULL,
+            REG_VERSION             INTEGER,
+            REG_PATH_ID             INTEGER,
+            REG_RESOURCE_NAME       VARCHAR(256),
+            REG_TENANT_ID INTEGER DEFAULT 0
+);
+
+ALTER TABLE REG_RESOURCE_PROPERTY ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_PROPERTY_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+ALTER TABLE REG_RESOURCE_PROPERTY ADD CONSTRAINT IF NOT EXISTS REG_RESOURCE_PROPERTY_FK_BY_TAG_ID FOREIGN KEY (REG_PROPERTY_ID, REG_TENANT_ID) REFERENCES REG_PROPERTY (REG_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_PROPERTY_IND_BY_PATH_ID_AND_RESOURCE_NAME ON REG_RESOURCE_PROPERTY(REG_PATH_ID, REG_RESOURCE_NAME, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_RESOURCE_PROPERTY_IND_BY_VERSION ON REG_RESOURCE_PROPERTY(REG_VERSION, REG_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS REG_ASSOCIATION (
+            REG_ASSOCIATION_ID INTEGER AUTO_INCREMENT,
+            REG_SOURCEPATH VARCHAR (2000) NOT NULL,
+            REG_TARGETPATH VARCHAR (2000) NOT NULL,
+            REG_ASSOCIATION_TYPE VARCHAR (2000) NOT NULL,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            PRIMARY KEY (REG_ASSOCIATION_ID, REG_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS REG_SNAPSHOT (
+            REG_SNAPSHOT_ID     INTEGER NOT NULL AUTO_INCREMENT,
+            REG_PATH_ID            INTEGER NOT NULL,
+            REG_RESOURCE_NAME VARCHAR (256),
+            REG_RESOURCE_VIDS     LONGBLOB NOT NULL,
+            REG_TENANT_ID INTEGER DEFAULT 0,
+            CONSTRAINT PK_REG_SNAPSHOT PRIMARY KEY(REG_SNAPSHOT_ID, REG_TENANT_ID)
+);
+
+ALTER TABLE REG_SNAPSHOT ADD CONSTRAINT IF NOT EXISTS REG_SNAPSHOT_FK_BY_PATH_ID FOREIGN KEY (REG_PATH_ID, REG_TENANT_ID) REFERENCES REG_PATH (REG_PATH_ID, REG_TENANT_ID);
+CREATE INDEX IF NOT EXISTS REG_SNAPSHOT_IND_BY_PATH_ID_AND_RESOURCE_NAME ON REG_SNAPSHOT(REG_PATH_ID, REG_RESOURCE_NAME, REG_TENANT_ID);
+
+-- ################################
+-- USER MANAGER TABLES
+-- ################################
+
+CREATE TABLE IF NOT EXISTS UM_TENANT (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_DOMAIN_NAME VARCHAR(255) NOT NULL,
+	        UM_EMAIL VARCHAR(255),
+	        UM_ACTIVE BOOLEAN DEFAULT FALSE,
+	        UM_CREATED_DATE TIMESTAMP NOT NULL,
+	        UM_USER_CONFIG LONGBLOB NOT NULL,
+			PRIMARY KEY (UM_ID),
+			UNIQUE(UM_DOMAIN_NAME));
+
+CREATE TABLE IF NOT EXISTS UM_DOMAIN(
+            UM_DOMAIN_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_DOMAIN_NAME VARCHAR(255),
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            PRIMARY KEY (UM_DOMAIN_ID, UM_TENANT_ID)
+);
+
+CREATE INDEX IF NOT EXISTS INDEX_UM_TENANT_UM_DOMAIN_NAME ON UM_TENANT (UM_DOMAIN_NAME); 
+
+CREATE TABLE IF NOT EXISTS UM_USER (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_USER_NAME VARCHAR(255) NOT NULL,
+			UM_USER_PASSWORD VARCHAR(255) NOT NULL,
+			UM_SALT_VALUE VARCHAR(31),
+			UM_REQUIRE_CHANGE BOOLEAN DEFAULT FALSE,
+            UM_CHANGED_TIME TIMESTAMP NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID),
+			UNIQUE(UM_USER_NAME, UM_TENANT_ID));
+
+CREATE TABLE IF NOT EXISTS UM_SYSTEM_USER (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_USER_NAME VARCHAR(255) NOT NULL,
+			UM_USER_PASSWORD VARCHAR(255) NOT NULL,
+			UM_SALT_VALUE VARCHAR(31),
+			UM_REQUIRE_CHANGE BOOLEAN DEFAULT FALSE,
+            UM_CHANGED_TIME TIMESTAMP NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID),
+			UNIQUE(UM_USER_NAME, UM_TENANT_ID));
+
+CREATE TABLE IF NOT EXISTS UM_USER_ATTRIBUTE (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_ATTR_NAME VARCHAR(255) NOT NULL,
+			UM_ATTR_VALUE VARCHAR(1024),
+            UM_PROFILE_ID VARCHAR(255),
+            UM_USER_ID INTEGER,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID),
+			FOREIGN KEY (UM_USER_ID, UM_TENANT_ID) REFERENCES UM_USER(UM_ID, UM_TENANT_ID));
+
+CREATE INDEX IF NOT EXISTS UM_USER_ID_INDEX ON UM_USER_ATTRIBUTE(UM_USER_ID);
+
+CREATE TABLE IF NOT EXISTS UM_ROLE (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_ROLE_NAME VARCHAR(255) NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			UM_SHARED_ROLE BOOLEAN DEFAULT FALSE,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID),
+			UNIQUE(UM_ROLE_NAME, UM_TENANT_ID));
+
+CREATE TABLE IF NOT EXISTS UM_MODULE(
+	UM_ID INTEGER  NOT NULL AUTO_INCREMENT,
+	UM_MODULE_NAME VARCHAR(100),
+	UNIQUE(UM_MODULE_NAME),
+	PRIMARY KEY(UM_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_MODULE_ACTIONS(
+	UM_ACTION VARCHAR(255) NOT NULL,
+	UM_MODULE_ID INTEGER NOT NULL,
+	PRIMARY KEY(UM_ACTION, UM_MODULE_ID),
+	FOREIGN KEY (UM_MODULE_ID) REFERENCES UM_MODULE(UM_ID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS UM_PERMISSION (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_RESOURCE_ID VARCHAR(255) NOT NULL,
+			UM_ACTION VARCHAR(255) NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			UM_MODULE_ID INTEGER DEFAULT 0,
+			UNIQUE(UM_RESOURCE_ID,UM_ACTION, UM_TENANT_ID),
+			PRIMARY KEY (UM_ID, UM_TENANT_ID));
+
+CREATE INDEX IF NOT EXISTS INDEX_UM_PERMISSION_UM_RESOURCE_ID_UM_ACTION ON UM_PERMISSION (UM_RESOURCE_ID, UM_ACTION, UM_TENANT_ID);
+
+CREATE TABLE IF NOT EXISTS UM_ROLE_PERMISSION (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_PERMISSION_ID INTEGER NOT NULL,
+			UM_ROLE_NAME VARCHAR(255) NOT NULL,
+            		UM_IS_ALLOWED SMALLINT NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			UM_DOMAIN_ID INTEGER,
+			FOREIGN KEY (UM_PERMISSION_ID, UM_TENANT_ID) REFERENCES UM_PERMISSION(UM_ID, UM_TENANT_ID) ON DELETE CASCADE,
+			FOREIGN KEY (UM_DOMAIN_ID, UM_TENANT_ID) REFERENCES UM_DOMAIN(UM_DOMAIN_ID, UM_TENANT_ID) ON DELETE CASCADE,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID));
+
+CREATE TABLE IF NOT EXISTS UM_USER_PERMISSION (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_PERMISSION_ID INTEGER NOT NULL,
+			UM_USER_NAME VARCHAR(255) NOT NULL,
+            UM_IS_ALLOWED SMALLINT NOT NULL,
+			UNIQUE (UM_PERMISSION_ID, UM_USER_NAME, UM_TENANT_ID),
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			FOREIGN KEY (UM_PERMISSION_ID, UM_TENANT_ID) REFERENCES UM_PERMISSION(UM_ID, UM_TENANT_ID) ON DELETE CASCADE,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID));
+
+CREATE TABLE IF NOT EXISTS UM_USER_ROLE (
+			UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_ROLE_ID INTEGER NOT NULL,
+			UM_USER_ID INTEGER NOT NULL,
+			UM_TENANT_ID INTEGER DEFAULT 0,
+			UNIQUE (UM_USER_ID, UM_ROLE_ID, UM_TENANT_ID),
+			FOREIGN KEY (UM_ROLE_ID, UM_TENANT_ID) REFERENCES UM_ROLE(UM_ID, UM_TENANT_ID),
+			FOREIGN KEY (UM_USER_ID, UM_TENANT_ID) REFERENCES UM_USER(UM_ID, UM_TENANT_ID),
+			PRIMARY KEY (UM_ID, UM_TENANT_ID));
+
+
+CREATE TABLE IF NOT EXISTS UM_SHARED_USER_ROLE(
+    UM_ROLE_ID INTEGER NOT NULL,
+    UM_USER_ID INTEGER NOT NULL,
+    UM_USER_TENANT_ID INTEGER NOT NULL,
+    UM_ROLE_TENANT_ID INTEGER NOT NULL,
+    UNIQUE(UM_USER_ID,UM_ROLE_ID,UM_USER_TENANT_ID, UM_ROLE_TENANT_ID),
+    FOREIGN KEY(UM_ROLE_ID,UM_ROLE_TENANT_ID) REFERENCES UM_ROLE(UM_ID,UM_TENANT_ID) ON DELETE CASCADE ,
+    FOREIGN KEY(UM_USER_ID,UM_USER_TENANT_ID) REFERENCES UM_USER(UM_ID,UM_TENANT_ID) ON DELETE CASCADE 
+);
+
+CREATE TABLE IF NOT EXISTS UM_ACCOUNT_MAPPING(
+	UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+	UM_USER_NAME VARCHAR(255) NOT NULL,
+	UM_TENANT_ID INTEGER NOT NULL,
+	UM_USER_STORE_DOMAIN VARCHAR(100),
+	UM_ACC_LINK_ID INTEGER NOT NULL,
+	UNIQUE(UM_USER_NAME, UM_TENANT_ID, UM_USER_STORE_DOMAIN, UM_ACC_LINK_ID),
+	FOREIGN KEY (UM_TENANT_ID) REFERENCES UM_TENANT(UM_ID) ON DELETE CASCADE,
+	PRIMARY KEY (UM_ID)
+);
+
+
+CREATE TABLE IF NOT EXISTS UM_DIALECT(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_DIALECT_URI VARCHAR(255) NOT NULL,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            UNIQUE(UM_DIALECT_URI, UM_TENANT_ID),
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+
+CREATE TABLE IF NOT EXISTS UM_CLAIM(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_DIALECT_ID INTEGER NOT NULL,
+            UM_CLAIM_URI VARCHAR(255) NOT NULL,
+            UM_DISPLAY_TAG VARCHAR(255),
+            UM_DESCRIPTION VARCHAR(255),
+            UM_MAPPED_ATTRIBUTE_DOMAIN VARCHAR(255),
+            UM_MAPPED_ATTRIBUTE VARCHAR(255),
+            UM_REG_EX VARCHAR(255),
+            UM_SUPPORTED SMALLINT,
+            UM_REQUIRED SMALLINT,
+            UM_DISPLAY_ORDER INTEGER,
+            UM_CHECKED_ATTRIBUTE SMALLINT,
+            UM_READ_ONLY SMALLINT,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            UNIQUE(UM_DIALECT_ID, UM_CLAIM_URI,UM_MAPPED_ATTRIBUTE_DOMAIN, UM_TENANT_ID),
+            FOREIGN KEY(UM_DIALECT_ID, UM_TENANT_ID) REFERENCES UM_DIALECT(UM_ID, UM_TENANT_ID),
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_PROFILE_CONFIG(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_DIALECT_ID INTEGER,
+            UM_PROFILE_NAME VARCHAR(255),
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            FOREIGN KEY(UM_DIALECT_ID, UM_TENANT_ID) REFERENCES UM_DIALECT(UM_ID, UM_TENANT_ID),
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+
+CREATE TABLE IF NOT EXISTS UM_HYBRID_ROLE(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_ROLE_NAME VARCHAR(255),
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_HYBRID_USER_ROLE(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_USER_NAME VARCHAR(255),
+            UM_ROLE_ID INTEGER NOT NULL,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+	    UM_DOMAIN_ID INTEGER,
+            UNIQUE (UM_USER_NAME, UM_ROLE_ID, UM_TENANT_ID,UM_DOMAIN_ID),
+            FOREIGN KEY (UM_ROLE_ID, UM_TENANT_ID) REFERENCES UM_HYBRID_ROLE(UM_ID, UM_TENANT_ID) ON DELETE CASCADE,
+	    FOREIGN KEY (UM_DOMAIN_ID, UM_TENANT_ID) REFERENCES UM_DOMAIN(UM_DOMAIN_ID, UM_TENANT_ID) ON DELETE CASCADE,
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_HYBRID_REMEMBER_ME (
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+			UM_USER_NAME VARCHAR(255) NOT NULL,
+			UM_COOKIE_VALUE VARCHAR(1024),
+			UM_CREATED_TIME TIMESTAMP,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+			PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_SYSTEM_ROLE(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_ROLE_NAME VARCHAR(255),
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);
+
+CREATE TABLE IF NOT EXISTS UM_SYSTEM_USER_ROLE(
+            UM_ID INTEGER NOT NULL AUTO_INCREMENT,
+            UM_USER_NAME VARCHAR(255),
+            UM_ROLE_ID INTEGER NOT NULL,
+            UM_TENANT_ID INTEGER DEFAULT 0,
+            UNIQUE (UM_USER_NAME, UM_ROLE_ID, UM_TENANT_ID),
+            FOREIGN KEY (UM_ROLE_ID, UM_TENANT_ID) REFERENCES UM_SYSTEM_ROLE(UM_ID, UM_TENANT_ID),
+            PRIMARY KEY (UM_ID, UM_TENANT_ID)
+);

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

@@ -54,5 +54,11 @@
         <Enable>true</Enable>
         <ExpiryTime>300</ExpiryTime>
     </DeviceCacheConfiguration>
+    <PushNotificationConfiguration>
+        <SchedulerBatchSize>100</SchedulerBatchSize>
+        <SchedulerBatchDelayMills>2000</SchedulerBatchDelayMills>
+        <SchedulerTaskInitialDelay>10</SchedulerTaskInitialDelay>
+        <SchedulerTaskEnabled>false</SchedulerTaskEnabled>
+    </PushNotificationConfiguration>
 </DeviceMgtConfiguration>
 

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

@@ -28,9 +28,19 @@
     <registryRoot>/</registryRoot>
 
     <dbConfig name="wso2registry">
-        <dataSource>jdbc/WSO2CarbonDB</dataSource>
+        <url>jdbc:h2:./target/databasetest/CARBON_TEST</url>
+        <!--userName>sa</userName>
+        <password>sa</password-->
+        <driverName>org.h2.Driver</driverName>
+        <maxActive>80</maxActive>
+        <maxWait>60000</maxWait>
+        <minIdle>5</minIdle>
     </dbConfig>
 
+    <!--<dbConfig name="wso2registry">-->
+        <!--<dataSource>jdbc/WSO2CarbonDB</dataSource>-->
+    <!--</dbConfig>-->
+
    <!--<handler class="org.wso2.carbon.registry.extensions.handlers.SynapseRepositoryHandler">
         <filter class="org.wso2.carbon.registry.core.jdbc.handlers.filters.MediaTypeMatcher">
             <property name="mediaType">application/vnd.apache.synapse</property>

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/resources/sql/CreateH2TestDB.sql

@@ -1,3 +1,4 @@
+DROP TABLE IF EXISTS DM_DEVICE_TYPE;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
      ID INT AUTO_INCREMENT NOT NULL,
      NAME VARCHAR(300) NULL DEFAULT NULL,
@@ -8,6 +9,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
      PRIMARY KEY (ID)
 );
 
+DROP TABLE IF EXISTS DM_GROUP;
 CREATE TABLE IF NOT EXISTS DM_GROUP (
   ID                  INTEGER AUTO_INCREMENT NOT NULL,
   GROUP_NAME          VARCHAR(100) DEFAULT NULL,
@@ -19,6 +21,7 @@ CREATE TABLE IF NOT EXISTS DM_GROUP (
   PRIMARY KEY (ID)
 );
 
+DROP TABLE IF EXISTS DM_DEVICE_CERTIFICATE;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE (
       ID                    INTEGER auto_increment NOT NULL,
       SERIAL_NUMBER            VARCHAR(500) DEFAULT NULL,
@@ -28,6 +31,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE (
     	PRIMARY KEY (ID)
 );
 
+DROP TABLE IF EXISTS DM_DEVICE;
 CREATE TABLE IF NOT EXISTS DM_DEVICE (
      ID                    INTEGER auto_increment NOT NULL,
      DESCRIPTION           TEXT DEFAULT NULL,
@@ -41,6 +45,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE (
      REFERENCES DM_DEVICE_TYPE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_DEVICE_PROPERTIES;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_PROPERTIES (
      DEVICE_TYPE_NAME VARCHAR(300) NOT NULL,
      DEVICE_IDENTIFICATION VARCHAR(300) NOT NULL,
@@ -50,6 +55,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_PROPERTIES (
      PRIMARY KEY (DEVICE_TYPE_NAME, DEVICE_IDENTIFICATION, PROPERTY_NAME)
 );
 
+DROP TABLE IF EXISTS DM_DEVICE_GROUP_MAP;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_MAP (
   ID        INTEGER AUTO_INCREMENT NOT NULL,
   DEVICE_ID INTEGER DEFAULT NULL,
@@ -62,6 +68,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_MAP (
   REFERENCES DM_GROUP (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_OPERATION;
 CREATE TABLE IF NOT EXISTS DM_OPERATION (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     TYPE VARCHAR(50) NOT NULL,
@@ -71,6 +78,7 @@ CREATE TABLE IF NOT EXISTS DM_OPERATION (
     PRIMARY KEY (ID)
 );
 
+DROP TABLE IF EXISTS DM_CONFIG_OPERATION;
 CREATE TABLE IF NOT EXISTS DM_CONFIG_OPERATION (
     OPERATION_ID INTEGER NOT NULL,
     OPERATION_CONFIG  BLOB DEFAULT NULL,
@@ -79,6 +87,7 @@ CREATE TABLE IF NOT EXISTS DM_CONFIG_OPERATION (
     DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_COMMAND_OPERATION;
 CREATE TABLE IF NOT EXISTS DM_COMMAND_OPERATION (
     OPERATION_ID INTEGER NOT NULL,
     ENABLED BOOLEAN NOT NULL DEFAULT FALSE,
@@ -87,6 +96,7 @@ CREATE TABLE IF NOT EXISTS DM_COMMAND_OPERATION (
     DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_POLICY_OPERATION;
 CREATE TABLE IF NOT EXISTS DM_POLICY_OPERATION (
     OPERATION_ID INTEGER NOT NULL,
     ENABLED INTEGER NOT NULL DEFAULT 0,
@@ -96,6 +106,7 @@ CREATE TABLE IF NOT EXISTS DM_POLICY_OPERATION (
     DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_PROFILE_OPERATION;
 CREATE TABLE IF NOT EXISTS DM_PROFILE_OPERATION (
     OPERATION_ID INTEGER NOT NULL,
     ENABLED INTEGER NOT NULL DEFAULT 0,
@@ -105,6 +116,7 @@ CREATE TABLE IF NOT EXISTS DM_PROFILE_OPERATION (
     DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_ENROLMENT;
 CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     DEVICE_ID INTEGER NOT NULL,
@@ -119,6 +131,7 @@ CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
     DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_ENROLMENT_OP_MAPPING;
 CREATE TABLE IF NOT EXISTS DM_ENROLMENT_OP_MAPPING (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     ENROLMENT_ID INTEGER NOT NULL,
@@ -126,6 +139,7 @@ CREATE TABLE IF NOT EXISTS DM_ENROLMENT_OP_MAPPING (
     STATUS VARCHAR(50) NULL,
     CREATED_TIMESTAMP INT NOT NULL,
     UPDATED_TIMESTAMP INT NOT NULL,
+    PUSH_NOTIFICATION_STATUS VARCHAR(50),
     PRIMARY KEY (ID),
     CONSTRAINT fk_dm_device_operation_mapping_device FOREIGN KEY (ENROLMENT_ID) REFERENCES
     DM_ENROLMENT (ID) ON DELETE NO ACTION ON UPDATE NO ACTION,
@@ -133,6 +147,7 @@ CREATE TABLE IF NOT EXISTS DM_ENROLMENT_OP_MAPPING (
     DM_OPERATION (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_DEVICE_OPERATION_RESPONSE;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_OPERATION_RESPONSE (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     ENROLMENT_ID INTEGER NOT NULL,
@@ -148,6 +163,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_OPERATION_RESPONSE (
 
 -- POLICY RELATED TABLES --
 
+DROP TABLE IF EXISTS DM_PROFILE;
 CREATE  TABLE IF NOT EXISTS DM_PROFILE (
   ID INT NOT NULL AUTO_INCREMENT ,
   PROFILE_NAME VARCHAR(45) NOT NULL ,
@@ -163,10 +179,7 @@ CREATE  TABLE IF NOT EXISTS DM_PROFILE (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_POLICY;
-
-
-
 CREATE  TABLE IF NOT EXISTS DM_POLICY (
   ID INT(11) NOT NULL AUTO_INCREMENT ,
   NAME VARCHAR(45) DEFAULT NULL ,
@@ -186,9 +199,7 @@ CREATE  TABLE IF NOT EXISTS DM_POLICY (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_DEVICE_POLICY;
-
-
 CREATE  TABLE IF NOT EXISTS DM_DEVICE_POLICY (
   ID INT(11) NOT NULL AUTO_INCREMENT ,
   DEVICE_ID INT(11) NOT NULL ,
@@ -208,9 +219,7 @@ CREATE  TABLE IF NOT EXISTS DM_DEVICE_POLICY (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_DEVICE_TYPE_POLICY;
-
-
 CREATE  TABLE IF NOT EXISTS DM_DEVICE_TYPE_POLICY (
   ID INT(11) NOT NULL ,
   DEVICE_TYPE VARCHAR(20) NOT NULL ,
@@ -228,10 +237,7 @@ CREATE  TABLE IF NOT EXISTS DM_DEVICE_TYPE_POLICY (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_PROFILE_FEATURES;
-
-
-
 CREATE  TABLE IF NOT EXISTS DM_PROFILE_FEATURES (
   ID INT(11) NOT NULL AUTO_INCREMENT,
   PROFILE_ID INT(11) NOT NULL,
@@ -247,9 +253,7 @@ CREATE  TABLE IF NOT EXISTS DM_PROFILE_FEATURES (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_ROLE_POLICY;
-
-
 CREATE  TABLE IF NOT EXISTS DM_ROLE_POLICY (
   ID INT(11) NOT NULL AUTO_INCREMENT ,
   ROLE_NAME VARCHAR(45) NOT NULL ,
@@ -262,9 +266,7 @@ CREATE  TABLE IF NOT EXISTS DM_ROLE_POLICY (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_USER_POLICY;
-
-
 CREATE  TABLE IF NOT EXISTS DM_USER_POLICY (
   ID INT NOT NULL AUTO_INCREMENT ,
   POLICY_ID INT NOT NULL ,
@@ -277,7 +279,7 @@ CREATE  TABLE IF NOT EXISTS DM_USER_POLICY (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_DEVICE_POLICY_APPLIED;
  CREATE  TABLE IF NOT EXISTS DM_DEVICE_POLICY_APPLIED (
   ID INT NOT NULL AUTO_INCREMENT ,
   DEVICE_ID INT NOT NULL ,
@@ -298,7 +300,7 @@ CREATE  TABLE IF NOT EXISTS DM_USER_POLICY (
 );
 
 
-
+DROP TABLE IF EXISTS DM_CRITERIA;
 CREATE TABLE IF NOT EXISTS DM_CRITERIA (
   ID INT NOT NULL AUTO_INCREMENT,
   TENANT_ID INT NOT NULL,
@@ -307,7 +309,7 @@ CREATE TABLE IF NOT EXISTS DM_CRITERIA (
 );
 
 
-
+DROP TABLE IF EXISTS DM_POLICY_CRITERIA;
 CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA (
   ID INT NOT NULL AUTO_INCREMENT,
   CRITERIA_ID INT NOT NULL,
@@ -339,6 +341,7 @@ CREATE TABLE IF NOT EXISTS DM_POLICY_CRITERIA_PROPERTIES (
     ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_POLICY_COMPLIANCE_STATUS;
 CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_STATUS (
   ID INT NOT NULL AUTO_INCREMENT,
   DEVICE_ID INT NOT NULL,
@@ -353,7 +356,7 @@ CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_STATUS (
   PRIMARY KEY (ID)
 );
 
-
+DROP TABLE IF EXISTS DM_POLICY_CHANGE_MGT;
 CREATE TABLE IF NOT EXISTS DM_POLICY_CHANGE_MGT (
   ID INT NOT NULL AUTO_INCREMENT,
   POLICY_ID INT NOT NULL,
@@ -362,7 +365,7 @@ CREATE TABLE IF NOT EXISTS DM_POLICY_CHANGE_MGT (
   PRIMARY KEY (ID)
 );
 
-
+DROP TABLE IF EXISTS DM_POLICY_COMPLIANCE_FEATURES;
 CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_FEATURES (
   ID INT NOT NULL AUTO_INCREMENT,
   COMPLIANCE_STATUS_ID INT NOT NULL,
@@ -377,6 +380,7 @@ CREATE TABLE IF NOT EXISTS DM_POLICY_COMPLIANCE_FEATURES (
     ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_ENROLMENT;
 CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     DEVICE_ID INTEGER NOT NULL,
@@ -391,6 +395,7 @@ CREATE TABLE IF NOT EXISTS DM_ENROLMENT (
     DM_DEVICE (ID) ON DELETE NO ACTION ON UPDATE NO ACTION
 );
 
+DROP TABLE IF EXISTS DM_APPLICATION;
 CREATE TABLE IF NOT EXISTS DM_APPLICATION (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     NAME VARCHAR(150) NOT NULL,
@@ -408,6 +413,7 @@ CREATE TABLE IF NOT EXISTS DM_APPLICATION (
     PRIMARY KEY (ID)
 );
 
+DROP TABLE IF EXISTS DM_DEVICE_APPLICATION_MAPPING;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_APPLICATION_MAPPING (
     ID INTEGER AUTO_INCREMENT NOT NULL,
     DEVICE_ID INTEGER NOT NULL,
@@ -423,6 +429,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_APPLICATION_MAPPING (
 -- POLICY RELATED TABLES  FINISHED --
 
 -- NOTIFICATION TABLE --
+DROP TABLE IF EXISTS DM_NOTIFICATION;
 CREATE TABLE IF NOT EXISTS DM_NOTIFICATION (
     NOTIFICATION_ID INTEGER AUTO_INCREMENT NOT NULL,
     DEVICE_ID INTEGER NOT NULL,
@@ -439,7 +446,6 @@ CREATE TABLE IF NOT EXISTS DM_NOTIFICATION (
 -- NOTIFICATION TABLE END --
 
 DROP TABLE IF EXISTS DM_DEVICE_INFO;
-
 CREATE TABLE IF NOT EXISTS DM_DEVICE_INFO (
   ID INTEGER AUTO_INCREMENT NOT NULL,
   DEVICE_ID INT NULL,
@@ -454,9 +460,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_INFO (
 );
 
 
-
 DROP TABLE IF EXISTS DM_DEVICE_LOCATION;
-
 CREATE TABLE IF NOT EXISTS DM_DEVICE_LOCATION (
   ID INTEGER AUTO_INCREMENT NOT NULL,
   DEVICE_ID INT NULL,
@@ -477,7 +481,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_LOCATION (
     ON UPDATE NO ACTION
 );
 
-
+DROP TABLE IF EXISTS DM_DEVICE_DETAIL;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_DETAIL (
   ID INT NOT NULL AUTO_INCREMENT,
   DEVICE_ID INT NOT NULL,
@@ -507,7 +511,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_DETAIL (
 
 
 -- POLICY AND DEVICE GROUP MAPPING --
-
+DROP TABLE IF EXISTS DM_DEVICE_GROUP_POLICY;
 CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_POLICY (
   ID INT NOT NULL AUTO_INCREMENT,
   DEVICE_GROUP_ID INT NOT NULL,
@@ -529,7 +533,7 @@ CREATE TABLE IF NOT EXISTS DM_DEVICE_GROUP_POLICY (
 -- END OF POLICY AND DEVICE GROUP MAPPING --
 
 -- DASHBOARD RELATED VIEWS --
-
+DROP VIEW IF EXISTS POLICY_COMPLIANCE_INFO;
 CREATE VIEW POLICY_COMPLIANCE_INFO AS
 SELECT
 DEVICE_INFO.DEVICE_ID,
@@ -559,6 +563,7 @@ FROM DM_POLICY_COMPLIANCE_STATUS) DEVICE_WITH_POLICY_INFO
 ON DEVICE_INFO.DEVICE_ID = DEVICE_WITH_POLICY_INFO.DEVICE_ID
 ORDER BY DEVICE_INFO.DEVICE_ID;
 
+DROP VIEW IF EXISTS FEATURE_NON_COMPLIANCE_INFO;
 CREATE VIEW FEATURE_NON_COMPLIANCE_INFO AS
 SELECT
 DM_DEVICE.ID AS DEVICE_ID,

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

@@ -28,6 +28,15 @@
             <class name="org.wso2.carbon.policy.mgt.core.PolicyDAOTestCase"/>
             <class name="org.wso2.carbon.policy.mgt.core.MonitoringTestCase" />
             <class name="org.wso2.carbon.policy.mgt.core.PolicyEvaluationTestCase" />
+
+        </classes>
+    </test>
+    
+    <test name="Service Unit Tests" preserve-order="true">
+        <parameter name="dbType" value="H2"/>
+        <classes>
+            <class name="org.wso2.carbon.policy.mgt.core.PolicyManagerServiceImplTest"/>
+            <class name="org.wso2.carbon.policy.mgt.core.task.TaskSchedulerServiceImplTest" />
         </classes>
     </test>
 </suite>

components/policy-mgt/org.wso2.carbon.policy.mgt.core/src/test/resources/user-test/user-mgt-registry-test.xml

@@ -0,0 +1,101 @@
+<!--
+ ~ Copyright (c) 2005-2011, 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.
+ -->
+<UserManager>
+	<Realm>
+		<Configuration>
+            <AddAdmin>true</AddAdmin>
+	    <AdminRole>admin</AdminRole>
+	    <AdminUser>
+	    	<UserName>admin</UserName>
+	   	<Password>admin</Password>
+	    </AdminUser>
+	    <EveryOneRoleName>everyone</EveryOneRoleName>
+            <ReadOnly>false</ReadOnly>
+            <MaxUserNameListLength>500</MaxUserNameListLength>
+			<Property name="url">jdbc:h2:target/databasetest/CARBON_TEST</Property>
+			<Property name="driverName">org.h2.Driver</Property>
+			<Property name="maxActive">50</Property>
+			<Property name="maxWait">60000</Property>
+			<Property name="minIdle">5</Property>
+        </Configuration>
+        <UserStoreManager
+            class="org.wso2.carbon.user.core.jdbc.JDBCUserStoreManager">
+            <Property name="PasswordJavaRegEx">[\S]{5,30}$</Property>
+            <Property name="PasswordJavaScriptRegEx">[\\S]{5,30}</Property>
+            <Property name="SelectUserSQL">SELECT * FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?</Property>
+            <!--<Property name="GetRoleListSQL">SELECT UM_ROLE_NAME FROM UM_ROLE WHERE UM_TENANT_ID=?</Property>-->
+            <!--<Property name="UserFilterSQL">SELECT UM_USER_NAME FROM UM_USER WHERE UM_USER_NAME LIKE ? AND UM_TENANT_ID=? ORDER BY UM_USER_NAME</Property>-->
+            <!--<Property name="UserRoleSQL">SELECT UM_ROLE_NAME FROM UM_USER_ROLE, UM_ROLE, UM_USER WHERE UM_USER.UM_USER_NAME=? AND UM_USER.UM_ID=UM_USER_ROLE.UM_USER_ID AND UM_ROLE.UM_ID=UM_USER_ROLE.UM_ROLE_ID AND UM_USER_ROLE.UM_TENANT_ID=? AND UM_ROLE.UM_TENANT_ID=? AND UM_USER.UM_TENANT_ID=?</Property>-->
+            <!--<Property name="IsRoleExistingSQL">SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="IsUserExistingSQL">SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUserListOfRoleSQL">SELECT UM_USER_NAME FROM UM_USER_ROLE, UM_ROLE, UM_USER WHERE UM_ROLE.UM_ROLE_NAME=? AND UM_USER.UM_ID=UM_USER_ROLE.UM_USER_ID AND UM_ROLE.UM_ID=UM_USER_ROLE.UM_ROLE_ID AND UM_USER_ROLE.UM_TENANT_ID=? AND UM_ROLE.UM_TENANT_ID=? AND UM_USER.UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUserPropertyForProfileSQL">SELECT UM_ATTR_VALUE FROM UM_USER_ATTRIBUTE, UM_USER WHERE UM_USER.UM_ID = UM_USER_ATTRIBUTE.UM_USER_ID AND UM_USER.UM_USER_NAME=? AND UM_ATTR_NAME=? AND UM_PROFILE_ID=? AND UM_USER_ATTRIBUTE.UM_TENANT_ID=? AND UM_USER.UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUserPropertiesForProfileSQL">SELECT UM_ATTR_NAME, UM_ATTR_VALUE FROM UM_USER_ATTRIBUTE, UM_USER WHERE UM_USER.UM_ID = UM_USER_ATTRIBUTE.UM_USER_ID AND UM_USER.UM_USER_NAME=? AND UM_PROFILE_ID=? AND UM_USER_ATTRIBUTE.UM_TENANT_ID=? AND UM_USER.UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetProfileNamesSQL">SELECT DISTINCT UM_PROFILE_ID FROM UM_USER_ATTRIBUTE WHERE UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUserProfileNamesSQL">SELECT DISTINCT UM_PROFILE_ID FROM UM_USER_ATTRIBUTE WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUsersWithDefaultPasswordsSQL">SELECT UM_USER_NAME FROM UM_USER WHERE WHERE UM_USER_NAME=? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="UserNameUniqueAcrossTenantsSQL">SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=?</Property>-->
+            <!--<Property name="GetUserIDFromUserNameSQL">SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetUserNameFromTenantIDSQL">SELECT UM_USER_NAME FROM UM_USER WHERE UM_TENANT_ID=?</Property>-->
+            <!--<Property name="GetTenantIDFromUserNameSQL">SELECT UM_TENANT_ID FROM UM_USER WHERE UM_USER_NAME=?</Property>-->
+            <Property name="PasswordDigest">SHA-256</Property>
+            <Property name="StoreSaltedPassword">true</Property>
+            <Property name="UserNameUniqueAcrossTenants">false</Property>
+            <Property name="IsEmailUserName">false</Property>
+            <Property name="SuperDomain">wso2.com</Property>
+            <Property name="IsUsersOfRoleListing">true</Property>
+            <Property name="MaxUserNameListLength">100</Property>
+            <!-- writing sqls follow-->
+            <!--<Property name="AddUserSQL">INSERT INTO UM_USER (UM_USER_NAME, UM_USER_PASSWORD, UM_SALT_VALUE, UM_REQUIRE_CHANGE, UM_CHANGED_TIME, UM_TENANT_ID) VALUES (?, ?, ?, ?, ?, ?)</Property>-->
+            <Property name="AddRoleSQL">INSERT INTO UM_ROLE (UM_ROLE_NAME, UM_TENANT_ID) VALUES (?, ?)</Property>
+            <!--<Property name="AddUserToRoleSQL">INSERT INTO UM_USER_ROLE (UM_USER_ID, UM_ROLE_ID, UM_TENANT_ID) VALUES ((SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?),(SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?), ?)</Property>-->
+            <!--<Property name="AddUserToRoleSQL-mssql">INSERT INTO UM_USER_ROLE (UM_USER_ID, UM_ROLE_ID, UM_TENANT_ID) SELECT (SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?),(SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?),(?)</Property>-->
+            <!--<Property name="RemoveUserFromRoleSQL">DELETE FROM UM_USER_ROLE WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_ROLE_ID=(SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="AddRoleToUserSQL">INSERT INTO UM_USER_ROLE (UM_ROLE_ID, UM_USER_ID, UM_TENANT_ID) VALUES ((SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?),(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?), ?)</Property>-->
+            <!--<Property name="AddRoleToUserSQL-mssql">INSERT INTO UM_USER_ROLE (UM_ROLE_ID, UM_USER_ID, UM_TENANT_ID) SELECT (SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?),(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?), (?)</Property>-->
+            <!--<Property name="RemoveRoleFromUserSQL">DELETE FROM UM_USER_ROLE WHERE UM_ROLE_ID=(SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?) AND UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="DeleteRoleSQL">DELETE FROM UM_ROLE WHERE UM_ROLE_NAME = ? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="OnDeleteRoleRemoveUserRoleMappingSQL">DELETE FROM UM_USER_ROLE WHERE UM_ROLE_ID=(SELECT UM_ID FROM UM_ROLE WHERE UM_ROLE_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="OnDeleteUserRemoveUserRoleMappingSQL">DELETE FROM UM_USER_ROLE WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="OnDeleteUserRemoveUserAttributeSQL">DELETE FROM UM_USER_ATTRIBUTE WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="DeleteUserSQL">DELETE FROM UM_USER WHERE UM_USER_NAME = ? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="UpdateUserPasswordSQL">UPDATE UM_USER SET UM_USER_PASSWORD= ?, UM_SALT_VALUE=?, UM_REQUIRE_CHANGE=?, UM_CHANGED_TIME=? WHERE UM_USER_NAME= ? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="AddUserPropertySQL">INSERT INTO UM_USER_ATTRIBUTE (UM_USER_ID, UM_ATTR_NAME, UM_ATTR_VALUE, UM_PROFILE_ID, UM_TENANT_ID) VALUES ((SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?), ?, ?, ?, ?)</Property>-->
+            <!--<Property name="AddUserPropertySQL-mssql">INSERT INTO UM_USER_ATTRIBUTE (UM_USER_ID, UM_ATTR_NAME, UM_ATTR_VALUE, UM_PROFILE_ID, UM_TENANT_ID) SELECT (SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?), (?), (?), (?), (?)</Property>-->
+            <!--<Property name="UpdateUserPropertySQL">UPDATE UM_USER_ATTRIBUTE SET UM_ATTR_VALUE=? WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_ATTR_NAME=? AND UM_PROFILE_ID=? AND UM_TENANT_ID=?</Property>-->
+            <!--<Property name="DeleteUserPropertySQL">DELETE FROM UM_USER_ATTRIBUTE WHERE UM_USER_ID=(SELECT UM_ID FROM UM_USER WHERE UM_USER_NAME=? AND UM_TENANT_ID=?) AND UM_ATTR_NAME=? AND UM_PROFILE_ID=? AND UM_TENANT_ID=?</Property>-->
+            <Property name="TenantManager">org.wso2.carbon.user.core.tenant.JDBCTenantManager</Property>
+	</UserStoreManager>
+        <AuthorizationManager
+            class="org.wso2.carbon.user.core.authorization.JDBCAuthorizationManager">
+            <Property name="AuthorizationCacheEnabled">true</Property>
+            </AuthorizationManager>
+    </Realm>
+    <SystemPermission>
+        <Permission>login</Permission>
+        <Permission>manage-configuration</Permission>
+        <Permission>manage-security</Permission>
+        <Permission>upload-services</Permission>
+        <Permission>manage-services</Permission>
+        <Permission>manage-lc-configuration</Permission>
+        <Permission>manage-mediation</Permission>
+        <Permission>monitor-system</Permission>
+        <Permission>delegate-identity</Permission>
+    </SystemPermission>
+</UserManager>
+

components/policy-mgt/pom.xml

@@ -23,13 +23,13 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>policy-mgt</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - Policy Management Component</name>
     <url>http://wso2.org</url>

components/test-coverage/pom.xml

@@ -21,7 +21,7 @@
     <parent>
         <artifactId>carbon-devicemgt</artifactId>
         <groupId>org.wso2.carbon.devicemgt</groupId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>

components/webapp-authenticator-framework/org.wso2.carbon.webapp.authenticator.framework/pom.xml

@@ -21,14 +21,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>webapp-authenticator-framework</artifactId>
-        <version>3.0.131-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>org.wso2.carbon.webapp.authenticator.framework</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>WSO2 Carbon - Web Application Authenticator Framework Bundle</name>
     <description>WSO2 Carbon - Web Application Authenticator Framework Bundle</description>

components/webapp-authenticator-framework/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.131-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>webapp-authenticator-framework</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - Webapp Authenticator Framework</name>
     <url>http://wso2.org</url>

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

@@ -21,14 +21,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>apimgt-extensions-feature</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.apimgt.application.extension.feature</artifactId>
     <packaging>pom</packaging>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <name>WSO2 Carbon - API Management Application Extension Feature</name>
     <url>http://wso2.org</url>
     <description>This feature contains an implementation of a api application registration, which takes care of subscription

features/apimgt-extensions/org.wso2.carbon.apimgt.handler.server.feature/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>apimgt-extensions-feature</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.apimgt.handler.server.feature</artifactId>
     <packaging>pom</packaging>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <name>WSO2 Carbon - Device Management - APIM handler Server Feature</name>
     <url>http://wso2.org</url>
     <description>This feature contains the handler for the api authentications

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

@@ -21,13 +21,13 @@
 	<parent>
 		<groupId>org.wso2.carbon.devicemgt</groupId>
 		<artifactId>apimgt-extensions-feature</artifactId>
-		<version>3.0.131-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.feature</artifactId>
-	<version>3.0.131-SNAPSHOT</version>
+	<version>3.0.136-SNAPSHOT</version>
 	<packaging>pom</packaging>
 	<name>WSO2 Carbon - APIM Integration Client Feature</name>
 	<url>http://wso2.org</url>

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

@@ -21,14 +21,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>apimgt-extensions-feature</artifactId>
-        <version>3.0.131-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.feature</artifactId>
     <packaging>pom</packaging>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <name>WSO2 Carbon - API Management Webapp Publisher Feature</name>
     <url>http://wso2.org</url>
     <description>This feature contains an implementation of a Tomcat lifecycle listener, which takes care of publishing

features/apimgt-extensions/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.131-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>apimgt-extensions-feature</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - API Management Extensions Feature</name>
     <url>http://wso2.org</url>

features/certificate-mgt/org.wso2.carbon.certificate.mgt.api.feature/pom.xml

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

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

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

features/certificate-mgt/org.wso2.carbon.certificate.mgt.server.feature/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>certificate-mgt-feature</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.certificate.mgt.server.feature</artifactId>
     <packaging>pom</packaging>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <name>WSO2 Carbon - Certificate Management Server Feature</name>
     <url>http://wso2.org</url>
     <description>This feature contains the core bundles required for back-end Certificate Management functionality

features/certificate-mgt/pom.xml

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>carbon-devicemgt</artifactId>
-        <version>3.0.131-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-feature</artifactId>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <packaging>pom</packaging>
     <name>WSO2 Carbon - Certificate Management Feature</name>
     <url>http://wso2.org</url>

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

@@ -22,14 +22,14 @@
     <parent>
         <groupId>org.wso2.carbon.devicemgt</groupId>
         <artifactId>device-mgt-extensions-feature</artifactId>
-        <version>3.0.131-SNAPSHOT</version>
+        <version>3.0.136-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
     <artifactId>org.wso2.carbon.device.mgt.extensions.device.type.deployer.feature</artifactId>
     <packaging>pom</packaging>
-    <version>3.0.131-SNAPSHOT</version>
+    <version>3.0.136-SNAPSHOT</version>
     <name>WSO2 Carbon - Device Type Deployer Feature</name>
     <url>http://wso2.org</url>
     <description>WSO2 Carbon - Device Type Deployer Feature</description>