Unit Tests for DeviceTaskManagerService

revert-70aa11f8
Madawa Soysa 7 years ago
parent c0b2ad3ae6
commit 1b9f797720

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

@ -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.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.EnrolmentInfo; 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.app.mgt.Application;
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup; 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.common.notification.mgt.Notification;
import org.wso2.carbon.device.mgt.core.dto.DeviceType; import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import java.util.ArrayList; import java.util.ArrayList;
@ -32,11 +32,12 @@ import java.util.Properties;
public class TestDataHolder { 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 Integer SUPER_TENANT_ID = -1234;
public final static String SUPER_TENANT_DOMAIN = "carbon.super"; public final static String SUPER_TENANT_DOMAIN = "carbon.super";
public final static String initialDeviceIdentifier = "12345"; public final static String initialDeviceIdentifier = "12345";
public final static String OWNER = "admin"; public final static String OWNER = "admin";
public static final String OPERATION_CONFIG = "TEST-OPERATION-";
public static Device initialTestDevice; public static Device initialTestDevice;
public static DeviceType initialTestDeviceType; public static DeviceType initialTestDeviceType;
@ -126,4 +127,29 @@ public class TestDataHolder {
deviceGroup.setOwner(OWNER); deviceGroup.setOwner(OWNER);
return deviceGroup; 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;
}
} }

@ -2,47 +2,32 @@ package org.wso2.carbon.device.mgt.core.task;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.mockito.Mock;
import org.mockito.Mockito; 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.Assert;
import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test; 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.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.common.TestDataHolder;
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager; 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.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.device.mgt.core.task.impl.DeviceTaskManagerServiceImpl;
import org.wso2.carbon.ntask.common.TaskException; import org.wso2.carbon.ntask.common.TaskException;
import org.wso2.carbon.ntask.core.TaskInfo; import org.wso2.carbon.ntask.core.TaskInfo;
import org.wso2.carbon.ntask.core.TaskManager; 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.internal.TasksDSComponent;
import org.wso2.carbon.ntask.core.service.TaskService; import org.wso2.carbon.ntask.core.service.TaskService;
import org.wso2.carbon.ntask.core.service.impl.TaskServiceImpl; import org.wso2.carbon.ntask.core.service.impl.TaskServiceImpl;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
public class DeviceTaskManagerServiceTest { public class DeviceTaskManagerServiceTest {
private static final Log log = LogFactory.getLog(DeviceTaskManagerService.class); private static final Log log = LogFactory.getLog(DeviceTaskManagerService.class);
private static final String TASK_TYPE = "DEVICE_MONITORING"; private static final String TASK_TYPE = "DEVICE_MONITORING";
private DeviceTaskManagerService deviceTaskManagerService; 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(); DeviceConfigurationManager.getInstance().initConfig();
log.info("Initializing Device Task Manager Service Test Suite"); log.info("Initializing Device Task Manager Service Test Suite");
this.taskService = new TestTaskServiceImpl(); this.taskService = new TestTaskServiceImpl();
@ -54,30 +39,31 @@ public class DeviceTaskManagerServiceTest {
taskServiceField.set(null, Mockito.mock(TaskServiceImpl.class, Mockito.RETURNS_MOCKS)); 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() { public void testStartTask() {
try { try {
log.debug("Attempting to start task from testStartTask"); 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); TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1); Assert.assertEquals(this.taskService.getRegisteredTaskTypes().size(), 1);
Assert.assertNotNull(taskManager 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"); log.debug("Task Successfully started");
} catch (DeviceMgtTaskException | TaskException e) { } catch (DeviceMgtTaskException | TaskException e) {
Assert.fail("Exception occurred when starting the task", 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() { public void testUpdateTask() {
try { try {
log.debug("Attempting to update task from testStartTask"); 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); 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); Assert.assertEquals(taskManager.getAllTasks().size(), 1);
log.debug("Task Successfully updated"); log.debug("Task Successfully updated");
} catch (DeviceMgtTaskException | TaskException e) { } 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() { public void testStopTask() {
log.debug("Attempting to stop task from testStopTask"); log.debug("Attempting to stop task from testStopTask");
try { 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); TaskManager taskManager = this.taskService.getTaskManager(TASK_TYPE);
Assert.assertEquals(taskManager.getAllTasks().size(), 0); Assert.assertEquals(taskManager.getAllTasks().size(), 0);
} catch (DeviceMgtTaskException | TaskException e) { } 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));
} }
} }

@ -31,6 +31,9 @@ public class TestTaskManagerImpl implements TaskManager {
@Override @Override
public boolean deleteTask(String taskName) throws TaskException { 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) { for (TaskInfo task : this.registeredTasks) {
if (task.getName().contains(taskName)) { if (task.getName().contains(taskName)) {
this.registeredTasks.remove(task); this.registeredTasks.remove(task);

Loading…
Cancel
Save