Merge branch 'master' into testcases

revert-70aa11f8
chathurace 7 years ago committed by GitHub
commit ce008fb061

@ -163,11 +163,6 @@
<groupId>org.wso2.carbon.devicemgt</groupId> <groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.device.mgt.common</artifactId> <artifactId>org.wso2.carbon.device.mgt.common</artifactId>
</dependency> </dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<scope>test</scope>
</dependency>
<dependency> <dependency>
<groupId>org.wso2.carbon.devicemgt</groupId> <groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.device.mgt.analytics.data.publisher</artifactId> <artifactId>org.wso2.carbon.device.mgt.analytics.data.publisher</artifactId>

@ -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;

@ -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.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.GroupPaginationRequest; import org.wso2.carbon.device.mgt.common.GroupPaginationRequest;
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.core.common.TestDataHolder;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder; import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
import org.wso2.carbon.registry.core.config.RegistryContext; import org.wso2.carbon.registry.core.config.RegistryContext;
import org.wso2.carbon.registry.core.exceptions.RegistryException; import org.wso2.carbon.registry.core.exceptions.RegistryException;
@ -108,7 +109,7 @@ public class TestUtils {
public static List<DeviceIdentifier> getDeviceIdentifiersList(){ public static List<DeviceIdentifier> getDeviceIdentifiersList(){
DeviceIdentifier identifier = new DeviceIdentifier(); DeviceIdentifier identifier = new DeviceIdentifier();
identifier.setId("12345"); identifier.setId("12345");
identifier.setType("Test"); identifier.setType(TestDataHolder.TEST_DEVICE_TYPE);
List<DeviceIdentifier> list = new ArrayList<>(); List<DeviceIdentifier> list = new ArrayList<>();
list.add(identifier); list.add(identifier);

@ -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.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.device.details.DeviceInfo; 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.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;
@ -33,11 +33,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;
@ -164,4 +165,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;
}
} }

@ -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();
}
}
}

@ -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.common.group.mgt.*;
import org.wso2.carbon.device.mgt.core.TestUtils; 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.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.DeviceConfigurationManager;
import org.wso2.carbon.device.mgt.core.config.cache.DeviceCacheConfiguration; import org.wso2.carbon.device.mgt.core.config.cache.DeviceCacheConfiguration;
import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory; import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
@ -266,7 +267,7 @@ public class GroupManagementProviderServiceTest extends BaseDeviceManagementTest
public void getGroupsByDeviceIdentifier() throws GroupManagementException { public void getGroupsByDeviceIdentifier() throws GroupManagementException {
DeviceIdentifier identifier = new DeviceIdentifier(); DeviceIdentifier identifier = new DeviceIdentifier();
identifier.setId("12345"); identifier.setId("12345");
identifier.setType("Test"); identifier.setType(TestDataHolder.TEST_DEVICE_TYPE);
List<DeviceGroup> groups = groupManagementProviderService.getGroups(identifier); List<DeviceGroup> groups = groupManagementProviderService.getGroups(identifier);
Assert.assertNotNull(groups); Assert.assertNotNull(groups);
} }

@ -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; 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 +56,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 +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() { 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 +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));
} }
} }

@ -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);
}
}
}

@ -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; package org.wso2.carbon.device.mgt.core.task;
import org.wso2.carbon.ntask.common.TaskException; import org.wso2.carbon.ntask.common.TaskException;

@ -46,7 +46,9 @@
<class name="org.wso2.carbon.device.mgt.core.operation.ScheduledTaskOperationTests"/> <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.permission.mgt.PermissionManagerServiceTest" />
<class name="org.wso2.carbon.device.mgt.core.notification.mgt.NotificationManagementServiceImplTests"/> <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.DeviceTaskManagerServiceTest"/>
<class name="org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerTest"/>
<class name="org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceTest"/> <class name="org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceTest"/>
</classes> </classes>
</test> </test>

@ -206,6 +206,7 @@
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>commons-dbcp.wso2</groupId> <groupId>commons-dbcp.wso2</groupId>
<artifactId>commons-dbcp</artifactId> <artifactId>commons-dbcp</artifactId>
@ -220,6 +221,13 @@
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.10.0</version>
</dependency>
</dependencies> </dependencies>
</project> </project>

@ -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();
}
}

@ -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;
}
}

@ -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;
}
}

@ -28,6 +28,13 @@
<class name="org.wso2.carbon.policy.mgt.core.PolicyDAOTestCase"/> <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.MonitoringTestCase" />
<class name="org.wso2.carbon.policy.mgt.core.PolicyEvaluationTestCase" /> <class name="org.wso2.carbon.policy.mgt.core.PolicyEvaluationTestCase" />
</classes>
</test>
<test name="Service Unit Tests" preserve-order="true">
<classes>
<class name="org.wso2.carbon.policy.mgt.core.task.TaskSchedulerServiceImplTest" />
</classes> </classes>
</test> </test>
<test name="Service Unit Tests" preserve-order="true"> <test name="Service Unit Tests" preserve-order="true">

Loading…
Cancel
Save