Merge pull request #1036 from Megala21/master

Adding test cases and improving existing test cases
revert-70aa11f8
sinthuja 7 years ago committed by GitHub
commit 565af94e36

@ -83,9 +83,7 @@ public class DeviceTypeManager implements DeviceManager {
if (deviceTypeConfiguration.getFeatures() != null && deviceTypeConfiguration.getFeatures().
getFeature() != null) {
List<Feature> features = deviceTypeConfiguration.getFeatures().getFeature();
if (features != null) {
featureManager = new ConfigurationBasedFeatureManager(features);
}
featureManager = new ConfigurationBasedFeatureManager(features);
}
if (deviceTypeConfiguration.getDeviceAuthorizationConfig() != null) {
requiredDeviceTypeAuthorization = deviceTypeConfiguration.getDeviceAuthorizationConfig().
@ -119,7 +117,8 @@ public class DeviceTypeManager implements DeviceManager {
try {
defaultPlatformConfiguration = this.getDefaultConfiguration();
} catch (DeviceManagementException e) {
String msg = "Error occurred while default platform configuration";
String msg =
"Error occurred while getting default platform configuration for the device type " + deviceType;
throw new DeviceTypeDeployerPayloadException(msg, e);
}

@ -126,14 +126,13 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
}
public boolean updateDevice(Device device) throws DeviceTypeMgtPluginException {
boolean status = false;
Connection conn = null;
Connection conn;
PreparedStatement stmt = null;
try {
conn = deviceTypeDAOHandler.getConnection();
stmt = conn.prepareStatement(
"UPDATE DM_DEVICE_PROPERTIES SET PROPERTY_VALUE = ? WHERE DEVICE_TYPE_NAME = ? AND " +
"DEVICE_IDENTIFICATION = ? AND PROPERTY_NAME = ? AND TENANT_ID= ?");
"UPDATE DM_DEVICE_PROPERTIES SET PROPERTY_VALUE = ? WHERE DEVICE_TYPE_NAME = ? AND "
+ "DEVICE_IDENTIFICATION = ? AND PROPERTY_NAME = ? AND TENANT_ID= ?");
for (Device.Property property : device.getProperties()) {
if (!deviceProps.contains(property.getName())) {
@ -149,8 +148,8 @@ public class PropertyBasedPluginDAOImpl implements PluginDAO {
stmt.executeBatch();
return true;
} catch (SQLException e) {
String msg = "Error occurred while modifying the device '" +
device.getDeviceIdentifier() + "' data on" + deviceType;
String msg = "Error occurred while modifying the device '" + device.getDeviceIdentifier() + "' data on"
+ deviceType;
log.error(msg, e);
throw new DeviceTypeMgtPluginException(msg, e);
} finally {

@ -22,6 +22,10 @@ package org.wso2.carbon.device.mgt.extensions.device.type.template.exception;
*/
public class DeviceTypeMgtPluginException extends Exception{
public DeviceTypeMgtPluginException(String msg) {
super(msg);
}
public DeviceTypeMgtPluginException(String msg, Exception nestedEx) {
super(msg, nestedEx);
}

@ -25,6 +25,7 @@ import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeMgtPluginException;
import org.wso2.carbon.device.mgt.extensions.internal.DeviceTypeExtensionDataHolder;
import org.wso2.carbon.registry.api.RegistryException;
import org.wso2.carbon.registry.api.RegistryService;
import org.wso2.carbon.registry.api.Resource;
import org.wso2.carbon.registry.core.Registry;
@ -101,25 +102,28 @@ public class DeviceTypeUtils {
public static Registry getConfigurationRegistry() throws DeviceTypeMgtPluginException {
try {
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
return DeviceTypeExtensionDataHolder.getInstance().getRegistryService()
.getConfigSystemRegistry(tenantId);
org.wso2.carbon.registry.core.service.RegistryService registryService = DeviceTypeExtensionDataHolder
.getInstance().getRegistryService();
if (registryService == null) {
throw new DeviceTypeMgtPluginException("Registry Service is not initialized properly");
}
return registryService.getConfigSystemRegistry(tenantId);
} catch (RegistryException e) {
throw new DeviceTypeMgtPluginException("Error in retrieving conf registry instance: " + e.getMessage(), e);
}
}
public static boolean putRegistryResource(String path, Resource resource) throws DeviceTypeMgtPluginException {
boolean status;
try {
DeviceTypeUtils.getConfigurationRegistry().beginTransaction();
DeviceTypeUtils.getConfigurationRegistry().put(path, resource);
DeviceTypeUtils.getConfigurationRegistry().commitTransaction();
status = true;
Registry registry = getConfigurationRegistry();
registry.beginTransaction();
registry.put(path, resource);
registry.commitTransaction();
return true;
} catch (RegistryException e) {
throw new DeviceTypeMgtPluginException("Error occurred while persisting registry resource : " +
e.getMessage(), e);
throw new DeviceTypeMgtPluginException(
"Error occurred while persisting registry resource : " + e.getMessage(), e);
}
return status;
}
public static Resource getRegistryResource(String path) throws DeviceTypeMgtPluginException {

@ -18,13 +18,26 @@
package org.wso2.carbon.device.mgt.extensions.device.type.template;
import org.h2.jdbcx.JdbcDataSource;
import org.mockito.Mockito;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import org.wso2.carbon.base.MultitenantConstants;
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.extensions.device.type.template.config.DataSource;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceDetails;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.DeviceTypeConfiguration;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.Properties;
import org.wso2.carbon.device.mgt.extensions.device.type.template.config.exception.DeviceTypeConfigurationException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceDAODefinition;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypeDAOHandler;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOImpl;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.DeviceTypePluginDAOManager;
import org.wso2.carbon.device.mgt.extensions.device.type.template.dao.PropertyBasedPluginDAOImpl;
import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeDeployerPayloadException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeMgtPluginException;
import org.wso2.carbon.device.mgt.extensions.utils.Utils;
import org.xml.sax.SAXException;
@ -32,7 +45,11 @@ import javax.xml.bind.JAXBException;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.URL;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;
/**
* This class tests the negative scenarios in {@link DeviceTypeManager} initialization;
@ -40,15 +57,22 @@ import java.net.URL;
public class DeviceTypeManagerNegativeTest {
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration1;
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration2;
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration3;
private DeviceTypeConfiguration androidDeviceTypeConfiguration;
private DeviceTypeConfigIdentifier deviceTypeConfigIdentifier;
private DeviceTypeManager androidDeviceTypeManager;
private DeviceTypeDAOHandler deviceTypeDAOHandler;
private final String DEFECTIVE_DEVICE_TYPE = "defectiveDeviceType";
private final String TABLE_NAME = "DEFECTIVE_DEVICE";
private DeviceIdentifier deviceIdentifier;
private final String ANDROID_DEVICE_TYPE = "android";
private PropertyBasedPluginDAOImpl propertyBasedPluginDAO;
private Device sampleDevice;
@BeforeTest
public void setup()
throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException,
IOException {
IOException, NoSuchFieldException, IllegalAccessException {
ClassLoader classLoader = getClass().getClassLoader();
URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype.xml");
File configurationFile = null;
@ -76,6 +100,37 @@ public class DeviceTypeManagerNegativeTest {
if (configurationFile != null) {
androidDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile());
}
resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype3.xml");
if (resourceUrl != null) {
configurationFile = new File(resourceUrl.getFile());
}
if (configurationFile != null) {
defectiveDeviceTypeConfiguration3 = Utils
.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile());
}
createDefectiveDeviceTypeManager();
deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(Utils.TEST_STRING);
deviceIdentifier.setType(ANDROID_DEVICE_TYPE);
DeviceDetails deviceDetails = new DeviceDetails();
Properties properties = new Properties();
List<String> propertyList = new ArrayList<>();
propertyList.add(Utils.TEST_STRING);
properties.addProperties(propertyList);
deviceDetails.setProperties(properties);
propertyBasedPluginDAO = new PropertyBasedPluginDAOImpl(deviceDetails,
deviceTypeDAOHandler, ANDROID_DEVICE_TYPE);
sampleDevice = new Device();
sampleDevice.setDeviceIdentifier(Utils.TEST_STRING);
List<Device.Property> deviceProperties = new ArrayList<>();
Device.Property property = new Device.Property();
property.setName(Utils.TEST_STRING);
property.setValue(Utils.TEST_STRING);
deviceProperties.add(property);
sampleDevice.setProperties(deviceProperties);
}
@Test(description = "This test case tests the behaviour of the DeviceTypeManager creation without defining the "
@ -121,4 +176,168 @@ public class DeviceTypeManagerNegativeTest {
new DeviceTypeManager(deviceTypeConfigIdentifier, androidDeviceTypeConfiguration);
}
@Test(description = "This test case tests the behaviour of the DeviceTypeManager creation when having a "
+ "defective platform configuration ", expectedExceptions = {DeviceTypeDeployerPayloadException.class},
expectedExceptionsMessageRegExp = "Error occurred while getting default platform configuration for the "
+ "device type wrong *")
public void testWithDefectivePlatformConfiguration() {
DeviceTypeConfigIdentifier wrongDeviceTypeConfigIdentifier = new DeviceTypeConfigIdentifier("wrong",
MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
new DeviceTypeManager(wrongDeviceTypeConfigIdentifier, androidDeviceTypeConfiguration);
}
@Test(description = "This test case tests the behaviour of the DeviceTypeManager creation when having a "
+ "defective platform configuration ", expectedExceptions = {DeviceTypeDeployerPayloadException.class},
expectedExceptionsMessageRegExp = "Error while looking up the data source:.*")
public void testWithoutDeviceSpecificTable() {
new DeviceTypeManager(deviceTypeConfigIdentifier, defectiveDeviceTypeConfiguration3);
}
@Test(description = "This test case tests the behaviour of the isEnrolled when the relevant tables are not there",
expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error while checking the enrollment status of android device.*")
public void testIsEnrolled() throws DeviceManagementException {
androidDeviceTypeManager.isEnrolled(deviceIdentifier);
}
@Test(description = "This test case tests the behaviour of the modifyEnrollment when the relevant tables "
+ "are not there",
expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error while updating the enrollment of the.*")
public void testModifyEnrollment() throws DeviceManagementException {
Device device = new Device();
device.setDeviceIdentifier(deviceIdentifier.getId());
device.setType(deviceIdentifier.getType());
androidDeviceTypeManager.modifyEnrollment(device);
}
@Test(description = "This test case tests the behaviour of the getAllDevices when the relevant tables "
+ "are not there",
expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error occurred while fetching all.*")
public void testGetAllDevices() throws DeviceManagementException {
androidDeviceTypeManager.getAllDevices();
}
@Test(description = "This test case tests the behaviour of the updateDeviceInfo when the relevant tables "
+ "are not there",
expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error occurred while fetching the.*")
public void testUpdateDeviceInfo() throws DeviceManagementException {
Device device = new Device();
device.setDeviceIdentifier(deviceIdentifier.getId());
device.setType(deviceIdentifier.getType());
androidDeviceTypeManager.updateDeviceInfo(deviceIdentifier, device);
}
@Test(description = ("This test case tests the behaviour of the enrollDevice when the relevant tables are not "
+ "there"), expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error while enrolling the.*", dependsOnMethods = {"testIsEnrolled"})
public void testEnrollDevice() throws DeviceManagementException {
Device device = new Device();
device.setDeviceIdentifier(deviceIdentifier.getId());
device.setType(deviceIdentifier.getType());
Mockito.doReturn(false).when(androidDeviceTypeManager).isEnrolled(Mockito.any());
androidDeviceTypeManager.enrollDevice(device);
}
@Test(description = ("This test case tests the behaviour of the updateDeviceInfo when the relevant tables are not "
+ "there"), expectedExceptions = {DeviceManagementException.class},
expectedExceptionsMessageRegExp = "Error occurred while updating the.*", dependsOnMethods =
{"testUpdateDeviceInfo"})
public void testUpdateDeviceWithMock() throws DeviceManagementException {
Mockito.doReturn(new Device()).when(androidDeviceTypeManager).getDevice(Mockito.any());
androidDeviceTypeManager.updateDeviceInfo(deviceIdentifier, sampleDevice);
}
@Test(description = "This test case tests the behaviour of addDevice when the relevant tables are not available",
expectedExceptions = { DeviceTypeMgtPluginException.class },
expectedExceptionsMessageRegExp = "Error occurred while adding the device .*")
public void testAddDevice() throws DeviceTypeMgtPluginException {
propertyBasedPluginDAO.addDevice(sampleDevice);
}
@Test(description = "This test case tests the behaviour of getDevice when the relevant tables are not available",
expectedExceptions = { DeviceTypeMgtPluginException.class },
expectedExceptionsMessageRegExp = "Error occurred while fetching device .*")
public void testGetPropertyBasedDevice() throws DeviceTypeMgtPluginException {
propertyBasedPluginDAO.getDevice("id");
}
@Test(description = "This test case tests the behaviour of the getAllDevices method of the PropertyBasedPuginDAO",
expectedExceptions = {DeviceTypeMgtPluginException.class}, expectedExceptionsMessageRegExp = "Error "
+ "occurred while fetching all.*")
public void testGetAllPropertyBasedDevices() throws DeviceTypeMgtPluginException {
propertyBasedPluginDAO.getAllDevices();
}
@Test(description = "This test case tests the behaviour of the updateDevice method of the PropertyBasedPuginDAO",
expectedExceptions = {DeviceTypeMgtPluginException.class}, expectedExceptionsMessageRegExp = "Error "
+ "occurred while modifying the device.*")
public void testUpdateDevice() throws DeviceTypeMgtPluginException {
propertyBasedPluginDAO.updateDevice(sampleDevice);
}
/**
* To create a defective device type manager for testing.
* @throws NoSuchFieldException No Such Field Exception.
* @throws SAXException SAX Exception.
* @throws JAXBException JAXB Exception
* @throws ParserConfigurationException Parser Configuration Exception.
* @throws DeviceTypeConfigurationException Device Type Configuration Exception.
* @throws IOException IO Exception.
* @throws IllegalAccessException Illegal Access Exception.
*/
private void createDefectiveDeviceTypeManager()
throws NoSuchFieldException, SAXException, JAXBException, ParserConfigurationException,
DeviceTypeConfigurationException, IOException, IllegalAccessException {
Field datasourceField = DeviceTypeDAOHandler.class.getDeclaredField("dataSource");
datasourceField.setAccessible(true);
Field currentConnection = DeviceTypeDAOHandler.class.getDeclaredField("currentConnection");
currentConnection.setAccessible(true);
Field deviceTypePluginDAOField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypePluginDAO");
deviceTypePluginDAOField.setAccessible(true);
Field deviceTypeDAOHandlerField = DeviceTypePluginDAOManager.class.getDeclaredField("deviceTypeDAOHandler");
deviceTypeDAOHandlerField.setAccessible(true);
ClassLoader classLoader = getClass().getClassLoader();
URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "android.xml");
File androidConfiguration = null;
if (resourceUrl != null) {
androidConfiguration = new File(resourceUrl.getFile());
}
DeviceTypeConfiguration androidDeviceConfiguration = Utils.getDeviceTypeConfiguration(androidConfiguration);
androidDeviceTypeManager = Mockito.mock(DeviceTypeManager.class, Mockito.CALLS_REAL_METHODS);
deviceTypeDAOHandler = Mockito
.mock(DeviceTypeDAOHandler.class, Mockito.CALLS_REAL_METHODS);
JdbcDataSource dataSource = new JdbcDataSource();
dataSource.setURL("jdbc:h2:mem:notexist;DB_CLOSE_DELAY=-1");
dataSource.setUser("sa");
dataSource.setPassword("sa");
datasourceField.set(deviceTypeDAOHandler, dataSource);
currentConnection.set(deviceTypeDAOHandler, new ThreadLocal<Connection>());
DeviceDAODefinition deviceDAODefinition = Utils.getDeviceDAODefinition(androidDeviceConfiguration);
DeviceTypePluginDAOImpl deviceTypePluginDAO = new DeviceTypePluginDAOImpl(deviceDAODefinition,
deviceTypeDAOHandler);
DeviceTypePluginDAOManager deviceTypePluginDAOManager = Mockito
.mock(DeviceTypePluginDAOManager.class, Mockito.CALLS_REAL_METHODS);
deviceTypePluginDAOField.set(deviceTypePluginDAOManager, deviceTypePluginDAO);
deviceTypeDAOHandlerField.set(deviceTypePluginDAOManager, deviceTypeDAOHandler);
Field deviceTypePluginDAOManagerField = DeviceTypeManager.class.getDeclaredField("deviceTypePluginDAOManager");
deviceTypePluginDAOManagerField.setAccessible(true);
deviceTypePluginDAOManagerField.set(androidDeviceTypeManager, deviceTypePluginDAOManager);
Field propertiesExist = DeviceTypeManager.class.getDeclaredField("propertiesExist");
propertiesExist.setAccessible(true);
Field deviceType = DeviceTypeManager.class.getDeclaredField("deviceType");
deviceType.setAccessible(true);
deviceType.set(androidDeviceTypeManager, ANDROID_DEVICE_TYPE);
propertiesExist.set(androidDeviceTypeManager, true);
}
}

@ -170,8 +170,8 @@ public class DeviceTypeManagerTest {
Assert.assertTrue(customDeviceTypeManager.enrollDevice(customDevice), "Custom device type enrollment failed.");
List<Device.Property> properties = customDevice.getProperties();
Device.Property property = new Device.Property();
property.setName("test");
property.setValue("test");
property.setName(Utils.TEST_STRING);
property.setValue(Utils.TEST_STRING);
properties.add(property);
customDevice.setProperties(properties);
Assert.assertFalse(customDeviceTypeManager.enrollDevice(customDevice),
@ -239,8 +239,8 @@ public class DeviceTypeManagerTest {
list.add(property);
}
sampleDevice1 = new Device("testdevice", androidDeviceType, "test", "testdevice", null, null, list);
sampleDevice2 = new Device("testdevice1", androidDeviceType, "test", "testdevice", null, null, list);
sampleDevice1 = new Device("testdevice", androidDeviceType, Utils.TEST_STRING, "testdevice", null, null, list);
sampleDevice2 = new Device("testdevice1", androidDeviceType, Utils.TEST_STRING, "testdevice", null, null, list);
}
/**

@ -42,9 +42,13 @@ import javax.xml.bind.JAXBException;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* This test case contains the tests for {@link HTTPDeviceTypeManagerService} and {@link DeviceTypeGeneratorServiceImpl}
@ -75,7 +79,8 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
@Test(description = "This test case tests the enrollment of newly added device type")
public void testEnrollDevice() throws DeviceManagementException {
String deviceId = "testdevice1";
Device sampleDevice1 = new Device(deviceId, androidSenseDeviceType, "test", "testdevice", null, null, null);
Device sampleDevice1 = new Device(deviceId, androidSenseDeviceType, Utils.TEST_STRING, "testdevice", null, null,
null);
Assert.assertTrue(httpDeviceTypeManagerService.getDeviceManager().enrollDevice(sampleDevice1),
"Enrollment of " + androidSenseDeviceType + " device failed");
Assert.assertTrue(httpDeviceTypeManagerService.getDeviceManager()
@ -108,7 +113,7 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
ConfigurationEntry configurationEntry = configurationEntries.get(0);
Assert.assertEquals(configurationEntry.getName(), "test",
Assert.assertEquals(configurationEntry.getName(), Utils.TEST_STRING,
"Platform Configuration for device type " + "sample is not saved correctly");
String contentType = configurationEntry.getContentType();
@ -142,6 +147,28 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
httpDeviceTypeManagerService.getDeviceManager().enrollDevice(null);
}
@Test(description = "This test case tests the getDeviceTypeConfiguration method",
dependsOnMethods = {"testPopulateDeviceManagementService"})
public void testGetDeviceTypeConfiguration()
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Method getDeviceTypeConfiguration = HTTPDeviceTypeManagerService.class
.getDeclaredMethod("getDeviceTypeConfiguration", String.class, DeviceTypeMetaDefinition.class);
getDeviceTypeConfiguration.setAccessible(true);
List<String> properties = new ArrayList<>();
properties.add(Utils.TEST_STRING);
deviceTypeMetaDefinition.setProperties(properties);
Map<String, String> mapProperties = new HashMap<>();
mapProperties.put(Utils.TEST_STRING, Utils.TEST_STRING);
PushNotificationConfig pushNotificationConfig = new PushNotificationConfig("push", true, mapProperties);
deviceTypeMetaDefinition.setPushNotificationConfig(pushNotificationConfig);
DeviceTypeConfiguration deviceTypeConfiguration = (DeviceTypeConfiguration) getDeviceTypeConfiguration
.invoke(httpDeviceTypeManagerService, "android", deviceTypeMetaDefinition);
Assert.assertEquals(deviceTypeMetaDefinition.getProperties().size(),
deviceTypeConfiguration.getDeviceDetails().getProperties().getProperty().size(), "Number of "
+ "properties added in device-type meta definition is not equal to the properties added in "
+ "the DeviceType Configuration");
}
/**
* To create a sample device type meta defintion.
* @throws SAXException SAX Exception.
@ -180,6 +207,13 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
commonFeature.setCode(feature.getCode());
commonFeature.setDescription(feature.getDescription());
commonFeature.setName(feature.getName());
org.wso2.carbon.device.mgt.common.Feature.MetadataEntry metadataEntry = new org.wso2.carbon.device.mgt
.common.Feature.MetadataEntry();
metadataEntry.setId(1);
metadataEntry.setValue(Utils.TEST_STRING);
List<org.wso2.carbon.device.mgt.common.Feature.MetadataEntry> metadataEntries = new ArrayList<>();
metadataEntries.add(metadataEntry);
commonFeature.setMetadataEntries(metadataEntries);
features.add(commonFeature);
}

@ -56,6 +56,7 @@ import java.util.List;
*/
public class Utils {
public static final String DEVICE_TYPE_FOLDER = "device-types" + File.separator;
public static final String TEST_STRING = "test";
/**
* To get the device type configuration based on the configuration file

@ -23,10 +23,15 @@ import org.testng.Assert;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.DeviceTypeConfigIdentifier;
import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeMgtPluginException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceSchemaInitializer;
import org.wso2.carbon.device.mgt.extensions.device.type.template.util.DeviceTypeUtils;
import org.wso2.carbon.device.mgt.extensions.license.mgt.file.FileSystemBasedLicenseManager;
import org.wso2.carbon.device.mgt.extensions.license.mgt.registry.RegistryBasedLicenseManager;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
@ -63,7 +68,7 @@ public class UtilsTest {
@Test(description = "This test case tests the getLicense method of the FileBasedLicenseManager")
public void testFileBasedLicenseManagerGetLicense() throws LicenseManagementException {
License fileBasedLicense = fileSystemBasedLicenseManager.getLicense("test","en_US");
License fileBasedLicense = fileSystemBasedLicenseManager.getLicense(Utils.TEST_STRING,"en_US");
Assert.assertEquals(fileBasedLicense.getText(), "This is a file based license",
"FileBased License cannot " + "be retrieved by FileBasedLicenseManager");
}
@ -79,6 +84,43 @@ public class UtilsTest {
+ "file system", expectedExceptions = {UnsupportedOperationException.class},
expectedExceptionsMessageRegExp = "'addLicense' method is not supported in FileSystemBasedLicenseManager")
public void testFileBasedLicenseManagerAddLicense() throws LicenseManagementException {
fileSystemBasedLicenseManager.addLicense("test", null);
fileSystemBasedLicenseManager.addLicense(Utils.TEST_STRING, null);
}
@Test(description = "This test case tests the DeviceTypeConfigIdentifier equals method")
public void testDeviceTypeConfigIdentifier() {
DeviceTypeConfigIdentifier deviceTypeConfigIdentifier = new DeviceTypeConfigIdentifier("sample",
MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
DeviceTypeConfigIdentifier clonedDeviceTypeConfigIdentifier = new DeviceTypeConfigIdentifier("sample",
MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
Assert.assertTrue(deviceTypeConfigIdentifier.equals(clonedDeviceTypeConfigIdentifier),
"Clone device type config identifier gives wrong results for equals check.");
Assert.assertFalse(deviceTypeConfigIdentifier.equals(null),
"Device Type config identifier object comparison gives wrong results.");
}
@Test(description = "This test cases tests the registry based license addition")
public void testAddRegistryBasedLicense() throws LicenseManagementException {
String newLicenseString = "New License";
License fileBasedLicense = fileSystemBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US");
RegistryBasedLicenseManager registryBasedLicenseManager = new RegistryBasedLicenseManager();
registryBasedLicenseManager.addLicense(Utils.TEST_STRING, fileBasedLicense);
Assert.assertEquals(fileBasedLicense.getText(),
registryBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US").getText(),
"Registry license addition failed");
fileBasedLicense.setText(newLicenseString);
registryBasedLicenseManager.addLicense(Utils.TEST_STRING, fileBasedLicense);
Assert.assertEquals(registryBasedLicenseManager.getLicense(Utils.TEST_STRING, "en_US").getText(),
newLicenseString, "Registry license update failed");
}
@Test(description = "This test case tests the GetConfigurationRegistry method when the registry service is "
+ "unavailable", dependsOnMethods = {"testDeviceSchemaInitializer", "testDeviceTypeConfigIdentifier",
"testAddRegistryBasedLicense"},
expectedExceptions = {DeviceTypeMgtPluginException.class},
expectedExceptionsMessageRegExp = "Error in retrieving conf registry instance:.*")
public void testGetConfigurationRegistry() throws DeviceTypeMgtPluginException {
PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantId(4);
DeviceTypeUtils.getConfigurationRegistry();
}
}

@ -0,0 +1,23 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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.
-->
<PlatformConfiguration>
</configuration
</PlatformConfiguration>

@ -24,7 +24,7 @@
<currentDBConfig>wso2registry</currentDBConfig>
<readOnly>false</readOnly>
<enableCache>true</enableCache>
<enableCache>false</enableCache>
<registryRoot>/</registryRoot>
<dbConfig name="wso2registry">

@ -51,6 +51,11 @@
<ProvisioningConfig>
<SharedWithAllTenants>true</SharedWithAllTenants>
</ProvisioningConfig>
<DeviceAuthorizationConfig>
<authorizationRequired>true</authorizationRequired>
</DeviceAuthorizationConfig>
<!--
isScheduled element used to enable scheduler task to send push notification.
Task will send push notification as batches. So this will reduce sudden request burst when many devices try to
@ -92,6 +97,9 @@
<Description>Ring the device</Description>
<Operation context="/api/device-mgt/android/v1.0/admin/devices/ring" method="POST" type="application/json">
</Operation>
<MetaData>
<Property>test</Property>
</MetaData>
</Feature>
<Feature code="DEVICE_LOCK">
<Name>Device Lock</Name>

@ -21,15 +21,6 @@
<DeviceDetails table-id="DEFECTIVE_DEVICE"/>
<Features>
<Feature code="bulb">
<Name>Control Bulb</Name>
<Description>Control Bulb on Arduino Uno</Description>
<Operation context="/arduino/device/{deviceId}/bulb" method="POST">
<QueryParameters>
<Parameter>state</Parameter>
</QueryParameters>
</Operation>
</Feature>
</Features>
<ProvisioningConfig>

@ -0,0 +1,61 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ 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.
-->
<DeviceTypeConfiguration name="defective-devicetype">
<DeviceDetails>
<Properties>
<Property>
defective
</Property>
</Properties>
</DeviceDetails>
<Features>
<Feature code="bulb">
<Name>Control Bulb</Name>
<Description>Control Bulb on Arduino Uno</Description>
<Operation context="/arduino/device/{deviceId}/bulb" method="POST">
<QueryParameters>
<Parameter>state</Parameter>
</QueryParameters>
</Operation>
</Feature>
</Features>
<ProvisioningConfig>
<SharedWithAllTenants>true</SharedWithAllTenants>
</ProvisioningConfig>
<License>
<Language>en_US</Language>
<Version>1.0.0</Version>
<Text>This is license text</Text>
</License>
<DataSource>
<JndiConfig>
<Name>jdbc/MobileAndroidDM_DS</Name>
</JndiConfig>
<TableConfig>
<Table name="AD_DEVICE">
</Table>
</TableConfig>
</DataSource>
</DeviceTypeConfiguration>
Loading…
Cancel
Save