Unit Tests for DeviceTaskManagerService

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/common/TestDataHolder.java

@@ -18,11 +18,11 @@ 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.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;
@@ -32,11 +32,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;
 
@@ -126,4 +127,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/task/DeviceTaskManagerServiceTest.java

@@ -2,47 +2,32 @@ 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 +39,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 +71,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 +84,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/TestTaskManagerImpl.java

@@ -31,6 +31,9 @@ public class TestTaskManagerImpl implements TaskManager {
 
     @Override
     public boolean deleteTask(String taskName) throws TaskException {
+        if(this.registeredTasks.size() <= 0) {
+            throw new TaskException("Cannot delete task.", TaskException.Code.NO_TASK_EXISTS);
+        }
         for (TaskInfo task : this.registeredTasks) {
             if (task.getName().contains(taskName)) {
                 this.registeredTasks.remove(task);