Merge pull request #1036 from Megala21/master

Adding test cases and improving existing test cases
4.x.x
sinthuja 7 years ago committed by GitHub
commit 565af94e36

@ -83,10 +83,8 @@ public class DeviceTypeManager implements DeviceManager {
if (deviceTypeConfiguration.getFeatures() != null && deviceTypeConfiguration.getFeatures(). if (deviceTypeConfiguration.getFeatures() != null && deviceTypeConfiguration.getFeatures().
getFeature() != null) { getFeature() != null) {
List<Feature> features = deviceTypeConfiguration.getFeatures().getFeature(); List<Feature> features = deviceTypeConfiguration.getFeatures().getFeature();
if (features != null) {
featureManager = new ConfigurationBasedFeatureManager(features); featureManager = new ConfigurationBasedFeatureManager(features);
} }
}
if (deviceTypeConfiguration.getDeviceAuthorizationConfig() != null) { if (deviceTypeConfiguration.getDeviceAuthorizationConfig() != null) {
requiredDeviceTypeAuthorization = deviceTypeConfiguration.getDeviceAuthorizationConfig(). requiredDeviceTypeAuthorization = deviceTypeConfiguration.getDeviceAuthorizationConfig().
isAuthorizationRequired(); isAuthorizationRequired();
@ -119,7 +117,8 @@ public class DeviceTypeManager implements DeviceManager {
try { try {
defaultPlatformConfiguration = this.getDefaultConfiguration(); defaultPlatformConfiguration = this.getDefaultConfiguration();
} catch (DeviceManagementException e) { } 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); throw new DeviceTypeDeployerPayloadException(msg, e);
} }

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

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

@ -18,13 +18,26 @@
package org.wso2.carbon.device.mgt.extensions.device.type.template; 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.BeforeTest;
import org.testng.annotations.Test; import org.testng.annotations.Test;
import org.wso2.carbon.base.MultitenantConstants; 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.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.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.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.DeviceTypeDeployerPayloadException;
import org.wso2.carbon.device.mgt.extensions.device.type.template.exception.DeviceTypeMgtPluginException;
import org.wso2.carbon.device.mgt.extensions.utils.Utils; import org.wso2.carbon.device.mgt.extensions.utils.Utils;
import org.xml.sax.SAXException; import org.xml.sax.SAXException;
@ -32,7 +45,11 @@ import javax.xml.bind.JAXBException;
import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.ParserConfigurationException;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.lang.reflect.Field;
import java.net.URL; 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; * This class tests the negative scenarios in {@link DeviceTypeManager} initialization;
@ -40,15 +57,22 @@ import java.net.URL;
public class DeviceTypeManagerNegativeTest { public class DeviceTypeManagerNegativeTest {
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration1; private DeviceTypeConfiguration defectiveDeviceTypeConfiguration1;
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration2; private DeviceTypeConfiguration defectiveDeviceTypeConfiguration2;
private DeviceTypeConfiguration defectiveDeviceTypeConfiguration3;
private DeviceTypeConfiguration androidDeviceTypeConfiguration; private DeviceTypeConfiguration androidDeviceTypeConfiguration;
private DeviceTypeConfigIdentifier deviceTypeConfigIdentifier; private DeviceTypeConfigIdentifier deviceTypeConfigIdentifier;
private DeviceTypeManager androidDeviceTypeManager;
private DeviceTypeDAOHandler deviceTypeDAOHandler;
private final String DEFECTIVE_DEVICE_TYPE = "defectiveDeviceType"; private final String DEFECTIVE_DEVICE_TYPE = "defectiveDeviceType";
private final String TABLE_NAME = "DEFECTIVE_DEVICE"; private final String TABLE_NAME = "DEFECTIVE_DEVICE";
private DeviceIdentifier deviceIdentifier;
private final String ANDROID_DEVICE_TYPE = "android";
private PropertyBasedPluginDAOImpl propertyBasedPluginDAO;
private Device sampleDevice;
@BeforeTest @BeforeTest
public void setup() public void setup()
throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException, throws SAXException, JAXBException, ParserConfigurationException, DeviceTypeConfigurationException,
IOException { IOException, NoSuchFieldException, IllegalAccessException {
ClassLoader classLoader = getClass().getClassLoader(); ClassLoader classLoader = getClass().getClassLoader();
URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype.xml"); URL resourceUrl = classLoader.getResource(Utils.DEVICE_TYPE_FOLDER + "defective-devicetype.xml");
File configurationFile = null; File configurationFile = null;
@ -76,6 +100,37 @@ public class DeviceTypeManagerNegativeTest {
if (configurationFile != null) { if (configurationFile != null) {
androidDeviceTypeConfiguration = Utils.getDeviceTypeConfiguration(configurationFile.getAbsoluteFile()); 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 " @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); 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."); Assert.assertTrue(customDeviceTypeManager.enrollDevice(customDevice), "Custom device type enrollment failed.");
List<Device.Property> properties = customDevice.getProperties(); List<Device.Property> properties = customDevice.getProperties();
Device.Property property = new Device.Property(); Device.Property property = new Device.Property();
property.setName("test"); property.setName(Utils.TEST_STRING);
property.setValue("test"); property.setValue(Utils.TEST_STRING);
properties.add(property); properties.add(property);
customDevice.setProperties(properties); customDevice.setProperties(properties);
Assert.assertFalse(customDeviceTypeManager.enrollDevice(customDevice), Assert.assertFalse(customDeviceTypeManager.enrollDevice(customDevice),
@ -239,8 +239,8 @@ public class DeviceTypeManagerTest {
list.add(property); list.add(property);
} }
sampleDevice1 = new Device("testdevice", androidDeviceType, "test", "testdevice", null, null, list); sampleDevice1 = new Device("testdevice", androidDeviceType, Utils.TEST_STRING, "testdevice", null, null, list);
sampleDevice2 = new Device("testdevice1", androidDeviceType, "test", "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 javax.xml.parsers.ParserConfigurationException;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL; import java.net.URL;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
/** /**
* This test case contains the tests for {@link HTTPDeviceTypeManagerService} and {@link DeviceTypeGeneratorServiceImpl} * 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") @Test(description = "This test case tests the enrollment of newly added device type")
public void testEnrollDevice() throws DeviceManagementException { public void testEnrollDevice() throws DeviceManagementException {
String deviceId = "testdevice1"; 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), Assert.assertTrue(httpDeviceTypeManagerService.getDeviceManager().enrollDevice(sampleDevice1),
"Enrollment of " + androidSenseDeviceType + " device failed"); "Enrollment of " + androidSenseDeviceType + " device failed");
Assert.assertTrue(httpDeviceTypeManagerService.getDeviceManager() Assert.assertTrue(httpDeviceTypeManagerService.getDeviceManager()
@ -108,7 +113,7 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
ConfigurationEntry configurationEntry = configurationEntries.get(0); 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"); "Platform Configuration for device type " + "sample is not saved correctly");
String contentType = configurationEntry.getContentType(); String contentType = configurationEntry.getContentType();
@ -142,6 +147,28 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
httpDeviceTypeManagerService.getDeviceManager().enrollDevice(null); 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. * To create a sample device type meta defintion.
* @throws SAXException SAX Exception. * @throws SAXException SAX Exception.
@ -180,6 +207,13 @@ public class HttpDeviceTypeManagerServiceAndDeviceTypeGeneratorServceTest {
commonFeature.setCode(feature.getCode()); commonFeature.setCode(feature.getCode());
commonFeature.setDescription(feature.getDescription()); commonFeature.setDescription(feature.getDescription());
commonFeature.setName(feature.getName()); 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); features.add(commonFeature);
} }

@ -56,6 +56,7 @@ import java.util.List;
*/ */
public class Utils { public class Utils {
public static final String DEVICE_TYPE_FOLDER = "device-types" + File.separator; 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 * 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.BeforeTest;
import org.testng.annotations.Test; import org.testng.annotations.Test;
import org.wso2.carbon.base.MultitenantConstants; 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.License;
import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException; 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.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.file.FileSystemBasedLicenseManager;
import org.wso2.carbon.device.mgt.extensions.license.mgt.registry.RegistryBasedLicenseManager;
import java.io.File; import java.io.File;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
@ -63,7 +68,7 @@ public class UtilsTest {
@Test(description = "This test case tests the getLicense method of the FileBasedLicenseManager") @Test(description = "This test case tests the getLicense method of the FileBasedLicenseManager")
public void testFileBasedLicenseManagerGetLicense() throws LicenseManagementException { 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", Assert.assertEquals(fileBasedLicense.getText(), "This is a file based license",
"FileBased License cannot " + "be retrieved by FileBasedLicenseManager"); "FileBased License cannot " + "be retrieved by FileBasedLicenseManager");
} }
@ -79,6 +84,43 @@ public class UtilsTest {
+ "file system", expectedExceptions = {UnsupportedOperationException.class}, + "file system", expectedExceptions = {UnsupportedOperationException.class},
expectedExceptionsMessageRegExp = "'addLicense' method is not supported in FileSystemBasedLicenseManager") expectedExceptionsMessageRegExp = "'addLicense' method is not supported in FileSystemBasedLicenseManager")
public void testFileBasedLicenseManagerAddLicense() throws LicenseManagementException { 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> <currentDBConfig>wso2registry</currentDBConfig>
<readOnly>false</readOnly> <readOnly>false</readOnly>
<enableCache>true</enableCache> <enableCache>false</enableCache>
<registryRoot>/</registryRoot> <registryRoot>/</registryRoot>
<dbConfig name="wso2registry"> <dbConfig name="wso2registry">

@ -51,6 +51,11 @@
<ProvisioningConfig> <ProvisioningConfig>
<SharedWithAllTenants>true</SharedWithAllTenants> <SharedWithAllTenants>true</SharedWithAllTenants>
</ProvisioningConfig> </ProvisioningConfig>
<DeviceAuthorizationConfig>
<authorizationRequired>true</authorizationRequired>
</DeviceAuthorizationConfig>
<!-- <!--
isScheduled element used to enable scheduler task to send push notification. 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 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> <Description>Ring the device</Description>
<Operation context="/api/device-mgt/android/v1.0/admin/devices/ring" method="POST" type="application/json"> <Operation context="/api/device-mgt/android/v1.0/admin/devices/ring" method="POST" type="application/json">
</Operation> </Operation>
<MetaData>
<Property>test</Property>
</MetaData>
</Feature> </Feature>
<Feature code="DEVICE_LOCK"> <Feature code="DEVICE_LOCK">
<Name>Device Lock</Name> <Name>Device Lock</Name>

@ -21,15 +21,6 @@
<DeviceDetails table-id="DEFECTIVE_DEVICE"/> <DeviceDetails table-id="DEFECTIVE_DEVICE"/>
<Features> <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> </Features>
<ProvisioningConfig> <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