Adding more testcasses.

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

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

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

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

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

@@ -22,7 +22,6 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.tomcat.jdbc.pool.PoolProperties;
 import org.testng.Assert;
-import org.testng.annotations.AfterSuite;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeSuite;
 import org.w3c.dom.Document;

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

@@ -36,28 +36,17 @@ import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
 import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
 import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
 import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
-import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
+import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
 import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
-import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
 import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
-import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
 import org.wso2.carbon.device.mgt.core.operation.mgt.CommandOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.ConfigOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
 import org.wso2.carbon.device.mgt.core.operation.mgt.PolicyOperation;
 import org.wso2.carbon.device.mgt.core.operation.mgt.ProfileOperation;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
-import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
-import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
-import org.wso2.carbon.registry.core.config.RegistryContext;
-import org.wso2.carbon.registry.core.exceptions.RegistryException;
-import org.wso2.carbon.registry.core.internal.RegistryDataHolder;
-import org.wso2.carbon.registry.core.jdbc.realm.InMemoryRealmService;
-import org.wso2.carbon.registry.core.service.RegistryService;
-import org.wso2.carbon.user.core.service.RealmService;
 import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
 
-import java.io.InputStream;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -67,7 +56,7 @@ import java.util.List;
 /**
  * This is the testcase which covers the methods from {@link OperationManager}
  */
-public class OperationManagementTests {
+public class OperationManagementTests extends BaseDeviceManagementTest {
 
     private static final String DEVICE_TYPE = "OP_TEST_TYPE";
     private static final String DEVICE_ID_PREFIX = "OP-TEST-DEVICE-ID-";
@@ -91,8 +80,8 @@ public class OperationManagementTests {
             deviceIds.add(new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE));
         }
         List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
-        DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
+        DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().
-        DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider();
+                getDeviceManagementProvider();
         deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
                 MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
         for (Device device : devices) {
@@ -108,27 +97,59 @@ public class OperationManagementTests {
         this.operationMgtService = new OperationManagerImpl(DEVICE_TYPE, notificationStrategy);
     }
 
-
-
     @Test
-    public void addCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addCommandOperation() throws DeviceManagementException, OperationManagementException,
-        this.commandActivity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+            InvalidDeviceException {
+        this.commandActivity = this.operationMgtService.addOperation(
+                getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
                 this.deviceIds);
         validateOperationResponse(this.commandActivity, ActivityStatus.Status.PENDING);
     }
 
+    @Test
+    public void addCommandOperationInvalidDeviceIds() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
+        startTenantFlowAsNonAdmin();
+        try {
+            ArrayList<DeviceIdentifier> invalidDevices = new ArrayList<>();
+            for (int i = 0; i < 3; i++) {
+                invalidDevices.add(new DeviceIdentifier("12345" + i, DEVICE_TYPE));
+            }
+            invalidDevices.addAll(this.deviceIds);
+            Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
+                    Operation.Type.COMMAND, COMMAND_OPERATON_CODE), invalidDevices);
+            Assert.assertEquals(activity.getActivityStatus().size(), invalidDevices.size(),
+                    "The operation response for add operation only have - " + activity.getActivityStatus().size());
+            for (int i = 0; i < activity.getActivityStatus().size(); i++) {
+                ActivityStatus status = activity.getActivityStatus().get(i);
+                if (i < 3) {
+                    Assert.assertEquals(status.getStatus(), ActivityStatus.Status.INVALID);
+                } else {
+                    Assert.assertEquals(status.getStatus(), ActivityStatus.Status.UNAUTHORIZED);
+                }
+            }
+        } finally {
+            PrivilegedCarbonContext.endTenantFlow();
+        }
+    }
+
+
     @Test(expectedExceptions = InvalidDeviceException.class)
-    public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
-        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+            InvalidDeviceException {
+        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
+                COMMAND_OPERATON_CODE),
                 new ArrayList<>());
     }
 
     @Test(expectedExceptions = InvalidDeviceException.class)
-    public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
+            InvalidDeviceException {
         DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
         List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
         deviceIdentifiers.add(deviceIdentifier);
-        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+        this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
+                COMMAND_OPERATON_CODE),
                 deviceIdentifiers);
     }
 
@@ -136,7 +157,8 @@ public class OperationManagementTests {
     public void addNonAdminUserDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
             InvalidDeviceException {
         startTenantFlowAsNonAdmin();
-        Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
+        Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
+                Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
                 deviceIds);
         PrivilegedCarbonContext.endTenantFlow();
         validateOperationResponse(activity, ActivityStatus.Status.UNAUTHORIZED);
@@ -149,27 +171,33 @@ public class OperationManagementTests {
     }
 
     @Test(dependsOnMethods = "addCommandOperation")
-    public void addPolicyOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addPolicyOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(), Operation.Type.POLICY, POLICY_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(),
+                Operation.Type.POLICY, POLICY_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
     @Test(dependsOnMethods = "addPolicyOperation")
-    public void addConfigOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addConfigOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(), Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(),
+                Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
     @Test(dependsOnMethods = "addConfigOperation")
-    public void addProfileOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
+    public void addProfileOperation() throws DeviceManagementException, OperationManagementException,
-        Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(), Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
+            InvalidDeviceException {
+        Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(),
+                Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
                 this.deviceIds);
         validateOperationResponse(activity, ActivityStatus.Status.PENDING);
     }
 
-    private Operation getOperation(Operation operation, Operation.Type type, String code) {
+    static Operation getOperation(Operation operation, Operation.Type type, String code) {
         String date = new SimpleDateFormat(DATE_FORMAT_NOW).format(new Date());
         operation.setCreatedTimeStamp(date);
         operation.setType(type);
@@ -178,7 +206,7 @@ public class OperationManagementTests {
     }
 
     private void validateOperationResponse(Activity activity, ActivityStatus.Status expectedStatus) {
-        Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation reponse for add operation only have - " +
+        Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation response for add operation only have - " +
                 activity.getActivityStatus().size());
         for (ActivityStatus status : activity.getActivityStatus()) {
             Assert.assertEquals(status.getStatus(), expectedStatus);
@@ -424,4 +452,13 @@ public class OperationManagementTests {
         Assert.assertTrue(this.operationMgtService.getNotificationStrategy() != null);
     }
 
+    @Test(dependsOnMethods = {"getOperationByActivityIdAndDevice", "getOperationByActivityIdAndDeviceAsNonAdmin"})
+    public void getOperationForInactiveDevice() throws DeviceManagementException, OperationManagementException {
+        boolean disEnrolled = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().
+                disenrollDevice(deviceIds.get(0));
+        Assert.assertTrue(disEnrolled);
+        List operations = this.operationMgtService.getOperations(deviceIds.get(0));
+        Assert.assertTrue(operations == null);
+    }
+
 }

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

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

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

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

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

@@ -23,7 +23,6 @@ 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.EnrolmentInfo;
 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;
@@ -40,7 +39,6 @@ import org.wso2.carbon.user.core.service.RealmService;
 import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
 
 import java.io.InputStream;
-import java.util.Date;
 
 public class DeviceManagementProviderServiceTest extends BaseDeviceManagementTest {
 

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

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

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

@@ -42,6 +42,7 @@
             <class name="org.wso2.carbon.device.mgt.core.app.mgt.ApplicationManagementProviderServiceTest"/>
             <class name="org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceTest"/>
             <class name="org.wso2.carbon.device.mgt.core.operation.OperationManagementTests"/>
+            <class name="org.wso2.carbon.device.mgt.core.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.task.DeviceTaskManagerServiceTest"/>