Merge pull request #1077 from Megala21/master

Adding test cases for UserManagementServiceImpl and NotificationManagementServiceImpl
revert-70aa11f8
sinthuja 7 years ago committed by GitHub
commit 70ba229f02

@ -80,8 +80,7 @@ public class NotificationManagementServiceImpl implements NotificationManagement
@PUT @PUT
@Path("/{id}/mark-checked") @Path("/{id}/mark-checked")
public Response updateNotificationStatus( public Response updateNotificationStatus(@PathParam("id") @Max(45)int id) {
@PathParam("id") @Max(45)int id) {
String msg; String msg;
Notification.Status status = Notification.Status.CHECKED; Notification.Status status = Notification.Status.CHECKED;
Notification notification; Notification notification;
@ -90,8 +89,8 @@ public class NotificationManagementServiceImpl implements NotificationManagement
} catch (NotificationManagementException e) { } catch (NotificationManagementException e) {
msg = "Error occurred while updating notification status."; msg = "Error occurred while updating notification status.";
log.error(msg, e); log.error(msg, e);
throw new UnexpectedServerErrorException( return Response.serverError().entity(
new ErrorResponse.ErrorResponseBuilder().setCode(500l).setMessage(msg).build()); new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
} }
try { try {
notification = DeviceMgtAPIUtils.getNotificationManagementService().getNotification(id); notification = DeviceMgtAPIUtils.getNotificationManagementService().getNotification(id);
@ -99,7 +98,7 @@ public class NotificationManagementServiceImpl implements NotificationManagement
} catch (NotificationManagementException e) { } catch (NotificationManagementException e) {
msg = "Notification updated successfully. But the retrial of the updated notification failed"; msg = "Notification updated successfully. But the retrial of the updated notification failed";
log.error(msg, e); log.error(msg, e);
return Response.status(Response.Status.OK).build(); return Response.status(Response.Status.OK).entity(msg).build();
} }
} }

@ -22,7 +22,6 @@ import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.eclipse.wst.common.uriresolver.internal.util.URIEncoder; import org.eclipse.wst.common.uriresolver.internal.util.URIEncoder;
import org.wso2.carbon.context.CarbonContext;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.EnrolmentInfo; import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException; import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException;
@ -86,7 +85,6 @@ public class UserManagementServiceImpl implements UserManagementService {
private static final Log log = LogFactory.getLog(UserManagementServiceImpl.class); private static final Log log = LogFactory.getLog(UserManagementServiceImpl.class);
private static final String DEFAULT_DEVICE_USER = "Internal/devicemgt-user"; private static final String DEFAULT_DEVICE_USER = "Internal/devicemgt-user";
private static final String DEFAULT_DEVICE_ADMIN = "Internal/devicemgt-admin";
// Permissions that are given for a normal device user. // Permissions that are given for a normal device user.
private static final Permission[] PERMISSIONS_FOR_DEVICE_USER = { private static final Permission[] PERMISSIONS_FOR_DEVICE_USER = {
@ -253,7 +251,11 @@ public class UserManagementServiceImpl implements UserManagementService {
log.debug("User credential of username: " + username + " has been changed"); log.debug("User credential of username: " + username + " has been changed");
} }
List<String> currentRoles = this.getFilteredRoles(userStoreManager, username); List<String> currentRoles = this.getFilteredRoles(userStoreManager, username);
List<String> newRoles = Arrays.asList(userInfo.getRoles());
List<String> newRoles = new ArrayList<>();
if (userInfo.getRoles() != null) {
newRoles = Arrays.asList(userInfo.getRoles());
}
List<String> rolesToAdd = new ArrayList<>(newRoles); List<String> rolesToAdd = new ArrayList<>(newRoles);
List<String> rolesToDelete = new ArrayList<>(); List<String> rolesToDelete = new ArrayList<>();
@ -288,7 +290,7 @@ public class UserManagementServiceImpl implements UserManagementService {
private List<String> getFilteredRoles(UserStoreManager userStoreManager, String username) private List<String> getFilteredRoles(UserStoreManager userStoreManager, String username)
throws UserStoreException { throws UserStoreException {
String[] roleListOfUser = new String[0]; String[] roleListOfUser;
roleListOfUser = userStoreManager.getRoleListOfUser(username); roleListOfUser = userStoreManager.getRoleListOfUser(username);
List<String> filteredRoles = new ArrayList<>(); List<String> filteredRoles = new ArrayList<>();
for (String role : roleListOfUser) { for (String role : roleListOfUser) {
@ -429,8 +431,8 @@ public class UserManagementServiceImpl implements UserManagementService {
public Response getUserCount() { public Response getUserCount() {
try { try {
UserStoreCountRetriever userStoreCountRetrieverService = DeviceMgtAPIUtils.getUserStoreCountRetrieverService(); UserStoreCountRetriever userStoreCountRetrieverService = DeviceMgtAPIUtils.getUserStoreCountRetrieverService();
RealmConfiguration secondaryRealmConfiguration = CarbonContext.getThreadLocalCarbonContext().getUserRealm(). RealmConfiguration secondaryRealmConfiguration = DeviceMgtAPIUtils.getUserRealm().getRealmConfiguration()
getRealmConfiguration().getSecondaryRealmConfig(); .getSecondaryRealmConfig();
if (secondaryRealmConfiguration != null) { if (secondaryRealmConfiguration != null) {
if (!secondaryRealmConfiguration.isPrimary() && !Constants.JDBC_USERSTOREMANAGER. if (!secondaryRealmConfiguration.isPrimary() && !Constants.JDBC_USERSTOREMANAGER.
@ -488,12 +490,10 @@ public class UserManagementServiceImpl implements UserManagementService {
public Response isUserExists(@QueryParam("username") String userName) { public Response isUserExists(@QueryParam("username") String userName) {
try { try {
UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager(); UserStoreManager userStoreManager = DeviceMgtAPIUtils.getUserStoreManager();
boolean userExists = false;
if (userStoreManager.isExistingUser(userName)) { if (userStoreManager.isExistingUser(userName)) {
userExists = true; return Response.status(Response.Status.OK).entity(true).build();
return Response.status(Response.Status.OK).entity(userExists).build();
} else { } else {
return Response.status(Response.Status.OK).entity(userExists).build(); return Response.status(Response.Status.OK).entity(false).build();
} }
} catch (UserStoreException e) { } catch (UserStoreException e) {
String msg = "Error while retrieving the user."; String msg = "Error while retrieving the user.";
@ -605,9 +605,7 @@ public class UserManagementServiceImpl implements UserManagementService {
DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService(); DeviceManagementProviderService dms = DeviceMgtAPIUtils.getDeviceManagementService();
try { try {
Set<String> recipients = new HashSet<>(); Set<String> recipients = new HashSet<>();
for (String recipient : enrollmentInvitation.getRecipients()) { recipients.addAll(enrollmentInvitation.getRecipients());
recipients.add(recipient);
}
Properties props = new Properties(); Properties props = new Properties();
String username = DeviceMgtAPIUtils.getAuthenticatedUser(); String username = DeviceMgtAPIUtils.getAuthenticatedUser();
String firstName = getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME); String firstName = getClaimValue(username, Constants.USER_CLAIM_FIRST_NAME);
@ -621,6 +619,8 @@ public class UserManagementServiceImpl implements UserManagementService {
} catch (DeviceManagementException e) { } catch (DeviceManagementException e) {
String msg = "Error occurred while inviting user to enrol their device"; String msg = "Error occurred while inviting user to enrol their device";
log.error(msg, e); log.error(msg, e);
return Response.serverError().entity(
new ErrorResponse.ErrorResponseBuilder().setMessage(msg).build()).build();
} catch (UserStoreException e) { } catch (UserStoreException e) {
String msg = "Error occurred while getting claim values to invite user"; String msg = "Error occurred while getting claim values to invite user";
log.error(msg, e); log.error(msg, e);

@ -0,0 +1,140 @@
/*
* 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.jaxrs.service.impl;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
import org.testng.Assert;
import org.testng.IObjectFactory;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.ObjectFactory;
import org.testng.annotations.Test;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationEntry;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfiguration;
import org.wso2.carbon.device.mgt.common.configuration.mgt.PlatformConfigurationManagementService;
import org.wso2.carbon.device.mgt.jaxrs.service.api.ConfigurationManagementService;
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
import org.wso2.carbon.policy.mgt.core.util.PolicyManagerUtil;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
/**
* This is a test class for {@link ConfigurationServiceImpl}.
*/
@PowerMockIgnore("javax.ws.rs.*")
@SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils",
"org.wso2.carbon.context.CarbonContext"})
@PrepareForTest({DeviceMgtAPIUtils.class, PolicyManagerUtil.class})
public class ConfigurationServiceImplTest {
private ConfigurationManagementService configurationManagementService;
private PlatformConfigurationManagementService platformConfigurationManagementService;
private PlatformConfiguration platformConfiguration;
@ObjectFactory
public IObjectFactory getObjectFactory() {
return new org.powermock.modules.testng.PowerMockObjectFactory();
}
@BeforeClass
public void init() {
configurationManagementService = new ConfigurationServiceImpl();
platformConfigurationManagementService = Mockito.mock(PlatformConfigurationManagementService.class);
platformConfiguration = new PlatformConfiguration();
platformConfiguration.setType("test");
}
@Test(description = "This method tests the getConfiguration method of ConfigurationManagementService under valid "
+ "conditions")
public void testGetConfigurationWithSuccessConditions() throws ConfigurationManagementException {
PowerMockito.stub(PowerMockito.method(PolicyManagerUtil.class, "getMonitoringFrequency")).toReturn(60);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getPlatformConfigurationManagementService"))
.toReturn(platformConfigurationManagementService);
Mockito.doReturn(platformConfiguration).when(platformConfigurationManagementService)
.getConfiguration(Mockito.any());
Response response = configurationManagementService.getConfiguration("test");
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"getConfiguration request " + "failed with valid parameters");
List<ConfigurationEntry> configurationEntryList = new ArrayList<>();
ConfigurationEntry configurationEntry = new ConfigurationEntry();
configurationEntry.setContentType("String");
configurationEntry.setName("test");
configurationEntry.setValue("test");
configurationEntryList.add(configurationEntry);
platformConfiguration.setConfiguration(configurationEntryList);
Mockito.reset(platformConfigurationManagementService);
Mockito.doReturn(platformConfiguration).when(platformConfigurationManagementService)
.getConfiguration(Mockito.any());
response = configurationManagementService.getConfiguration("test");
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"getConfiguration request " + "failed with valid parameters");
}
@Test(description = "This method tests the getConfiguration method under negative conditions")
public void testGetConfigurationUnderNegativeConditions() throws ConfigurationManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getPlatformConfigurationManagementService"))
.toReturn(platformConfigurationManagementService);
Mockito.reset(platformConfigurationManagementService);
Mockito.doThrow(new ConfigurationManagementException()).when(platformConfigurationManagementService)
.getConfiguration(Mockito.any());
Response response = configurationManagementService.getConfiguration("test");
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"getConfiguration request " + "succeeded under negative conditions");
}
@Test(description = "This method tests the updateConfiguration method under valid conditions.", dependsOnMethods
= {"testGetConfigurationWithSuccessConditions"})
public void testUpdateConfigurationUnderValidConditions() throws ConfigurationManagementException {
Mockito.reset(platformConfigurationManagementService);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getPlatformConfigurationManagementService"))
.toReturn(platformConfigurationManagementService);
PowerMockito
.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getNotifierFrequency", PlatformConfiguration.class))
.toReturn(60);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "scheduleTaskService", int.class))
.toReturn(null);
Mockito.doReturn(platformConfiguration).when(platformConfigurationManagementService)
.getConfiguration(Mockito.any());
Mockito.doReturn(true).when(platformConfigurationManagementService)
.saveConfiguration(Mockito.any(), Mockito.any());
Response response = configurationManagementService.updateConfiguration(platformConfiguration);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"updateConfiguration request failed with valid parameters");
}
@Test(description = "This method tests the updateConfiguration method under negative conditions.",
dependsOnMethods = {"testGetConfigurationWithSuccessConditions"})
public void testUpdateConfigurationUnderNegativeConditions() throws ConfigurationManagementException {
Mockito.reset(platformConfigurationManagementService);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getPlatformConfigurationManagementService"))
.toReturn(platformConfigurationManagementService);
Mockito.doThrow(new ConfigurationManagementException()).when(platformConfigurationManagementService)
.saveConfiguration(Mockito.any(), Mockito.any());
Response response = configurationManagementService.updateConfiguration(platformConfiguration);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"updateConfiguration request succeeded with in-valid parameters");
}
}

@ -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.jaxrs.service.impl;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
import org.testng.Assert;
import org.testng.IObjectFactory;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.ObjectFactory;
import org.testng.annotations.Test;
import org.wso2.carbon.context.CarbonContext;
import org.wso2.carbon.device.mgt.common.PaginationResult;
import org.wso2.carbon.device.mgt.common.notification.mgt.Notification;
import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementException;
import org.wso2.carbon.device.mgt.common.notification.mgt.NotificationManagementService;
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.MockitoAnnotations.initMocks;
/**
* This is a test class for {@link NotificationManagementServiceImpl}.
*/
@PowerMockIgnore("javax.ws.rs.*")
@SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils",
"org.wso2.carbon.context.CarbonContext"})
@PrepareForTest({DeviceMgtAPIUtils.class, MultitenantUtils.class, CarbonContext.class})
public class NotificationManagementServiceImplTest {
private NotificationManagementService notificationManagementService;
private org.wso2.carbon.device.mgt.jaxrs.service.api.NotificationManagementService notificationManagement;
@ObjectFactory
public IObjectFactory getObjectFactory() {
return new org.powermock.modules.testng.PowerMockObjectFactory();
}
@BeforeClass
public void setup() throws UserStoreException, NotificationManagementException {
initMocks(this);
notificationManagementService = Mockito.mock(NotificationManagementService.class);
PaginationResult paginationResult = new PaginationResult();
List<Notification> notifications = new ArrayList<>();
notifications.add(new Notification());
paginationResult.setData(notifications);
paginationResult.setRecordsTotal(1);
Mockito.doReturn(paginationResult).when(notificationManagementService).getAllNotifications(Mockito.any());
Mockito.doReturn(paginationResult).when(notificationManagementService)
.getNotificationsByStatus(Mockito.any(), Mockito.any());
notificationManagement = new NotificationManagementServiceImpl();
}
@Test(description = "This method tests the behaviour of getNotifications method under different conditions")
public void testGetNotifications() throws NotificationManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getNotificationManagementService"))
.toReturn(this.notificationManagementService);
Response response = notificationManagement.getNotifications("NEW", "test", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "Notification retrieval failed");
response = notificationManagement.getNotifications(null, "test", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "Notification retrieval failed");
Mockito.reset(this.notificationManagementService);
Mockito.doThrow(new NotificationManagementException()).when(notificationManagementService)
.getAllNotifications(Mockito.any());
response = notificationManagement.getNotifications(null, "test", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Notification retrieval succeeded with issues in NotificationManagement OSGI service");
Mockito.reset(this.notificationManagementService);
}
@Test(description = "This method tests the behaviour of updateNotificationStatus method under different conditions")
public void testUpdateNotificationStatus() throws NotificationManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getNotificationManagementService"))
.toReturn(this.notificationManagementService);
Mockito.doReturn(true).when(notificationManagementService)
.updateNotificationStatus(1, Notification.Status.CHECKED);
Mockito.doThrow(NotificationManagementException.class).when(notificationManagementService)
.updateNotificationStatus(2, Notification.Status.CHECKED);
Mockito.doReturn(true).when(notificationManagementService)
.updateNotificationStatus(3, Notification.Status.CHECKED);
Mockito.doReturn(new Notification()).when(notificationManagementService).getNotification(1);
Mockito.doThrow(new NotificationManagementException()).when(notificationManagementService).getNotification(3);
Response response = notificationManagement.updateNotificationStatus(1);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Notification status update failed under correct conditions");
response = notificationManagement.updateNotificationStatus(2);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Notification status update succeeded under erroneous conditions");
response = notificationManagement.updateNotificationStatus(3);
Assert.assertEquals(response.getEntity(),
"Notification updated successfully. But the retrial of the updated " + "notification failed",
"Notification status update succeeded under erroneous conditions");
}
}

@ -0,0 +1,384 @@
/*
* 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.jaxrs.service.impl;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
import org.testng.Assert;
import org.testng.IObjectFactory;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.ObjectFactory;
import org.testng.annotations.Test;
import org.wso2.carbon.context.CarbonContext;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.configuration.mgt.ConfigurationManagementException;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
import org.wso2.carbon.device.mgt.jaxrs.beans.BasicUserInfo;
import org.wso2.carbon.device.mgt.jaxrs.beans.EnrollmentInvitation;
import org.wso2.carbon.device.mgt.jaxrs.beans.UserInfo;
import org.wso2.carbon.device.mgt.jaxrs.service.api.UserManagementService;
import org.wso2.carbon.device.mgt.jaxrs.util.Constants;
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
import org.wso2.carbon.user.api.RealmConfiguration;
import org.wso2.carbon.user.api.UserRealm;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.user.api.UserStoreManager;
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
import javax.ws.rs.core.Response;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.MockitoAnnotations.initMocks;
/**
* This is a test case for {@link UserManagementService}.
*/
@PowerMockIgnore("javax.ws.rs.*")
@SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils",
"org.wso2.carbon.context.CarbonContext"})
@PrepareForTest({DeviceMgtAPIUtils.class, MultitenantUtils.class, CarbonContext.class})
public class UserManagementServiceImplTest {
private UserStoreManager userStoreManager;
private UserManagementService userManagementService;
private DeviceManagementProviderService deviceManagementProviderService;
private static final String DEFAULT_DEVICE_USER = "Internal/devicemgt-user";
private UserRealm userRealm;
private EnrollmentInvitation enrollmentInvitation;
private List<String> userList;
private static final String TEST_USERNAME = "test";
private static final String TEST2_USERNAME = "test2";
private static final String TEST3_USERNAME = "test3";
@ObjectFactory
public IObjectFactory getObjectFactory() {
return new org.powermock.modules.testng.PowerMockObjectFactory();
}
@BeforeClass
public void setup() throws UserStoreException {
initMocks(this);
userManagementService = new UserManagementServiceImpl();
userStoreManager = Mockito.mock(UserStoreManager.class, Mockito.RETURNS_MOCKS);
deviceManagementProviderService = Mockito
.mock(DeviceManagementProviderServiceImpl.class, Mockito.CALLS_REAL_METHODS);
userRealm = Mockito.mock(UserRealm.class);
RealmConfiguration realmConfiguration = Mockito.mock(RealmConfiguration.class);
Mockito.doReturn(null).when(realmConfiguration).getSecondaryRealmConfig();
Mockito.doReturn(realmConfiguration).when(userRealm).getRealmConfiguration();
enrollmentInvitation = new EnrollmentInvitation();
List<String> recipients = new ArrayList<>();
recipients.add(TEST_USERNAME);
enrollmentInvitation.setDeviceType("android");
enrollmentInvitation.setRecipients(recipients);
userList = new ArrayList<>();
userList.add(TEST_USERNAME);
}
@Test(description = "This method tests the addUser method of UserManagementService")
public void testAddUser() throws UserStoreException, ConfigurationManagementException, DeviceManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
Mockito.doReturn(true).when(userStoreManager).isExistingUser("admin");
Mockito.doAnswer(new Answer() {
private int count = 0;
public Object answer(InvocationOnMock invocation) {
if (count == 0) {
count++;
return false;
} else {
return true;
}
}
}).when(userStoreManager).isExistingUser(TEST_USERNAME);
Mockito.doReturn("test@test.com").when(userStoreManager)
.getUserClaimValue(TEST_USERNAME, Constants.USER_CLAIM_EMAIL_ADDRESS, null);
Mockito.doReturn(TEST_USERNAME).when(userStoreManager)
.getUserClaimValue(TEST_USERNAME, Constants.USER_CLAIM_FIRST_NAME, null);
Mockito.doReturn(TEST_USERNAME).when(userStoreManager)
.getUserClaimValue(TEST_USERNAME, Constants.USER_CLAIM_LAST_NAME, null);
Mockito.doNothing().when(userStoreManager)
.addUser(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
UserInfo userInfo = new UserInfo();
userInfo.setUsername("admin");
Response response = userManagementService.addUser(userInfo);
Assert.assertEquals(response.getStatus(), Response.Status.CONFLICT.getStatusCode(),
"Same user can be added " + "twice");
userInfo = getUserInfo();
Mockito.doReturn(true).when(userStoreManager).isExistingRole(DEFAULT_DEVICE_USER);
Mockito.doNothing().when(deviceManagementProviderService).sendRegistrationEmail(Mockito.any());
response = userManagementService.addUser(userInfo);
Assert.assertEquals(response.getStatus(), Response.Status.CREATED.getStatusCode(), "User addition failed");
}
@Test(description = "This method tests the getUser method of UserManagementService", dependsOnMethods =
"testAddUser")
public void testGetUser() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Response response = userManagementService.getUser(TEST_USERNAME, null, null);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "User retrieval failed");
BasicUserInfo userInfo = (BasicUserInfo) response.getEntity();
Assert.assertEquals(userInfo.getFirstname(), TEST_USERNAME,
"Retrieved user object is different from the original one " + "saved");
Mockito.doReturn(false).when(userStoreManager).isExistingUser(TEST2_USERNAME);
response = userManagementService.getUser(TEST2_USERNAME, null, null);
Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
"Non-existing user was retrieved successfully");
}
@Test(description = "This method tests the updateUser method of UserManagementService", dependsOnMethods =
{"testGetUser"})
public void testUpdateUser() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Response response = userManagementService.updateUser(TEST2_USERNAME, null, null);
Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
"Non-existing user was successfully updated");
String[] roles = { "Internal/everyone", DEFAULT_DEVICE_USER };
Mockito.doReturn(roles).when(userStoreManager).getRoleListOfUser(TEST_USERNAME);
Mockito.doNothing().when(userStoreManager).updateRoleListOfUser(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doNothing().when(userStoreManager).setUserClaimValues(Mockito.any(), Mockito.any(), Mockito.any());
response = userManagementService.updateUser(TEST_USERNAME, null, getUserInfo());
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "Updating the user info failed");
}
@Test(description = "This method tests the getRolesOfUser method of UserManagementService", dependsOnMethods =
{"testUpdateUser"})
public void testGetRolesOfUser() {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Response response = userManagementService.getRolesOfUser(TEST2_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
"Roles of a non-existing user was successfully retrieved");
response = userManagementService.getRolesOfUser(TEST_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Retrieval of roles of a existing user failed.");
}
@Test(description = "This method tests the IsUserExists method of UserManagementService", dependsOnMethods =
{"testGetRolesOfUser"})
public void testIsUserExists() {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Response response = userManagementService.isUserExists(TEST2_USERNAME);
boolean responseEntity = (boolean) response.getEntity();
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Check for existence of user failed");
Assert.assertFalse(responseEntity, "Non-existing user is identified as already existing user");
response = userManagementService.isUserExists(TEST_USERNAME);
responseEntity = (boolean) response.getEntity();
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Check for existence of user failed");
Assert.assertTrue(responseEntity, "Existing user is identified as non-existing user");
}
@Test(description = "This method tests the send invitation method of UserManagementService", dependsOnMethods =
{"testIsUserExists"})
public void testSendInvitation() throws ConfigurationManagementException, DeviceManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
Mockito.doNothing().when(deviceManagementProviderService).sendEnrolmentInvitation(Mockito.any(), Mockito.any());
Response response = userManagementService.inviteExistingUsersToEnrollDevice(userList);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Inviting existing users to enroll device failed");
}
@Test(description = "This method tests the getUserNames method of UserManagementService", dependsOnMethods =
{"testSendInvitation"})
public void testGetUserNames() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Mockito.doReturn(new String[] { TEST_USERNAME }).when(userStoreManager)
.listUsers(Mockito.anyString(), Mockito.anyInt());
Response response = userManagementService.getUserNames(TEST_USERNAME, null, "00", 0, 0);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Getting user names is failed for a valid request");
}
@Test(description = "This method tests the getUsers method of UserManagementService",
dependsOnMethods = {"testGetUserNames"})
public void testGetUsers() {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(userStoreManager);
Response response = userManagementService.getUsers(null, "00", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "GetUsers request failed");
}
@Test(description = "This method tests the inviteToEnrollDevice method of UserManagementService",
dependsOnMethods = "testGetUsers")
public void testInviteToEnrollDevice() {
URL resourceUrl = ClassLoader.getSystemResource("testng.xml");
System.setProperty("carbon.home", resourceUrl.getPath());
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getAuthenticatedUser")).toReturn(TEST_USERNAME);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
EnrollmentInvitation enrollmentInvitation = new EnrollmentInvitation();
List<String> recipients = new ArrayList<>();
recipients.add(TEST_USERNAME);
enrollmentInvitation.setDeviceType("android");
enrollmentInvitation.setRecipients(recipients);
Response response = userManagementService.inviteToEnrollDevice(enrollmentInvitation);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Inviting users to enroll device failed");
}
@Test(description = "This method tests the removeUser method of UserManagementService", dependsOnMethods =
"testInviteToEnrollDevice")
public void testRemoveUser() throws DeviceManagementException, UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
Mockito.doReturn(true).when(deviceManagementProviderService).setStatus(Mockito.anyString(), Mockito.any());
Mockito.doNothing().when(userStoreManager).deleteUser(Mockito.anyString());
Response response = userManagementService.removeUser(TEST_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
"Cannot remove user, the request failed");
response = userManagementService.removeUser(TEST2_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
"Successfully removed non-existing user");
}
@Test(description = "This method tests the behaviour of getUserCount method of UserManagementService",
dependsOnMethods = {"testRemoveUser"})
public void testGetUserCount() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserRealm")).toReturn(userRealm);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreCountRetrieverService"))
.toReturn(null);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Response response = userManagementService.getUserCount();
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "User count retrieval failed");
}
@Test(description = "This method tests the behaviour of methods when there is an issue with "
+ "DeviceManagementProviderService", dependsOnMethods = {"testGetUserCount"})
public void testNegativeScenarios1() throws ConfigurationManagementException, DeviceManagementException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getAuthenticatedUser")).toReturn(TEST_USERNAME);
Mockito.reset(deviceManagementProviderService);
Mockito.doThrow(new DeviceManagementException()).when(deviceManagementProviderService)
.sendEnrolmentInvitation(Mockito.any(), Mockito.any());
Response response = userManagementService.inviteExistingUsersToEnrollDevice(userList);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Invite existing users to enroll device succeeded under erroneous conditions");
response = userManagementService.inviteToEnrollDevice(enrollmentInvitation);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Invite existing users to enroll device succeeded under erroneous conditions");
}
@Test(description = "This method tests the behaviour of the different methods when there is an issue is "
+ "userStoreManager", dependsOnMethods = {"testNegativeScenarios1"})
public void testNegativeScenarios2() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
Mockito.doThrow(new UserStoreException()).when(userStoreManager).isExistingUser(TEST3_USERNAME);
Response response = userManagementService.getUser(TEST3_USERNAME, null, null);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user retrieval with problematic inputs");
UserInfo userInfo = new UserInfo();
userInfo.setUsername(TEST3_USERNAME);
response = userManagementService.addUser(userInfo);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user addition with problematic inputs");
response = userManagementService.updateUser(TEST3_USERNAME, null, userInfo);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user updating request with problematic inputs");
response = userManagementService.removeUser(TEST3_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user removal request with problematic inputs");
response = userManagementService.getRolesOfUser(TEST3_USERNAME, null);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user role retrieval request with problematic inputs");
response = userManagementService.isUserExists(TEST3_USERNAME);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for checking existence of user under problematic conditions");
}
@Test(description = "This method tests the behaviour of various methods when there is an issue with UserStore "
+ "Manager", dependsOnMethods = {"testNegativeScenarios2"})
public void testNegativeScenarios3() throws UserStoreException {
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreManager"))
.toReturn(this.userStoreManager);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserRealm")).toReturn(userRealm);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getUserStoreCountRetrieverService"))
.toReturn(null);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getAuthenticatedUser")).toReturn(TEST_USERNAME);
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
.toReturn(this.deviceManagementProviderService);
Mockito.reset(this.userStoreManager);
Mockito.doThrow(new UserStoreException()).when(userStoreManager)
.getUserClaimValue(Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doThrow(new UserStoreException()).when(userStoreManager)
.listUsers(Mockito.anyString(), Mockito.anyInt());
Response response = userManagementService.getUsers(TEST_USERNAME, "00", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a users retrieval request.");
response = userManagementService.getUserCount();
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user count retrieval request.");
response = userManagementService.getUserNames(TEST_USERNAME, null, "00", 0, 10);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Response returned successful for a user count retrieval request.");
response = userManagementService.inviteToEnrollDevice(enrollmentInvitation);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Invite existing users to enroll device succeeded under erroneous conditions");
response = userManagementService.inviteExistingUsersToEnrollDevice(userList);
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
"Invite existing users to enroll device succeeded under erroneous conditions");
}
/**
* To get the user info of a user
*
* @return UserInfo of the User.
*/
private UserInfo getUserInfo() {
UserInfo userInfo = new UserInfo();
userInfo.setUsername(TEST_USERNAME);
userInfo.setFirstname(TEST_USERNAME);
userInfo.setLastname(TEST_USERNAME);
userInfo.setEmailAddress("test@test.com");
return userInfo;
}
}

@ -28,6 +28,9 @@
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementServiceTest"/> <class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementServiceTest"/>
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementAdminServiceTest"/> <class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementAdminServiceTest"/>
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceAgentServiceTest"/> <class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceAgentServiceTest"/>
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.UserManagementServiceImplTest"/>
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.NotificationManagementServiceImplTest"/>
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.ConfigurationServiceImplTest"/>
</classes> </classes>
</test> </test>
</suite> </suite>

@ -66,11 +66,8 @@ import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory; import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
import org.wso2.carbon.device.mgt.core.dao.DeviceTypeDAO; import org.wso2.carbon.device.mgt.core.dao.DeviceTypeDAO;
import org.wso2.carbon.device.mgt.core.dao.EnrollmentDAO; import org.wso2.carbon.device.mgt.core.dao.EnrollmentDAO;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceDetailsMgtException;
import org.wso2.carbon.device.mgt.core.device.details.mgt.DeviceInformationManager;
import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsDAO; import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsDAO;
import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsMgtDAOException; import org.wso2.carbon.device.mgt.core.device.details.mgt.dao.DeviceDetailsMgtDAOException;
import org.wso2.carbon.device.mgt.core.device.details.mgt.impl.DeviceInformationManagerImpl;
import org.wso2.carbon.device.mgt.core.dto.DeviceType; import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier; import org.wso2.carbon.device.mgt.core.dto.DeviceTypeServiceIdentifier;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder; import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
@ -250,7 +247,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
} }
} else { } else {
int enrolmentId = 0; int enrolmentId;
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceType type = deviceTypeDAO.getDeviceType(device.getType(), tenantId); DeviceType type = deviceTypeDAO.getDeviceType(device.getType(), tenantId);
@ -363,7 +360,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Get enrollments for user '" + user + "' device: " + deviceId); log.debug("Get enrollments for user '" + user + "' device: " + deviceId);
} }
List<EnrolmentInfo> enrolmentInfos = new ArrayList<>(); List<EnrolmentInfo> enrolmentInfos;
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
enrolmentInfos = enrollmentDAO.getEnrollmentsOfUser(deviceId, user, this.getTenantId()); enrolmentInfos = enrollmentDAO.getEnrollmentsOfUser(deviceId, user, this.getTenantId());
@ -453,10 +450,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
@Override @Override
public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException { public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
Device device = this.getDevice(deviceId, false); Device device = this.getDevice(deviceId, false);
if (device != null) { return device != null;
return true;
}
return false;
} }
@Override @Override
@ -627,8 +621,8 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
+ requireDeviceInfo); + requireDeviceInfo);
} }
PaginationResult paginationResult = new PaginationResult(); PaginationResult paginationResult = new PaginationResult();
List<Device> allDevices = new ArrayList<>(); List<Device> allDevices;
int count = 0; int count;
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
String deviceType = request.getDeviceType(); String deviceType = request.getDeviceType();
request = DeviceManagerUtil.validateDeviceListPageSize(request); request = DeviceManagerUtil.validateDeviceListPageSize(request);
@ -679,9 +673,9 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Get devices with pagination " + request.toString() + " and requiredDeviceInfo: " + requireDeviceInfo); log.debug("Get devices with pagination " + request.toString() + " and requiredDeviceInfo: " + requireDeviceInfo);
} }
List<Device> devicesForRoles = null; List<Device> devicesForRoles;
PaginationResult paginationResult = new PaginationResult(); PaginationResult paginationResult = new PaginationResult();
List<Device> allDevices = new ArrayList<>(); List<Device> allDevices;
int count = 0; int count = 0;
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
request = DeviceManagerUtil.validateDeviceListPageSize(request); request = DeviceManagerUtil.validateDeviceListPageSize(request);
@ -785,7 +779,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
" and owner '" + owner + "' and requiredDeviceInfo: " + requireDeviceInfo); " and owner '" + owner + "' and requiredDeviceInfo: " + requireDeviceInfo);
} }
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
Device device = null; Device device;
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
device = deviceDAO.getDevice(deviceId, owner, tenantId); device = deviceDAO.getDevice(deviceId, owner, tenantId);
@ -835,12 +829,12 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
Enumeration e = props.propertyNames(); Enumeration e = props.propertyNames();
while (e.hasMoreElements()) { while (e.hasMoreElements()) {
String key = (String) e.nextElement(); String key = (String) e.nextElement();
params.put(key, new TypedValue<Class<?>, Object>(String.class, props.getProperty(key))); params.put(key, new TypedValue<>(String.class, props.getProperty(key)));
} }
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTPS, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTPS,
new TypedValue<Class<?>, Object>(String.class, DeviceManagerUtil.getServerBaseHttpsUrl())); new TypedValue<>(String.class, DeviceManagerUtil.getServerBaseHttpsUrl()));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTP, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTP,
new TypedValue<Class<?>, Object>(String.class, DeviceManagerUtil.getServerBaseHttpUrl())); new TypedValue<>(String.class, DeviceManagerUtil.getServerBaseHttpUrl()));
try { try {
EmailContext ctx = EmailContext ctx =
new EmailContext.EmailContextBuilder(new ContentProviderInfo(templateName, params), new EmailContext.EmailContextBuilder(new ContentProviderInfo(templateName, params),
@ -875,17 +869,17 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
if (emailSenderService != null) { if (emailSenderService != null) {
Map<String, TypedValue<Class<?>, Object>> params = new HashMap<>(); Map<String, TypedValue<Class<?>, Object>> params = new HashMap<>();
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.FIRST_NAME, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.FIRST_NAME,
new TypedValue<Class<?>, Object>(String.class, metaInfo.getProperty("first-name"))); new TypedValue<>(String.class, metaInfo.getProperty("first-name")));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.USERNAME, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.USERNAME,
new TypedValue<Class<?>, Object>(String.class, metaInfo.getProperty("username"))); new TypedValue<>(String.class, metaInfo.getProperty("username")));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.PASSWORD, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.PASSWORD,
new TypedValue<Class<?>, Object>(String.class, metaInfo.getProperty("password"))); new TypedValue<>(String.class, metaInfo.getProperty("password")));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.DOMAIN, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.DOMAIN,
new TypedValue<Class<?>, Object>(String.class, metaInfo.getProperty("domain"))); new TypedValue<>(String.class, metaInfo.getProperty("domain")));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTPS, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTPS,
new TypedValue<Class<?>, Object>(String.class, DeviceManagerUtil.getServerBaseHttpsUrl())); new TypedValue<>(String.class, DeviceManagerUtil.getServerBaseHttpsUrl()));
params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTP, params.put(org.wso2.carbon.device.mgt.core.DeviceManagementConstants.EmailAttributes.SERVER_BASE_URL_HTTP,
new TypedValue<Class<?>, Object>(String.class, DeviceManagerUtil.getServerBaseHttpUrl())); new TypedValue<>(String.class, DeviceManagerUtil.getServerBaseHttpUrl()));
try { try {
EmailContext ctx = EmailContext ctx =
new EmailContext.EmailContextBuilder( new EmailContext.EmailContextBuilder(
@ -1284,7 +1278,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
log.debug("Update enrollment with status"); log.debug("Update enrollment with status");
} }
try { try {
boolean success = false; boolean success;
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
success = enrollmentDAO.setStatus(currentOwner, status, tenantId); success = enrollmentDAO.setStatus(currentOwner, status, tenantId);
@ -1607,10 +1601,10 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
+ requireDeviceInfo); + requireDeviceInfo);
} }
PaginationResult result = new PaginationResult(); PaginationResult result = new PaginationResult();
int deviceCount = 0; int deviceCount;
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
String username = request.getOwner(); String username = request.getOwner();
List<Device> userDevices = new ArrayList<>(); List<Device> userDevices;
request = DeviceManagerUtil.validateDeviceListPageSize(request); request = DeviceManagerUtil.validateDeviceListPageSize(request);
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
@ -1662,7 +1656,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
PaginationResult result = new PaginationResult(); PaginationResult result = new PaginationResult();
List<Device> allDevices; List<Device> allDevices;
int deviceCount = 0; int deviceCount;
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
String ownerShip = request.getOwnership(); String ownerShip = request.getOwnership();
request = DeviceManagerUtil.validateDeviceListPageSize(request); request = DeviceManagerUtil.validateDeviceListPageSize(request);
@ -1729,7 +1723,6 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
List<Device> userDevices; List<Device> userDevices;
for (String user : users) { for (String user : users) {
userDevices = new ArrayList<>();
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
userDevices = deviceDAO.getDevicesOfUser(user, tenantId); userDevices = deviceDAO.getDevicesOfUser(user, tenantId);
@ -1865,7 +1858,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
PaginationResult result = new PaginationResult(); PaginationResult result = new PaginationResult();
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
List<Device> allDevices = new ArrayList<>(); List<Device> allDevices;
String deviceName = request.getDeviceName(); String deviceName = request.getDeviceName();
request = DeviceManagerUtil.validateDeviceListPageSize(request); request = DeviceManagerUtil.validateDeviceListPageSize(request);
try { try {
@ -2019,10 +2012,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
@Override @Override
public boolean isEnrolled(DeviceIdentifier deviceId, String user) throws DeviceManagementException { public boolean isEnrolled(DeviceIdentifier deviceId, String user) throws DeviceManagementException {
Device device = this.getDevice(deviceId, false); Device device = this.getDevice(deviceId, false);
if (device != null && device.getEnrolmentInfo() != null && device.getEnrolmentInfo().getOwner().equals(user)) { return device != null && device.getEnrolmentInfo() != null && device.getEnrolmentInfo().getOwner().equals(user);
return true;
}
return false;
} }
@Override @Override
@ -2056,7 +2046,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
log.debug("Change device status of device: " + deviceIdentifier.getId() + " of type '" log.debug("Change device status of device: " + deviceIdentifier.getId() + " of type '"
+ deviceIdentifier.getType() + "'"); + deviceIdentifier.getType() + "'");
} }
boolean isDeviceUpdated = false; boolean isDeviceUpdated;
Device device = getDevice(deviceIdentifier, false); Device device = getDevice(deviceIdentifier, false);
int deviceId = device.getId(); int deviceId = device.getId();
EnrolmentInfo enrolmentInfo = device.getEnrolmentInfo(); EnrolmentInfo enrolmentInfo = device.getEnrolmentInfo();
@ -2251,7 +2241,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
* @param service {@link GroupManagementProviderService} instance. * @param service {@link GroupManagementProviderService} instance.
* @param groupName of the group to create. * @param groupName of the group to create.
* @return Group with details. * @return Group with details.
* @throws GroupManagementException * @throws GroupManagementException Group Management Exception
*/ */
private DeviceGroup createDefaultGroup(GroupManagementProviderService service, String groupName) private DeviceGroup createDefaultGroup(GroupManagementProviderService service, String groupName)
throws GroupManagementException { throws GroupManagementException {
@ -2460,27 +2450,25 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
log.debug("Get all device info of devices, num of devices: " + allDevices.size()); log.debug("Get all device info of devices, num of devices: " + allDevices.size());
} }
List<Device> devices = new ArrayList<>(); List<Device> devices = new ArrayList<>();
if (allDevices != null) { for (Device device : allDevices) {
for (Device device : allDevices) { device.setDeviceInfo(this.getDeviceInfo(device));
device.setDeviceInfo(this.getDeviceInfo(device)); device.setApplications(this.getInstalledApplications(device));
device.setApplications(this.getInstalledApplications(device)); DeviceManager deviceManager = this.getDeviceManager(device.getType());
DeviceManager deviceManager = this.getDeviceManager(device.getType()); if (deviceManager == null) {
if (deviceManager == null) { if (log.isDebugEnabled()) {
if (log.isDebugEnabled()) { log.debug("Device Manager associated with the device type '" + device.getType() + "' is null. " +
log.debug("Device Manager associated with the device type '" + device.getType() + "' is null. " + "Therefore, not attempting method 'isEnrolled'");
"Therefore, not attempting method 'isEnrolled'");
}
devices.add(device);
continue;
}
Device dmsDevice =
deviceManager.getDevice(new DeviceIdentifier(device.getDeviceIdentifier(), device.getType()));
if (dmsDevice != null) {
device.setFeatures(dmsDevice.getFeatures());
device.setProperties(dmsDevice.getProperties());
} }
devices.add(device); devices.add(device);
continue;
}
Device dmsDevice =
deviceManager.getDevice(new DeviceIdentifier(device.getDeviceIdentifier(), device.getType()));
if (dmsDevice != null) {
device.setFeatures(dmsDevice.getFeatures());
device.setProperties(dmsDevice.getProperties());
} }
devices.add(device);
} }
return devices; return devices;
} }

Loading…
Cancel
Save