Merge pull request #996 from sinthuja/origin-wso2-master

adding more testcases to operation management.
revert-70aa11f8
Harshan Liyanage 7 years ago committed by GitHub
commit 697414aae4

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

@ -141,7 +141,7 @@ public class OperationManagerImpl implements OperationManager {
org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation operationDto =
OperationDAOUtil.convertOperation(operation);
int operationId = this.lookupOperationDAO(operation).addOperation(operationDto);
boolean isScheduledOperation = this.isTaskScheduledOperation(operation, deviceIds);
boolean isScheduledOperation = this.isTaskScheduledOperation(operation);
boolean isNotRepeated = false;
boolean isScheduled = false;
@ -344,18 +344,22 @@ public class OperationManagerImpl implements OperationManager {
PaginationResult paginationResult = null;
List<Operation> operations = new ArrayList<>();
String owner = request.getOwner();
try {
if (!DeviceManagerUtil.isDeviceExists(deviceId)) {
throw new OperationManagementException("Device not found for given device " +
"Identifier:" + deviceId.getId() + " and given type : " +
deviceId.getType());
}
} catch (DeviceManagementException e) {
throw new OperationManagementException("Error while checking the existence of the device identifier - "
+ deviceId.getId() + " of the device type - " + deviceId.getType(), e);
}
if (!isActionAuthorized(deviceId)) {
throw new OperationManagementException("User '" + getUser() + "' is not authorized to access the '" +
deviceId.getType() + "' device, which carries the identifier '" +
deviceId.getId() + "' of owner '" + owner + "'");
}
EnrolmentInfo enrolmentInfo = this.getEnrolmentInfo(deviceId, owner);
if (enrolmentInfo == null) {
throw new OperationManagementException("Device not found for given device " +
"Identifier:" + deviceId.getId() + " and given type" +
deviceId.getType());
}
int enrolmentId = enrolmentInfo.getId();
try {
OperationManagementDAOFactory.openConnection();
@ -530,9 +534,8 @@ public class OperationManagerImpl implements OperationManager {
try {
int enrolmentId = enrolmentInfo.getId();
OperationManagementDAOFactory.beginTransaction();
boolean isUpdated = false;
if (operation.getStatus() != null) {
isUpdated = operationDAO.updateOperationStatus(enrolmentId, operationId,
operationDAO.updateOperationStatus(enrolmentId, operationId,
org.wso2.carbon.device.mgt.core.dto.operation.mgt.
Operation.Status.valueOf(operation.getStatus().
toString()));
@ -806,25 +809,6 @@ public class OperationManagerImpl implements OperationManager {
}
}
private OperationDAO lookupOperationDAO(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation operation) {
if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.CommandOperation ||
operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.COMMAND)) {
return commandOperationDAO;
} else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.ProfileOperation ||
operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.PROFILE)) {
return profileOperationDAO;
} else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.ConfigOperation ||
operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.CONFIG)) {
return configOperationDAO;
} else if (operation instanceof org.wso2.carbon.device.mgt.core.dto.operation.mgt.PolicyOperation ||
operation.getType().equals(org.wso2.carbon.device.mgt.core.dto.operation.mgt.Operation.Type.POLICY)) {
return policyOperationDAO;
} else {
return operationDAO;
}
}
private String getUser() {
return CarbonContext.getThreadLocalCarbonContext().getUsername();
}
@ -867,26 +851,6 @@ public class OperationManagerImpl implements OperationManager {
return isUserAuthorized;
}
private int getEnrolmentByStatus(DeviceIdentifier deviceId,
EnrolmentInfo.Status status) throws OperationManagementException {
int enrolmentId;
try {
DeviceManagementDAOFactory.openConnection();
int tenantId = CarbonContext.getThreadLocalCarbonContext().getTenantId();
enrolmentId = deviceDAO.getEnrolmentByStatus(deviceId, status, tenantId);
} catch (DeviceManagementDAOException e) {
throw new OperationManagementException("Error occurred while retrieving metadata of '" +
deviceId.getType() + "' device carrying the identifier '" +
deviceId.getId() + "'", e);
} catch (SQLException e) {
throw new OperationManagementException(
"Error occurred while opening a connection to the data source", e);
} finally {
DeviceManagementDAOFactory.closeConnection();
}
return enrolmentId;
}
private EnrolmentInfo getEnrolmentInfo(DeviceIdentifier deviceId, String owner) throws OperationManagementException {
EnrolmentInfo enrolmentInfo = null;
try {
@ -959,39 +923,15 @@ public class OperationManagerImpl implements OperationManager {
return updateStatus;
}
private boolean isTaskScheduledOperation(Operation operation, List<DeviceIdentifier> deviceIds) {
private boolean isTaskScheduledOperation(Operation operation) {
DeviceManagementProviderService deviceManagementProviderService = DeviceManagementDataHolder.getInstance().
getDeviceManagementProvider();
List<MonitoringOperation> monitoringOperations = deviceManagementProviderService.getMonitoringOperationList(deviceType);//Get task list from each device type
for (MonitoringOperation op : monitoringOperations) {
if (operation.getCode().equals(op.getTaskName())) {
return true;
}
}
// for(String dti : taskOperation){
// if (dti.equals(deviceType)) {
// monitoringOperations = deviceTypeSpecificTasks.get(dti);
//
// }
// }
//
// for(DeviceIdentifier deviceIdentifier : deviceIds){
// String deviceType = deviceIdentifier.getType();
//
//
//
// }
// TaskConfiguration taskConfiguration = DeviceConfigurationManager.getInstance().getDeviceManagementConfig().
// getTaskConfiguration();
// for (TaskConfiguration.Operation op : taskConfiguration.getOperations()) {
// if (operation.getCode().equals(op.getOperationName())) {
// return true;
// }
// }
return false;
}

@ -474,6 +474,13 @@ public final class DeviceManagerUtil {
return true;
}
public static boolean isDeviceExists(DeviceIdentifier deviceIdentifier) throws DeviceManagementException {
Device device = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().getDevice(deviceIdentifier,
false);
return !(device == null || device.getDeviceIdentifier() == null ||
device.getDeviceIdentifier().isEmpty() || device.getEnrolmentInfo() == null);
}
private static CacheManager getCacheManager() {
return Caching.getCacheManagerFactory().getCacheManager(DeviceManagementConstants.DM_CACHE_MANAGER);
}

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

@ -22,7 +22,6 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tomcat.jdbc.pool.PoolProperties;
import org.testng.Assert;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeSuite;
import org.w3c.dom.Document;
@ -30,17 +29,31 @@ import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.core.TestUtils;
import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
import org.wso2.carbon.device.mgt.core.dao.GroupManagementDAOFactory;
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.notification.mgt.dao.NotificationManagementDAOFactory;
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.device.mgt.core.service.GroupManagementProviderServiceImpl;
import org.wso2.carbon.device.mgt.core.util.DeviceManagerUtil;
import org.wso2.carbon.registry.core.config.RegistryContext;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.internal.RegistryDataHolder;
import org.wso2.carbon.registry.core.jdbc.realm.InMemoryRealmService;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.user.core.service.RealmService;
import javax.sql.DataSource;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.File;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
@ -56,6 +69,7 @@ public abstract class BaseDeviceManagementTest {
this.initDataSource();
this.initSQLScript();
this.initializeCarbonContext();
this.initServices();
}
protected void initDataSource() throws Exception {
@ -66,6 +80,27 @@ public abstract class BaseDeviceManagementTest {
NotificationManagementDAOFactory.init(dataSource);
}
private void initServices() throws DeviceManagementException, RegistryException {
DeviceConfigurationManager.getInstance().initConfig();
DeviceManagementProviderService deviceMgtService = new DeviceManagementProviderServiceImpl();
DeviceManagementServiceComponent.notifyStartupListeners();
DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
DeviceManagementDataHolder.getInstance().setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(new GroupManagementProviderServiceImpl());
DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
}
private RegistryService getRegistryService() throws RegistryException {
RealmService realmService = new InMemoryRealmService();
RegistryDataHolder.getInstance().setRealmService(realmService);
DeviceManagementDataHolder.getInstance().setRealmService(realmService);
InputStream is = this.getClass().getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
context.setSetup(true);
return context.getEmbeddedRegistryService();
}
@BeforeClass
public abstract void init() throws Exception;

@ -36,28 +36,17 @@ import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
import org.wso2.carbon.device.mgt.common.push.notification.NotificationStrategy;
import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.core.TestDeviceManagementService;
import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
import org.wso2.carbon.device.mgt.core.common.BaseDeviceManagementTest;
import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
import org.wso2.carbon.device.mgt.core.operation.mgt.CommandOperation;
import org.wso2.carbon.device.mgt.core.operation.mgt.ConfigOperation;
import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
import org.wso2.carbon.device.mgt.core.operation.mgt.PolicyOperation;
import org.wso2.carbon.device.mgt.core.operation.mgt.ProfileOperation;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
import org.wso2.carbon.registry.core.config.RegistryContext;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.internal.RegistryDataHolder;
import org.wso2.carbon.registry.core.jdbc.realm.InMemoryRealmService;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.user.core.service.RealmService;
import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
@ -67,7 +56,7 @@ import java.util.List;
/**
* This is the testcase which covers the methods from {@link OperationManager}
*/
public class OperationManagementTests {
public class OperationManagementTests extends BaseDeviceManagementTest {
private static final String DEVICE_TYPE = "OP_TEST_TYPE";
private static final String DEVICE_ID_PREFIX = "OP-TEST-DEVICE-ID-";
@ -79,6 +68,7 @@ public class OperationManagementTests {
private static final int NO_OF_DEVICES = 5;
private static final String ADMIN_USER = "admin";
private static final String NON_ADMIN_USER = "test";
private static final String INVALID_DEVICE = "ThisIsInvalid";
private List<DeviceIdentifier> deviceIds = new ArrayList<>();
private OperationManager operationMgtService;
@ -87,18 +77,12 @@ public class OperationManagementTests {
@BeforeClass
public void init() throws Exception {
DeviceConfigurationManager.getInstance().initConfig();
for (int i = 0; i < NO_OF_DEVICES; i++) {
deviceIds.add(new DeviceIdentifier(DEVICE_ID_PREFIX + i, DEVICE_TYPE));
}
List<Device> devices = TestDataHolder.generateDummyDeviceData(this.deviceIds);
DeviceManagementProviderService deviceMgtService = new DeviceManagementProviderServiceImpl();
DeviceManagementServiceComponent.notifyStartupListeners();
DeviceManagementDataHolder.getInstance().setDeviceManagementProvider(deviceMgtService);
DeviceManagementDataHolder.getInstance().setRegistryService(getRegistryService());
DeviceManagementDataHolder.getInstance().setDeviceAccessAuthorizationService(new DeviceAccessAuthorizationServiceImpl());
DeviceManagementDataHolder.getInstance().setGroupManagementProviderService(new GroupManagementProviderServiceImpl());
DeviceManagementDataHolder.getInstance().setDeviceTaskManagerService(null);
DeviceManagementProviderService deviceMgtService = DeviceManagementDataHolder.getInstance().
getDeviceManagementProvider();
deviceMgtService.registerDeviceType(new TestDeviceManagementService(DEVICE_TYPE,
MultitenantConstants.SUPER_TENANT_DOMAIN_NAME));
for (Device device : devices) {
@ -114,35 +98,59 @@ public class OperationManagementTests {
this.operationMgtService = new OperationManagerImpl(DEVICE_TYPE, notificationStrategy);
}
private RegistryService getRegistryService() throws RegistryException {
RealmService realmService = new InMemoryRealmService();
RegistryDataHolder.getInstance().setRealmService(realmService);
DeviceManagementDataHolder.getInstance().setRealmService(realmService);
InputStream is = this.getClass().getClassLoader().getResourceAsStream("carbon-home/repository/conf/registry.xml");
RegistryContext context = RegistryContext.getBaseInstance(is, realmService);
context.setSetup(true);
return context.getEmbeddedRegistryService();
}
@Test
public void addCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
this.commandActivity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
public void addCommandOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
this.commandActivity = this.operationMgtService.addOperation(
getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
this.deviceIds);
validateOperationResponse(this.commandActivity, ActivityStatus.Status.PENDING);
}
@Test
public void addCommandOperationInvalidDeviceIds() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
startTenantFlowAsNonAdmin();
try {
ArrayList<DeviceIdentifier> invalidDevices = new ArrayList<>();
for (int i = 0; i < 3; i++) {
invalidDevices.add(new DeviceIdentifier(INVALID_DEVICE + i, DEVICE_TYPE));
}
invalidDevices.addAll(this.deviceIds);
Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
Operation.Type.COMMAND, COMMAND_OPERATON_CODE), invalidDevices);
Assert.assertEquals(activity.getActivityStatus().size(), invalidDevices.size(),
"The operation response for add operation only have - " + activity.getActivityStatus().size());
for (int i = 0; i < activity.getActivityStatus().size(); i++) {
ActivityStatus status = activity.getActivityStatus().get(i);
if (i < 3) {
Assert.assertEquals(status.getStatus(), ActivityStatus.Status.INVALID);
} else {
Assert.assertEquals(status.getStatus(), ActivityStatus.Status.UNAUTHORIZED);
}
}
} finally {
PrivilegedCarbonContext.endTenantFlow();
}
}
@Test(expectedExceptions = InvalidDeviceException.class)
public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
public void addEmptyDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
COMMAND_OPERATON_CODE),
new ArrayList<>());
}
@Test(expectedExceptions = InvalidDeviceException.class)
public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
public void addNonInitializedDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
deviceIdentifiers.add(deviceIdentifier);
this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND,
COMMAND_OPERATON_CODE),
deviceIdentifiers);
}
@ -150,7 +158,8 @@ public class OperationManagementTests {
public void addNonAdminUserDevicesCommandOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
startTenantFlowAsNonAdmin();
Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(), Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
Activity activity = this.operationMgtService.addOperation(getOperation(new CommandOperation(),
Operation.Type.COMMAND, COMMAND_OPERATON_CODE),
deviceIds);
PrivilegedCarbonContext.endTenantFlow();
validateOperationResponse(activity, ActivityStatus.Status.UNAUTHORIZED);
@ -163,27 +172,33 @@ public class OperationManagementTests {
}
@Test(dependsOnMethods = "addCommandOperation")
public void addPolicyOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(), Operation.Type.POLICY, POLICY_OPERATION_CODE),
public void addPolicyOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new PolicyOperation(),
Operation.Type.POLICY, POLICY_OPERATION_CODE),
this.deviceIds);
validateOperationResponse(activity, ActivityStatus.Status.PENDING);
}
@Test(dependsOnMethods = "addPolicyOperation")
public void addConfigOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(), Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
public void addConfigOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new ConfigOperation(),
Operation.Type.CONFIG, CONFIG_OPERATION_CODE),
this.deviceIds);
validateOperationResponse(activity, ActivityStatus.Status.PENDING);
}
@Test(dependsOnMethods = "addConfigOperation")
public void addProfileOperation() throws DeviceManagementException, OperationManagementException, InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(), Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
public void addProfileOperation() throws DeviceManagementException, OperationManagementException,
InvalidDeviceException {
Activity activity = this.operationMgtService.addOperation(getOperation(new ProfileOperation(),
Operation.Type.PROFILE, PROFILE_OPERATION_CODE),
this.deviceIds);
validateOperationResponse(activity, ActivityStatus.Status.PENDING);
}
private Operation getOperation(Operation operation, Operation.Type type, String code) {
static Operation getOperation(Operation operation, Operation.Type type, String code) {
String date = new SimpleDateFormat(DATE_FORMAT_NOW).format(new Date());
operation.setCreatedTimeStamp(date);
operation.setType(type);
@ -192,7 +207,7 @@ public class OperationManagementTests {
}
private void validateOperationResponse(Activity activity, ActivityStatus.Status expectedStatus) {
Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation reponse for add operation only have - " +
Assert.assertEquals(activity.getActivityStatus().size(), NO_OF_DEVICES, "The operation response for add operation only have - " +
activity.getActivityStatus().size());
for (ActivityStatus status : activity.getActivityStatus()) {
Assert.assertEquals(status.getStatus(), expectedStatus);
@ -328,6 +343,17 @@ public class OperationManagementTests {
Assert.assertTrue(operation.getType().equals(Operation.Type.POLICY));
}
@Test(dependsOnMethods = "updateOperation", expectedExceptions = OperationManagementException.class)
public void getNextPendingOperationAsNonAdmin() throws OperationManagementException {
startTenantFlowAsNonAdmin();
try {
DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
this.operationMgtService.getNextPendingOperation(deviceIdentifier);
} finally {
PrivilegedCarbonContext.endTenantFlow();
}
}
@Test(dependsOnMethods = "getNextPendingOperation")
public void getOperationByDeviceAndOperationId() throws OperationManagementException {
DeviceIdentifier deviceIdentifier = this.deviceIds.get(0);
@ -438,4 +464,41 @@ public class OperationManagementTests {
Assert.assertTrue(this.operationMgtService.getNotificationStrategy() != null);
}
@Test(dependsOnMethods = {"getOperationByActivityIdAndDevice", "getOperationByActivityIdAndDeviceAsNonAdmin"})
public void getOperationForInactiveDevice() throws DeviceManagementException, OperationManagementException {
boolean disEnrolled = DeviceManagementDataHolder.getInstance().getDeviceManagementProvider().
disenrollDevice(deviceIds.get(0));
Assert.assertTrue(disEnrolled);
List operations = this.operationMgtService.getOperations(deviceIds.get(0));
Assert.assertTrue(operations == null);
}
@Test(dependsOnMethods = "getOperationForInactiveDevice", expectedExceptions = OperationManagementException.class)
public void getPaginatedOperationDeviceForInvalidDevice() throws DeviceManagementException, OperationManagementException {
PrivilegedCarbonContext.startTenantFlow();
PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(MultitenantConstants.SUPER_TENANT_ID, true);
PrivilegedCarbonContext.getThreadLocalCarbonContext().setUsername(ADMIN_USER);
try {
PaginationRequest request = new PaginationRequest(1, 2);
request.setDeviceType(DEVICE_TYPE);
request.setOwner(ADMIN_USER);
PaginationResult result = this.operationMgtService.getOperations(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE), request);
Assert.assertEquals(result.getRecordsFiltered(), 4);
Assert.assertEquals(result.getData().size(), 2);
Assert.assertEquals(result.getRecordsTotal(), 4);
} finally {
PrivilegedCarbonContext.endTenantFlow();
}
}
@Test(dependsOnMethods = "getOperationForInactiveDevice", expectedExceptions = OperationManagementException.class)
public void getPendingOperationDeviceForInvalidDevice() throws DeviceManagementException, OperationManagementException {
this.operationMgtService.getPendingOperations(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE));
}
@Test(dependsOnMethods = "getPendingOperationDeviceForInvalidDevice", expectedExceptions = OperationManagementException.class)
public void getNextPendingOperationDeviceForInvalidDevice() throws DeviceManagementException, OperationManagementException {
this.operationMgtService.getNextPendingOperation(new DeviceIdentifier(INVALID_DEVICE, DEVICE_TYPE));
}
}

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

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

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

@ -42,6 +42,7 @@
<class name="org.wso2.carbon.device.mgt.core.app.mgt.ApplicationManagementProviderServiceTest"/>
<class name="org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceTest"/>
<class name="org.wso2.carbon.device.mgt.core.operation.OperationManagementTests"/>
<class name="org.wso2.carbon.device.mgt.core.operation.ScheduledTaskOperationTests"/>
<class name="org.wso2.carbon.device.mgt.core.permission.mgt.PermissionManagerServiceTest" />
<class name="org.wso2.carbon.device.mgt.core.notification.mgt.NotificationManagementServiceImplTests"/>
<class name="org.wso2.carbon.device.mgt.core.task.DeviceTaskManagerServiceTest"/>

Loading…
Cancel
Save