forked from community/device-mgt-core
Merge branch 'master' of https://github.com/wso2/carbon-device-mgt
GDLMadushanka
7 years ago
commit
520529f474
@ -1,38 +1,10 @@
|
||||
package org.wso2.carbon.apimgt.webapp.publisher.config;
|
||||
|
||||
public class APIResourceManagementException extends Exception{
|
||||
public class APIResourceManagementException extends Exception {
|
||||
private static final long serialVersionUID = -3151279311929070297L;
|
||||
|
||||
private String errorMessage;
|
||||
|
||||
public String getErrorMessage() {
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
public void setErrorMessage(String errorMessage) {
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public APIResourceManagementException(String msg, Exception nestedEx) {
|
||||
super(msg, nestedEx);
|
||||
setErrorMessage(msg);
|
||||
}
|
||||
|
||||
public APIResourceManagementException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
setErrorMessage(message);
|
||||
}
|
||||
|
||||
public APIResourceManagementException(String msg) {
|
||||
super(msg);
|
||||
setErrorMessage(msg);
|
||||
}
|
||||
|
||||
public APIResourceManagementException() {
|
||||
super();
|
||||
}
|
||||
|
||||
public APIResourceManagementException(Throwable cause) {
|
||||
super(cause);
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,48 @@
|
||||
/*
|
||||
* 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.apimgt.webapp.publisher.utils;
|
||||
|
||||
import org.wso2.carbon.apimgt.webapp.publisher.APIConfig;
|
||||
import org.wso2.carbon.apimgt.webapp.publisher.dto.ApiScope;
|
||||
import org.wso2.carbon.apimgt.webapp.publisher.dto.ApiUriTemplate;
|
||||
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* Contains util methods for webAppPublisher tests.
|
||||
*/
|
||||
public class TestUtils {
|
||||
|
||||
public void setAPIURITemplates(APIConfig apiConfig, String uriTemplate) {
|
||||
Set<ApiUriTemplate> uriTemplates = new LinkedHashSet<>();
|
||||
ApiUriTemplate template = new ApiUriTemplate();
|
||||
template.setAuthType("Application & Application User");
|
||||
template.setHttpVerb("POST");
|
||||
template.setResourceURI("https://localhost:9443/api/device-mgt/windows/v1.0/admin/devices/reboot");
|
||||
template.setUriTemplate(uriTemplate);
|
||||
ApiScope scope = new ApiScope();
|
||||
scope.setKey("perm:windows:reboot");
|
||||
scope.setName("Reboot");
|
||||
scope.setRoles("/permission/admin/device-mgt/devices/owning-device/operations/windows/reboot");
|
||||
scope.setDescription("Lock reset on Windows devices");
|
||||
template.setScope(scope);
|
||||
uriTemplates.add(template);
|
||||
apiConfig.setUriTemplates(uriTemplates);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,315 @@
|
||||
/*
|
||||
* 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.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
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.DeviceIdentifier;
|
||||
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
|
||||
import org.wso2.carbon.device.mgt.common.PaginationRequest;
|
||||
import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationException;
|
||||
import org.wso2.carbon.device.mgt.common.authorization.DeviceAccessAuthorizationService;
|
||||
import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
|
||||
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.service.api.DeviceManagementService;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
|
||||
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
|
||||
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
import java.util.UUID;
|
||||
import javax.ws.rs.core.Response;
|
||||
|
||||
import static org.mockito.MockitoAnnotations.initMocks;
|
||||
|
||||
/**
|
||||
* This class includes unit tests for testing the functionality of {@link DeviceManagementServiceImpl}
|
||||
*/
|
||||
@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 DeviceManagementServiceImplTest {
|
||||
|
||||
private static final Log log = LogFactory.getLog(DeviceManagementServiceImplTest.class);
|
||||
private static final String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
|
||||
private static final String TEST_DEVICE_NAME = "TEST-DEVICE";
|
||||
private static final String DEFAULT_USERNAME = "admin";
|
||||
private static final String TENANT_AWARE_USERNAME = "admin@carbon.super";
|
||||
private static final String DEFAULT_ROLE = "admin";
|
||||
private static final String DEFAULT_OWNERSHIP = "BYOD";
|
||||
private static final String DEFAULT_STATUS = "ACTIVE";
|
||||
private static final String DEFAULT_DATE_FORMAT = "EEE, d MMM yyyy HH:mm:ss Z";
|
||||
private DeviceManagementService deviceManagementService;
|
||||
private DeviceAccessAuthorizationService deviceAccessAuthorizationService;
|
||||
private DeviceManagementProviderService deviceManagementProviderService;
|
||||
|
||||
@ObjectFactory
|
||||
public IObjectFactory getObjectFactory() {
|
||||
return new org.powermock.modules.testng.PowerMockObjectFactory();
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public void init() throws Exception {
|
||||
log.info("Initializing DeviceManagementServiceImpl tests");
|
||||
initMocks(this);
|
||||
this.deviceManagementProviderService = Mockito
|
||||
.mock(DeviceManagementProviderServiceImpl.class, Mockito.RETURNS_MOCKS);
|
||||
this.deviceManagementService = new DeviceManagementServiceImpl();
|
||||
this.deviceAccessAuthorizationService = Mockito.mock(DeviceAccessAuthorizationServiceImpl.class);
|
||||
}
|
||||
|
||||
@Test(description = "Testing if the device is enrolled when the device is enrolled.")
|
||||
public void testIsEnrolledWhenDeviceIsEnrolled() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.isEnrolled(Mockito.any(DeviceIdentifier.class)))
|
||||
.thenReturn(true);
|
||||
Response response = this.deviceManagementService.isEnrolled(TEST_DEVICE_TYPE, UUID.randomUUID().toString());
|
||||
Assert.assertNotNull(response);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
Mockito.reset(this.deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing if the device is enrolled when the device is not enrolled.",
|
||||
dependsOnMethods = "testIsEnrolledWhenDeviceIsEnrolled")
|
||||
public void testIsEnrolledWhenDeviceIsNotEnrolled() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.isEnrolled(Mockito.any(DeviceIdentifier.class)))
|
||||
.thenReturn(false);
|
||||
Response response = this.deviceManagementService.isEnrolled(TEST_DEVICE_TYPE, UUID.randomUUID().toString());
|
||||
Assert.assertNotNull(response);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.NO_CONTENT.getStatusCode());
|
||||
Mockito.reset(this.deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing if the device enrolled api when exception occurred.",
|
||||
dependsOnMethods = "testIsEnrolledWhenDeviceIsNotEnrolled")
|
||||
public void testIsEnrolledError() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.isEnrolled(Mockito.any(DeviceIdentifier.class)))
|
||||
.thenThrow(new DeviceManagementException());
|
||||
Response response = this.deviceManagementService.isEnrolled(TEST_DEVICE_TYPE, UUID.randomUUID().toString());
|
||||
Assert.assertNotNull(response);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
|
||||
Mockito.reset(this.deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when request exists both name and role.")
|
||||
public void testGetDevicesWhenBothNameAndRoleAvailable() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(TEST_DEVICE_NAME, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices with correct request.")
|
||||
public void testGetDevices() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(TEST_DEVICE_NAME, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, null, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(TEST_DEVICE_NAME, TEST_DEVICE_TYPE, null, null, null, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(TEST_DEVICE_NAME, TEST_DEVICE_TYPE, null, null, null, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, true, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when DeviceAccessAuthorizationService is not available")
|
||||
public void testGetDevicesWithErroneousDeviceAccessAuthorizationService() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(null);
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when user is the device admin")
|
||||
public void testGetDevicesWhenUserIsAdmin() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
Mockito.when(deviceAccessAuthorizationService.isDeviceAdminUser()).thenReturn(true);
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, null, DEFAULT_USERNAME, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when user is unauthorized.")
|
||||
public void testGetDevicesWhenUserIsUnauthorized() throws Exception {
|
||||
PowerMockito.spy(MultitenantUtils.class);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
PowerMockito.doReturn(TENANT_AWARE_USERNAME)
|
||||
.when(MultitenantUtils.class, "getTenantAwareUsername", DEFAULT_USERNAME);
|
||||
PowerMockito.doReturn("newuser@carbon.super").when(MultitenantUtils.class, "getTenantAwareUsername", "newuser");
|
||||
Mockito.when(this.deviceAccessAuthorizationService.isDeviceAdminUser()).thenReturn(false);
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, "newuser", null, DEFAULT_ROLE, DEFAULT_OWNERSHIP, DEFAULT_STATUS, 1,
|
||||
null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode());
|
||||
Mockito.reset(this.deviceAccessAuthorizationService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices with IF-Modified-Since")
|
||||
public void testGetDevicesWithModifiedSince() throws Exception {
|
||||
String ifModifiedSince = new SimpleDateFormat(DEFAULT_DATE_FORMAT).format(new Date());
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, ifModifiedSince, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.NOT_MODIFIED.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, ifModifiedSince, true, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.NOT_MODIFIED.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, "ErrorModifiedSince", false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices with Since")
|
||||
public void testGetDevicesWithSince() throws Exception {
|
||||
String since = new SimpleDateFormat(DEFAULT_DATE_FORMAT).format(new Date());
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, since, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, since, null, true, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode());
|
||||
response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, "ErrorSince", null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when unable to retrieve devices")
|
||||
public void testGetDeviceServerErrorWhenGettingDeviceList() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
Mockito.when(this.deviceManagementProviderService.getAllDevices(Mockito.any(PaginationRequest.class), Mockito.anyBoolean()))
|
||||
.thenThrow(new DeviceManagementException());
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
|
||||
Mockito.reset(this.deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing get devices when unable to check if the user is the admin user")
|
||||
public void testGetDevicesServerErrorWhenCheckingAdminUser() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceAccessAuthorizationService"))
|
||||
.toReturn(this.deviceAccessAuthorizationService);
|
||||
PowerMockito.stub(PowerMockito.method(MultitenantUtils.class, "getTenantAwareUsername"))
|
||||
.toReturn(TENANT_AWARE_USERNAME);
|
||||
PowerMockito.stub(PowerMockito.method(CarbonContext.class, "getThreadLocalCarbonContext"))
|
||||
.toReturn(Mockito.mock(CarbonContext.class, Mockito.RETURNS_MOCKS));
|
||||
Mockito.when(this.deviceAccessAuthorizationService.isDeviceAdminUser())
|
||||
.thenThrow(new DeviceAccessAuthorizationException());
|
||||
|
||||
Response response = this.deviceManagementService
|
||||
.getDevices(null, TEST_DEVICE_TYPE, DEFAULT_USERNAME, null, DEFAULT_ROLE, DEFAULT_OWNERSHIP,
|
||||
DEFAULT_STATUS, 1, null, null, false, 10, 5);
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode());
|
||||
Mockito.reset(this.deviceAccessAuthorizationService);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,252 @@
|
||||
/*
|
||||
* 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.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
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.DeviceManagementException;
|
||||
import org.wso2.carbon.device.mgt.common.spi.DeviceTypeGeneratorService;
|
||||
import org.wso2.carbon.device.mgt.core.dto.DeviceType;
|
||||
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
|
||||
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.extensions.device.type.template.DeviceTypeGeneratorServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.service.api.admin.DeviceTypeManagementAdminService;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.service.impl.admin.DeviceTypeManagementAdminServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.service.impl.util.DeviceMgtAPITestHelper;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
|
||||
|
||||
import javax.ws.rs.core.Response;
|
||||
|
||||
import static org.mockito.MockitoAnnotations.initMocks;
|
||||
|
||||
/**
|
||||
* This class holds the unit tests for the class {@link DeviceTypeManagementAdminService}
|
||||
*/
|
||||
@PowerMockIgnore("javax.ws.rs.*")
|
||||
@SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils"})
|
||||
@PrepareForTest({DeviceMgtAPIUtils.class, DeviceManagementProviderService.class})
|
||||
public class DeviceTypeManagementAdminServiceTest {
|
||||
|
||||
private static final Log log = LogFactory.getLog(DeviceTypeManagementAdminService.class);
|
||||
private static final String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
|
||||
private static final String TEST_DEVICE_TYPE_1 = "DUMMY-DEVICE-TYPE-1";
|
||||
private static final String TEST_DEVICE_TYPE_2 = "DUMMY DEVICE TYPE";
|
||||
private static final int TEST_DEVICE_TYPE_ID = 12345;
|
||||
private static final int TEST_DEVICE_TYPE_ID_1 = 123452;
|
||||
private static final int TEST_DEVICE_TYPE_ID_2 = 121233452;
|
||||
private DeviceTypeManagementAdminService deviceTypeManagementAdminService;
|
||||
private DeviceManagementProviderService deviceManagementProviderService;
|
||||
private DeviceTypeGeneratorService deviceTypeGeneratorService;
|
||||
|
||||
@ObjectFactory
|
||||
public IObjectFactory getObjectFactory() {
|
||||
return new org.powermock.modules.testng.PowerMockObjectFactory();
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public void init() throws DeviceManagementException {
|
||||
log.info("Initializing DeviceTypeManagementAdmin tests");
|
||||
initMocks(this);
|
||||
this.deviceManagementProviderService = Mockito
|
||||
.mock(DeviceManagementProviderServiceImpl.class, Mockito.RETURNS_MOCKS);
|
||||
this.deviceTypeGeneratorService = Mockito.mock(DeviceTypeGeneratorServiceImpl.class, Mockito.RETURNS_MOCKS);
|
||||
this.deviceTypeManagementAdminService = new DeviceTypeManagementAdminServiceImpl();
|
||||
}
|
||||
|
||||
@Test(description = "Test get all the device types.")
|
||||
public void testGetDeviceTypes() {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Response response = this.deviceTypeManagementAdminService.getDeviceTypes();
|
||||
|
||||
log.info(response.getEntity());
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(), "The Response status code " +
|
||||
"should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Test the error scenario of getting all the device types.")
|
||||
public void testGetDeviceTypesError() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Mockito.when(deviceManagementProviderService.getDeviceTypes()).thenThrow(new DeviceManagementException());
|
||||
Response response = this.deviceTypeManagementAdminService.getDeviceTypes();
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The expected status code is 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test the new device type creation scenario.")
|
||||
public void testAddDeviceTypeWithExistingName() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE_1, TEST_DEVICE_TYPE_ID_1);
|
||||
Response response = this.deviceTypeManagementAdminService.addDeviceType(deviceType);
|
||||
|
||||
log.info(response.getEntity());
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.CONFLICT.getStatusCode(),
|
||||
"The Response Status code should be 409.");
|
||||
}
|
||||
|
||||
@Test(description = "Test the new device type creation scenario when device type name is unqualified.")
|
||||
public void testAddDeviceTypeWithUnqualifiedName() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Mockito.when(deviceManagementProviderService.getDeviceType(Mockito.anyString())).thenReturn(null);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE_2, TEST_DEVICE_TYPE_ID_2);
|
||||
Response response = this.deviceTypeManagementAdminService.addDeviceType(deviceType);
|
||||
|
||||
log.info(response.getEntity());
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
|
||||
"The Response Status code should be 400.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test creating a new device type success scenario.")
|
||||
public void testAddDeviceType() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceTypeGeneratorService"))
|
||||
.toReturn(this.deviceTypeGeneratorService);
|
||||
|
||||
Mockito.when(deviceManagementProviderService.getDeviceType(Mockito.anyString())).thenReturn(null);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
Response response = this.deviceTypeManagementAdminService.addDeviceType(deviceType);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The Response Status code should be 200.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test the create device type scenario when the device type is null.")
|
||||
public void testAddDeviceTypeWithNoDeviceType() {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Response response = this.deviceTypeManagementAdminService.addDeviceType(null);
|
||||
|
||||
log.info(response.getEntity());
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
|
||||
"The Response Status code should be 409.");
|
||||
}
|
||||
|
||||
@Test(description = "Test the device type creation scenario with Device Management exception.")
|
||||
public void testAddDeviceTypeWithException() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceType(Mockito.anyString())).thenThrow(new
|
||||
DeviceManagementException());
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
Response response = this.deviceTypeManagementAdminService.addDeviceType(deviceType);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The Response Status code should be 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test the update device type scenario.")
|
||||
public void testUpdateDeviceType() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceTypeGeneratorService"))
|
||||
.toReturn(this.deviceTypeGeneratorService);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
Response response = this.deviceTypeManagementAdminService.updateDeviceType(deviceType);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The Response Status code should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Test the update device type scenario.")
|
||||
public void testUpdateNonExistingDeviceType() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceTypeGeneratorService"))
|
||||
.toReturn(this.deviceTypeGeneratorService);
|
||||
Mockito.when(deviceManagementProviderService.getDeviceType(Mockito.anyString())).thenReturn(null);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
Response response = this.deviceTypeManagementAdminService.updateDeviceType(deviceType);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
|
||||
"The Response Status code should be 400.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test update device Type when device type is null")
|
||||
public void testUpdateDeviceTypeWithNullDeviceType() {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Response response = this.deviceTypeManagementAdminService.updateDeviceType(null);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
|
||||
"The Response Status code should be 400.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test update device Type with DeviceManagementException")
|
||||
public void testUpdateDeviceTypeWithException() throws DeviceManagementException {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceType(Mockito.anyString()))
|
||||
.thenThrow(new DeviceManagementException());
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
Response response = this.deviceTypeManagementAdminService.updateDeviceType(deviceType);
|
||||
|
||||
Assert.assertNotNull(response, "The response should not be null");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The Response Status code should be 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,236 @@
|
||||
/*
|
||||
* 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.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
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.DeviceManagementException;
|
||||
import org.wso2.carbon.device.mgt.common.FeatureManager;
|
||||
import org.wso2.carbon.device.mgt.core.dto.DeviceType;
|
||||
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.service.api.DeviceTypeManagementService;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.service.impl.util.DeviceMgtAPITestHelper;
|
||||
import org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils;
|
||||
|
||||
import javax.ws.rs.core.Response;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.List;
|
||||
|
||||
import static org.mockito.MockitoAnnotations.initMocks;
|
||||
|
||||
/**
|
||||
* This class holds the unit tests for the class {@link DeviceTypeManagementService}
|
||||
*/
|
||||
@PowerMockIgnore("javax.ws.rs.*")
|
||||
@SuppressStaticInitializationFor({"org.wso2.carbon.device.mgt.jaxrs.util.DeviceMgtAPIUtils"})
|
||||
@PrepareForTest({DeviceMgtAPIUtils.class, DeviceManagementProviderService.class})
|
||||
public class DeviceTypeManagementServiceTest {
|
||||
|
||||
private static final Log log = LogFactory.getLog(DeviceManagementServiceImplTest.class);
|
||||
private static final String TEST_DEVICE_TYPE = "TEST-DEVICE-TYPE";
|
||||
private static final int TEST_DEVICE_TYPE_ID = 12345;
|
||||
private static final String MODIFIED_SINCE = "1234503934242";
|
||||
private DeviceTypeManagementService deviceTypeManagementService;
|
||||
private DeviceManagementProviderService deviceManagementProviderService;
|
||||
|
||||
@ObjectFactory
|
||||
public IObjectFactory getObjectFactory() {
|
||||
return new org.powermock.modules.testng.PowerMockObjectFactory();
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public void init() throws DeviceManagementException {
|
||||
log.info("Initializing DeviceTypeManagement tests");
|
||||
initMocks(this);
|
||||
this.deviceManagementProviderService = Mockito
|
||||
.mock(DeviceManagementProviderServiceImpl.class, Mockito.RETURNS_MOCKS);
|
||||
this.deviceTypeManagementService = new DeviceTypeManagementServiceImpl();
|
||||
}
|
||||
|
||||
@Test(description = "Testing for existing device types.")
|
||||
public void testExistingDeviceType() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypes("");
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The response states should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Testing get existing device types error")
|
||||
public void testExistingDeviceTypesError() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceTypes()).thenThrow(new DeviceManagementException());
|
||||
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypes();
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The response status should be 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Testing get existing device types error")
|
||||
public void testExistingDeviceTypesModifiedError() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getAvailableDeviceTypes()).thenThrow(new
|
||||
DeviceManagementException());
|
||||
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypes(MODIFIED_SINCE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The response status should be 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test case to retrieve the Features of specified device type.")
|
||||
public void testGetDeviceTypeFeatures() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Response response = this.deviceTypeManagementService.getFeatures(TEST_DEVICE_TYPE, MODIFIED_SINCE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The response status should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Test case to test the error scenario when retrieving the Features of specified device type.")
|
||||
public void testGetDeviceTypeFeaturesError() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
FeatureManager featureManager = Mockito.mock(FeatureManager.class);
|
||||
Mockito.when(this.deviceManagementProviderService.getFeatureManager(Mockito.anyString())).thenReturn
|
||||
(featureManager);
|
||||
Mockito.when((featureManager).getFeatures()).thenThrow(new DeviceManagementException());
|
||||
Response response = this.deviceTypeManagementService.getFeatures(TEST_DEVICE_TYPE, MODIFIED_SINCE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The response status should be 500.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
Mockito.reset(featureManager);
|
||||
}
|
||||
|
||||
@Test(description = "Test getting device type features when feature manager is null.")
|
||||
public void testGetDeviceTypeFeaturesWithNoFeatureManager() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getFeatureManager(Mockito.anyString())).thenReturn(null);
|
||||
Response response = this.deviceTypeManagementService.getFeatures(TEST_DEVICE_TYPE, MODIFIED_SINCE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.NOT_FOUND.getStatusCode(),
|
||||
"The response status should be 404.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test to get all the device types.")
|
||||
public void testGetDeviceTypes() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypes();
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The response status should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Test to get all the device types.")
|
||||
public void testGetDeviceTypesWithDeviceTypes() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
|
||||
List<DeviceType> deviceTypes = DeviceMgtAPITestHelper.getDummyDeviceTypeList(5);
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceTypes()).thenReturn(deviceTypes);
|
||||
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypes();
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The response state should be 200");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test to get all the device types for the given name")
|
||||
public void testGetDeviceTypeByName() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypeByName(TEST_DEVICE_TYPE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.OK.getStatusCode(),
|
||||
"The response status should be 200.");
|
||||
}
|
||||
|
||||
@Test(description = "Test the scenario when there are no device types for the given name.")
|
||||
public void testGetDeviceTypeByNameError() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceType(Mockito.anyString())).thenReturn(null);
|
||||
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypeByName(TEST_DEVICE_TYPE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.NO_CONTENT.getStatusCode(),
|
||||
"The response status should be 204.");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test the scenario when there are no device types for the given name.")
|
||||
public void testGetDeviceTypeByNameException() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Mockito.when(this.deviceManagementProviderService.getDeviceType(Mockito.anyString()))
|
||||
.thenThrow(new DeviceManagementException());
|
||||
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypeByName(TEST_DEVICE_TYPE);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(),
|
||||
"The response status should be 500");
|
||||
Mockito.reset(deviceManagementProviderService);
|
||||
}
|
||||
|
||||
@Test(description = "Test to get all the device types when given name is null")
|
||||
public void testGetDeviceTypeByNameBadRequest() throws Exception {
|
||||
PowerMockito.stub(PowerMockito.method(DeviceMgtAPIUtils.class, "getDeviceManagementService"))
|
||||
.toReturn(this.deviceManagementProviderService);
|
||||
Response response = this.deviceTypeManagementService.getDeviceTypeByName(null);
|
||||
Assert.assertNotNull(response, "The response object is null.");
|
||||
Assert.assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode(),
|
||||
"The response status should be 400");
|
||||
}
|
||||
|
||||
@Test(description = "Test to clear the sensitive metadata information of device type")
|
||||
public void testClearMetaEntryInfo() throws NoSuchMethodException, InvocationTargetException,
|
||||
IllegalAccessException {
|
||||
Method clearMetaEntryInfo = DeviceTypeManagementServiceImpl.class.getDeclaredMethod("clearMetaEntryInfo",
|
||||
DeviceType.class);
|
||||
clearMetaEntryInfo.setAccessible(true);
|
||||
|
||||
DeviceType deviceType = DeviceMgtAPITestHelper.getDummyDeviceType(TEST_DEVICE_TYPE, TEST_DEVICE_TYPE_ID);
|
||||
DeviceType returned = (DeviceType) clearMetaEntryInfo.invoke(this.deviceTypeManagementService, deviceType);
|
||||
|
||||
Assert.assertNotNull(returned.getDeviceTypeMetaDefinition(), "The response object is null.");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
/*
|
||||
* 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.util;
|
||||
|
||||
import org.wso2.carbon.device.mgt.common.push.notification.PushNotificationConfig;
|
||||
import org.wso2.carbon.device.mgt.common.type.mgt.DeviceTypeMetaDefinition;
|
||||
import org.wso2.carbon.device.mgt.core.dto.DeviceType;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Helper class for Device Management API test cases.
|
||||
* */
|
||||
public class DeviceMgtAPITestHelper {
|
||||
|
||||
private static final String DEVICE_TYPE_DESCRIPTION = "Dummy Description";
|
||||
private static final String DEVICE_TYPE = "TEST_DEVICE_TYPE";
|
||||
|
||||
/**
|
||||
* Creates a Device Type with given name and given id.
|
||||
* If the name is null, the TEST_DEVICE_TYPE will be used as the name.
|
||||
*
|
||||
* @param name : Name of the device type.
|
||||
* @param deviceTypeId : The Id of the device type.
|
||||
* @return DeviceType
|
||||
*/
|
||||
public static DeviceType getDummyDeviceType(String name, int deviceTypeId) {
|
||||
DeviceType deviceType = new DeviceType();
|
||||
deviceType.setId(deviceTypeId);
|
||||
deviceType.setName(name != null ? name : DEVICE_TYPE);
|
||||
|
||||
DeviceTypeMetaDefinition deviceTypeMetaDefinition = new DeviceTypeMetaDefinition();
|
||||
deviceTypeMetaDefinition.setClaimable(true);
|
||||
deviceTypeMetaDefinition.setDescription(DEVICE_TYPE_DESCRIPTION);
|
||||
|
||||
PushNotificationConfig pushNotificationConfig =
|
||||
new PushNotificationConfig(name, true, null);
|
||||
deviceTypeMetaDefinition.setPushNotificationConfig(pushNotificationConfig);
|
||||
|
||||
deviceType.setDeviceTypeMetaDefinition(deviceTypeMetaDefinition);
|
||||
return deviceType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a list of device types.
|
||||
*
|
||||
* @param count: The number of device types that is needed.
|
||||
* @return List<DeviceType> : A list of device types.
|
||||
*/
|
||||
public static List<DeviceType> getDummyDeviceTypeList(int count) {
|
||||
List<DeviceType> deviceTypes = new ArrayList<>();
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
DeviceType deviceType = getDummyDeviceType(DEVICE_TYPE + count, count);
|
||||
deviceTypes.add(deviceType);
|
||||
}
|
||||
|
||||
return deviceTypes;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,34 @@
|
||||
#
|
||||
# Copyright (c) 2016, 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.
|
||||
#
|
||||
|
||||
#
|
||||
# This is the log4j configuration file used by WSO2 Carbon
|
||||
#
|
||||
# IMPORTANT : Please do not remove or change the names of any
|
||||
# of the Appender defined here. The layout pattern & log file
|
||||
# can be changed using the WSO2 Carbon Management Console, and those
|
||||
# settings will override the settings in this file.
|
||||
#
|
||||
|
||||
log4j.rootLogger=DEBUG, STD_OUT
|
||||
|
||||
# Redirect log messages to console
|
||||
log4j.appender.STD_OUT=org.apache.log4j.ConsoleAppender
|
||||
log4j.appender.STD_OUT.Target=System.out
|
||||
log4j.appender.STD_OUT.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.STD_OUT.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
|
||||
@ -0,0 +1,32 @@
|
||||
|
||||
<!--
|
||||
~ 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.
|
||||
-->
|
||||
|
||||
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
|
||||
|
||||
<suite name="DeviceManagementAPI">
|
||||
<parameter name="useDefaultListeners" value="false"/>
|
||||
|
||||
<test name="API Unit Tests" preserve-order="true">
|
||||
<classes>
|
||||
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceManagementServiceImplTest"/>
|
||||
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementServiceTest"/>
|
||||
<class name="org.wso2.carbon.device.mgt.jaxrs.service.impl.DeviceTypeManagementAdminServiceTest"/>
|
||||
</classes>
|
||||
</test>
|
||||
</suite>
|
||||
@ -0,0 +1,349 @@
|
||||
package org.wso2.carbon.policy.mgt.core.mgt.impl;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.testng.Assert;
|
||||
import org.testng.annotations.BeforeClass;
|
||||
import org.testng.annotations.Test;
|
||||
import org.testng.internal.collections.Pair;
|
||||
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
|
||||
import org.wso2.carbon.device.mgt.common.IllegalTransactionStateException;
|
||||
import org.wso2.carbon.device.mgt.common.group.mgt.DeviceGroup;
|
||||
import org.wso2.carbon.device.mgt.common.operation.mgt.OperationManager;
|
||||
import org.wso2.carbon.device.mgt.common.policy.mgt.Profile;
|
||||
import org.wso2.carbon.device.mgt.common.policy.mgt.ProfileFeature;
|
||||
import org.wso2.carbon.device.mgt.core.authorization.DeviceAccessAuthorizationServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
|
||||
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
|
||||
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
|
||||
import org.wso2.carbon.device.mgt.core.operation.mgt.OperationManagerImpl;
|
||||
import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.core.service.GroupManagementProviderServiceImpl;
|
||||
import org.wso2.carbon.policy.mgt.common.PolicyEvaluationPoint;
|
||||
import org.wso2.carbon.policy.mgt.common.ProfileManagementException;
|
||||
import org.wso2.carbon.policy.mgt.core.BasePolicyManagementDAOTest;
|
||||
import org.wso2.carbon.policy.mgt.core.PolicyManagerServiceImpl;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.FeatureDAO;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.FeatureManagerDAOException;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.PolicyManagementDAOFactory;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.ProfileDAO;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.ProfileManagerDAOException;
|
||||
import org.wso2.carbon.policy.mgt.core.dao.impl.ProfileDAOImpl;
|
||||
import org.wso2.carbon.policy.mgt.core.internal.PolicyManagementDataHolder;
|
||||
import org.wso2.carbon.policy.mgt.core.mock.TypeXDeviceManagementService;
|
||||
import org.wso2.carbon.policy.mgt.core.services.SimplePolicyEvaluationTest;
|
||||
import org.wso2.carbon.policy.mgt.core.util.FeatureCreator;
|
||||
import org.wso2.carbon.policy.mgt.core.util.ProfileCreator;
|
||||
|
||||
import javax.sql.DataSource;
|
||||
import java.sql.Connection;
|
||||
import java.sql.SQLException;
|
||||
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Matchers.anyBoolean;
|
||||
import static org.mockito.Matchers.anyInt;
|
||||
import static org.mockito.Matchers.anyListOf;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
public class ProfileManagerImplTest extends BasePolicyManagementDAOTest {
|
||||
private static final Log log = LogFactory.getLog(PolicyManagerServiceImpl.class);
|
||||
|
||||
private static final String DEVICE3 = "device3";
|
||||
private static final String GROUP3 = "group3";
|
||||
private static final String POLICY3 = "policy3";
|
||||
private static final String DEVICE_TYPE_C = "deviceTypeC";
|
||||
|
||||
private Profile profile1;
|
||||
private OperationManager operationManager;
|
||||
|
||||
@BeforeClass
|
||||
public void initialize() throws Exception {
|
||||
log.info("Initializing policy manager tests");
|
||||
super.initializeServices();
|
||||
deviceMgtService.registerDeviceType(new TypeXDeviceManagementService(DEVICE_TYPE_C));
|
||||
operationManager = new OperationManagerImpl(DEVICE_TYPE_C);
|
||||
enrollDevice(DEVICE3, DEVICE_TYPE_C);
|
||||
createDeviceGroup(GROUP3);
|
||||
DeviceGroup group1 = groupMgtService.getGroup(GROUP3);
|
||||
addDeviceToGroup(new DeviceIdentifier(DEVICE3, DEVICE_TYPE_C), GROUP3);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests adding new profile")
|
||||
public void testAddProfile() throws Exception {
|
||||
//Creating profile object
|
||||
Profile profile = ProfileCreator.getProfile(FeatureCreator.getFeatureList(), DEVICE_TYPE_C);
|
||||
//Adding profile
|
||||
profile1 = profileManager.addProfile(profile);
|
||||
Assert.assertEquals(profile1.getProfileName(), profile.getProfileName());
|
||||
Assert.assertEquals(profile1.getTenantId(), profile.getTenantId());
|
||||
Assert.assertEquals(profile1.getDeviceType(), profile.getDeviceType());
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when adding new profile",
|
||||
dependsOnMethods = "testAddProfile")
|
||||
public void testAddProfileThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.addProfile(any(Profile.class))).thenThrow(new ProfileManagerDAOException());
|
||||
//Creating profile object
|
||||
Profile profile = ProfileCreator.getProfile(FeatureCreator.getFeatureList(), DEVICE_TYPE_C);
|
||||
testThrowingException(profile, p -> profileManager.addProfile(p), "profileDAO", profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when adding new profile",
|
||||
dependsOnMethods = "testAddProfileThrowingProfileManagerDAOException")
|
||||
public void testAddProfileThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.addProfileFeatures(anyListOf(ProfileFeature.class), anyInt())).thenThrow(
|
||||
new FeatureManagerDAOException());
|
||||
//Creating profile object
|
||||
Profile profile = ProfileCreator.getProfile(FeatureCreator.getFeatureList(), DEVICE_TYPE_C);
|
||||
testThrowingException(profile, p -> profileManager.addProfile(p), "featureDAO", featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when adding new profile",
|
||||
dependsOnMethods = "testAddProfileThrowingFeatureManagerDAOException",
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testAddProfileThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Creating profile object
|
||||
Profile profile = ProfileCreator.getProfile(FeatureCreator.getFeatureList(), DEVICE_TYPE_C);
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.first()).setAutoCommit(anyBoolean());
|
||||
try {
|
||||
profileManager.addProfile(profile);
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests updating profile",
|
||||
dependsOnMethods = "testAddProfile")
|
||||
public void testUpdateProfile() throws Exception {
|
||||
String newProfileName = "Updated Test Profile";
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
savedProfile.setProfileName(newProfileName);
|
||||
Profile updateProfile = profileManager.updateProfile(savedProfile);
|
||||
Assert.assertEquals(updateProfile.getProfileName(), newProfileName);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when updating profile",
|
||||
dependsOnMethods = "testUpdateProfile")
|
||||
public void testUpdateProfileThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.updateProfile(any(Profile.class))).thenThrow(new ProfileManagerDAOException());
|
||||
|
||||
String newProfileName = "Updated Test Profile";
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
savedProfile.setProfileName(newProfileName);
|
||||
testThrowingException(savedProfile, p -> profileManager.updateProfile(p), "profileDAO", profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when updating profile",
|
||||
dependsOnMethods = "testUpdateProfileThrowingProfileManagerDAOException")
|
||||
public void testUpdateProfileThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.updateProfileFeatures(anyListOf(ProfileFeature.class), anyInt())).thenThrow(
|
||||
new FeatureManagerDAOException());
|
||||
|
||||
String newProfileName = "Updated Test Profile";
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
savedProfile.setProfileName(newProfileName);
|
||||
testThrowingException(savedProfile, p -> profileManager.updateProfile(p), "featureDAO", featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when updating profile",
|
||||
dependsOnMethods = {"testUpdateProfileThrowingFeatureManagerDAOException"},
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testUpdateProfileThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Retrieving profile object
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.first()).setAutoCommit(anyBoolean());
|
||||
|
||||
String newProfileName = "Updated Test Profile";
|
||||
savedProfile.setProfileName(newProfileName);
|
||||
try {
|
||||
profileManager.updateProfile(savedProfile);
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests retrieving profile", dependsOnMethods = "testAddProfile")
|
||||
public void testGetProfile() throws Exception {
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
Assert.assertEquals(profile1.getProfileName(), savedProfile.getProfileName());
|
||||
Assert.assertEquals(profile1.getTenantId(), savedProfile.getTenantId());
|
||||
Assert.assertEquals(profile1.getDeviceType(), savedProfile.getDeviceType());
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests retrieving non existent profile", dependsOnMethods = "testGetProfile",
|
||||
expectedExceptions = ProfileManagementException.class)
|
||||
public void testGetProfileThrowingProfileManagementException() throws Exception {
|
||||
int nonExistentProfileId = 9999;
|
||||
profileManager.getProfile(nonExistentProfileId);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when retrieving profile",
|
||||
dependsOnMethods = "testGetProfile")
|
||||
public void testGetProfileThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.getProfile(anyInt())).thenThrow(new ProfileManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getProfile(p.getProfileId()), "profileDAO", profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when retrieving profile",
|
||||
dependsOnMethods = "testGetProfileThrowingProfileManagerDAOException")
|
||||
public void testGetProfileThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.getFeaturesForProfile(anyInt())).thenThrow(new FeatureManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getProfile(p.getProfileId()), "featureDAO", featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when retrieving profile",
|
||||
dependsOnMethods = "testGetProfileThrowingFeatureManagerDAOException",
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testGetProfileThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Creating profile object
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.second().second()).getConnection();
|
||||
|
||||
try {
|
||||
profileManager.getProfile(profile1.getProfileId());
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests retrieving all profiles",
|
||||
dependsOnMethods = "testAddProfile")
|
||||
public void testGetAllProfiles() throws Exception {
|
||||
profileManager.getAllProfiles();
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when retrieving all profiles",
|
||||
dependsOnMethods = "testGetAllProfiles")
|
||||
public void testGetAllProfilesThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.getAllProfiles()).thenThrow(new ProfileManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getAllProfiles(), "profileDAO", profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when retrieving all profiles",
|
||||
dependsOnMethods = "testGetAllProfilesThrowingProfileManagerDAOException")
|
||||
public void testGetAllProfilesThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.getAllProfileFeatures()).thenThrow(new FeatureManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getAllProfiles(), "featureDAO", featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when retrieving all profiles",
|
||||
dependsOnMethods = "testGetAllProfilesThrowingFeatureManagerDAOException",
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testGetAllProfilesThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Creating profile object
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.second().second()).getConnection();
|
||||
|
||||
try {
|
||||
profileManager.getAllProfiles();
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests retrieving profiles of a device type",
|
||||
dependsOnMethods = "testAddProfile")
|
||||
public void testGetProfilesOfDeviceType() throws Exception {
|
||||
profileManager.getProfilesOfDeviceType(DEVICE_TYPE_C);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when retrieving all profiles of a " +
|
||||
"device type",
|
||||
dependsOnMethods = "testGetProfilesOfDeviceType")
|
||||
public void testGetProfilesOfDeviceTypeThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.getProfilesOfDeviceType(anyString())).thenThrow(new ProfileManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getProfilesOfDeviceType(DEVICE_TYPE_C), "profileDAO",
|
||||
profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when retrieving all profiles of a " +
|
||||
"device type",
|
||||
dependsOnMethods = "testGetProfilesOfDeviceTypeThrowingProfileManagerDAOException")
|
||||
public void testGetProfilesOfDeviceTypeThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.getAllProfileFeatures()).thenThrow(new FeatureManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.getProfilesOfDeviceType(DEVICE_TYPE_C), "featureDAO",
|
||||
featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when retrieving all profiles of a device type",
|
||||
dependsOnMethods = "testGetProfilesOfDeviceTypeThrowingFeatureManagerDAOException",
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testGetProfilesOfDeviceTypeThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Creating profile object
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.second().second()).getConnection();
|
||||
|
||||
try {
|
||||
profileManager.getProfilesOfDeviceType(DEVICE_TYPE_C);
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling ProfileManagerDAOException when deleting a profile",
|
||||
dependsOnMethods = "testGetProfilesOfDeviceTypeThrowingIllegalTransactionStateException")
|
||||
public void testDeleteProfileThrowingProfileManagerDAOException() throws Exception {
|
||||
ProfileDAO profileDAO = mock(ProfileDAOImpl.class);
|
||||
when(profileDAO.deleteProfile(any(Profile.class))).thenThrow(new ProfileManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.deleteProfile(profile1), "profileDAO", profileDAO,
|
||||
ProfileManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling FeatureManagerDAOException when deleting a profile",
|
||||
dependsOnMethods = "testDeleteProfileThrowingProfileManagerDAOException")
|
||||
public void testDeleteProfileThrowingFeatureManagerDAOException() throws Exception {
|
||||
FeatureDAO featureDAO = mock(FeatureDAO.class);
|
||||
when(featureDAO.deleteFeaturesOfProfile(any(Profile.class))).thenThrow(new FeatureManagerDAOException());
|
||||
testThrowingException(profile1, p -> profileManager.deleteProfile(profile1), "featureDAO", featureDAO,
|
||||
FeatureManagerDAOException.class);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests handling SQLException when deleting a profile",
|
||||
dependsOnMethods = "testDeleteProfileThrowingFeatureManagerDAOException",
|
||||
expectedExceptions = IllegalTransactionStateException.class)
|
||||
public void testDeleteProfileThrowingIllegalTransactionStateException() throws Exception {
|
||||
//Creating profile object
|
||||
Pair<Connection, Pair<DataSource, DataSource>> pair = mockConnection();
|
||||
PowerMockito.doThrow(new SQLException()).when(pair.second().second()).getConnection();
|
||||
|
||||
try {
|
||||
profileManager.deleteProfile(profile1);
|
||||
} finally {
|
||||
PolicyManagementDAOFactory.init(pair.second().first());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests deleting a profile",
|
||||
dependsOnMethods = "testDeleteProfileThrowingIllegalTransactionStateException",
|
||||
expectedExceptions = {ProfileManagementException.class})
|
||||
public void testDeleteProfile() throws Exception {
|
||||
profileManager.deleteProfile(profile1);
|
||||
Profile savedProfile = profileManager.getProfile(profile1.getProfileId());
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,284 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.authenticator;
|
||||
|
||||
import org.apache.catalina.Context;
|
||||
import org.apache.catalina.connector.Request;
|
||||
import org.apache.catalina.core.StandardContext;
|
||||
import org.apache.tomcat.util.buf.MessageBytes;
|
||||
import org.apache.tomcat.util.http.MimeHeaders;
|
||||
import org.bouncycastle.cert.jcajce.JcaCertStore;
|
||||
import org.bouncycastle.cms.CMSAbsentContent;
|
||||
import org.bouncycastle.cms.CMSException;
|
||||
import org.bouncycastle.cms.CMSSignedData;
|
||||
import org.bouncycastle.cms.CMSSignedDataGenerator;
|
||||
import org.h2.jdbcx.JdbcDataSource;
|
||||
import org.mockito.Mockito;
|
||||
import org.testng.Assert;
|
||||
import org.testng.annotations.BeforeClass;
|
||||
import org.testng.annotations.Test;
|
||||
import org.wso2.carbon.base.MultitenantConstants;
|
||||
import org.wso2.carbon.certificate.mgt.core.dao.CertificateManagementDAOFactory;
|
||||
import org.wso2.carbon.certificate.mgt.core.exception.KeystoreException;
|
||||
import org.wso2.carbon.certificate.mgt.core.impl.CertificateGenerator;
|
||||
import org.wso2.carbon.certificate.mgt.core.impl.KeyStoreReader;
|
||||
import org.wso2.carbon.certificate.mgt.core.scep.SCEPException;
|
||||
import org.wso2.carbon.certificate.mgt.core.scep.SCEPManager;
|
||||
import org.wso2.carbon.certificate.mgt.core.scep.SCEPManagerImpl;
|
||||
import org.wso2.carbon.certificate.mgt.core.scep.TenantedDeviceWrapper;
|
||||
import org.wso2.carbon.certificate.mgt.core.service.CertificateManagementService;
|
||||
import org.wso2.carbon.certificate.mgt.core.service.CertificateManagementServiceImpl;
|
||||
import org.wso2.carbon.device.mgt.common.Device;
|
||||
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
|
||||
import org.wso2.carbon.device.mgt.common.EnrolmentInfo;
|
||||
import org.wso2.carbon.device.mgt.core.config.DeviceConfigurationManager;
|
||||
import org.wso2.carbon.webapp.authenticator.framework.AuthenticationInfo;
|
||||
import org.wso2.carbon.webapp.authenticator.framework.internal.AuthenticatorFrameworkDataHolder;
|
||||
import org.wso2.carbon.webapp.authenticator.framework.util.TestCertificateGenerator;
|
||||
|
||||
import javax.sql.DataSource;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Field;
|
||||
import java.net.URL;
|
||||
import java.security.cert.CertificateEncodingException;
|
||||
import java.security.cert.X509Certificate;
|
||||
import java.sql.Connection;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Base64;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
/**
|
||||
* This is a test case for {@link CertificateAuthenticator}.
|
||||
*/
|
||||
public class CertificateAuthenticatorTest {
|
||||
private CertificateAuthenticator certificateAuthenticator;
|
||||
private Request certificationVerificationRequest;
|
||||
private Request mutalAuthHeaderRequest;
|
||||
private Request proxyMutalAuthHeaderRequest;
|
||||
private Field headersField;
|
||||
private static final String MUTUAL_AUTH_HEADER = "mutual-auth-header";
|
||||
private static final String PROXY_MUTUAL_AUTH_HEADER = "proxy-mutual-auth-header";
|
||||
private static final String CERTIFICATE_VERIFICATION_HEADER = "Mdm-Signature";
|
||||
private static final String CLIENT_CERTIFICATE_ATTRIBUTE = "javax.servlet.request.X509Certificate";
|
||||
private X509Certificate X509certificate;
|
||||
|
||||
@BeforeClass
|
||||
public void setup() throws KeystoreException, NoSuchFieldException, IllegalAccessException, SQLException,
|
||||
DeviceManagementException, CertificateEncodingException, CMSException, IOException, SCEPException {
|
||||
certificateAuthenticator = new CertificateAuthenticator();
|
||||
CertificateManagementService certificateManagementService = Mockito
|
||||
.mock(CertificateManagementServiceImpl.class, Mockito.CALLS_REAL_METHODS);
|
||||
headersField = org.apache.coyote.Request.class.getDeclaredField("headers");
|
||||
headersField.setAccessible(true);
|
||||
|
||||
Field certificateManagementServiceImpl = CertificateManagementServiceImpl.class.getDeclaredField
|
||||
("certificateManagementServiceImpl");
|
||||
certificateManagementServiceImpl.setAccessible(true);
|
||||
Field keyStoreReaderField = CertificateManagementServiceImpl.class.getDeclaredField("keyStoreReader");
|
||||
keyStoreReaderField.setAccessible(true);
|
||||
Field certificateGeneratorField = CertificateManagementServiceImpl.class.getDeclaredField
|
||||
("certificateGenerator");
|
||||
certificateGeneratorField.setAccessible(true);
|
||||
certificateManagementServiceImpl.set(null, certificateManagementService);
|
||||
|
||||
// Create KeyStore Reader
|
||||
Field dataSource = CertificateManagementDAOFactory.class.getDeclaredField("dataSource");
|
||||
dataSource.setAccessible(true);
|
||||
dataSource.set(null, createDatabase());
|
||||
Field databaseEngine = CertificateManagementDAOFactory.class.getDeclaredField("databaseEngine");
|
||||
databaseEngine.setAccessible(true);
|
||||
databaseEngine.set(null, "H2");
|
||||
KeyStoreReader keyStoreReader = new KeyStoreReader();
|
||||
keyStoreReaderField.set(null, keyStoreReader);
|
||||
|
||||
CertificateGenerator certificateGenerator = new TestCertificateGenerator();
|
||||
certificateGeneratorField.set(null, certificateGenerator);
|
||||
|
||||
AuthenticatorFrameworkDataHolder.getInstance().
|
||||
setCertificateManagementService(certificateManagementService);
|
||||
X509certificate = certificateManagementService.generateX509Certificate();
|
||||
|
||||
proxyMutalAuthHeaderRequest = createRequest(PROXY_MUTUAL_AUTH_HEADER, String.valueOf(X509certificate));
|
||||
System.setProperty("carbon.config.dir.path",
|
||||
System.getProperty("carbon.home") + File.separator + "repository" + File.separator + "conf");
|
||||
DeviceConfigurationManager.getInstance().initConfig();
|
||||
certificationVerificationRequest = createRequest(CERTIFICATE_VERIFICATION_HEADER,
|
||||
createEncodedSignature(X509certificate));
|
||||
|
||||
mutalAuthHeaderRequest = createRequest(MUTUAL_AUTH_HEADER, "test");
|
||||
|
||||
SCEPManager scepManager = Mockito.mock(SCEPManagerImpl.class, Mockito.CALLS_REAL_METHODS);
|
||||
TenantedDeviceWrapper tenantedDeviceWrapper = new TenantedDeviceWrapper();
|
||||
tenantedDeviceWrapper.setTenantDomain(MultitenantConstants.SUPER_TENANT_DOMAIN_NAME);
|
||||
tenantedDeviceWrapper.setTenantId(MultitenantConstants.SUPER_TENANT_ID);
|
||||
Device device = new Device();
|
||||
device.setEnrolmentInfo(new EnrolmentInfo("admin", null, null));
|
||||
tenantedDeviceWrapper.setDevice(device);
|
||||
Mockito.doReturn(tenantedDeviceWrapper).when(scepManager).getValidatedDevice(Mockito.any());
|
||||
AuthenticatorFrameworkDataHolder.getInstance().setScepManager(scepManager);
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests the behaviour of the CertificateAuthenticator for Proxy mutal Auth "
|
||||
+ "Header requests")
|
||||
public void testRequestsWithProxyMutalAuthHeader()
|
||||
throws KeystoreException, NoSuchFieldException, IllegalAccessException {
|
||||
Assert.assertTrue(certificateAuthenticator.canHandle(proxyMutalAuthHeaderRequest), "canHandle method "
|
||||
+ "returned false for a request with all the required header");
|
||||
AuthenticationInfo authenticationInfo = certificateAuthenticator
|
||||
.authenticate(proxyMutalAuthHeaderRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertNull(authenticationInfo.getTenantDomain(),
|
||||
"Authentication got succeeded without proper certificate");
|
||||
|
||||
proxyMutalAuthHeaderRequest = createRequest(PROXY_MUTUAL_AUTH_HEADER,
|
||||
String.valueOf(X509certificate.getIssuerDN()));
|
||||
authenticationInfo = certificateAuthenticator.authenticate(proxyMutalAuthHeaderRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertNotNull(authenticationInfo.getTenantDomain(),
|
||||
"Authentication got failed for a proper certificate");
|
||||
|
||||
CertificateGenerator tempCertificateGenerator = new CertificateGenerator();
|
||||
X509Certificate certificateWithOutCN = tempCertificateGenerator.generateX509Certificate();
|
||||
proxyMutalAuthHeaderRequest = createRequest(PROXY_MUTUAL_AUTH_HEADER,
|
||||
String.valueOf(certificateWithOutCN.getIssuerDN()));
|
||||
authenticationInfo = certificateAuthenticator.authenticate(proxyMutalAuthHeaderRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertEquals(authenticationInfo.getStatus(), WebappAuthenticator.Status.FAILURE,
|
||||
"Authentication got passed with a certificate without CN");
|
||||
|
||||
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests the behaviour of the CertificateAuthenticator for Certification "
|
||||
+ "Verification Header requests")
|
||||
public void testRequestCertificateVerificationHeader()
|
||||
throws CertificateEncodingException, IOException, CMSException, NoSuchFieldException,
|
||||
IllegalAccessException {
|
||||
Assert.assertTrue(certificateAuthenticator.canHandle(certificationVerificationRequest),
|
||||
"canHandle method returned false for a request with all the required header");
|
||||
AuthenticationInfo authenticationInfo = certificateAuthenticator
|
||||
.authenticate(certificationVerificationRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertNull(authenticationInfo.getTenantDomain(), "Authentication got passed without proper certificate");
|
||||
authenticationInfo = certificateAuthenticator.authenticate(certificationVerificationRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertEquals(authenticationInfo.getTenantDomain(), MultitenantConstants.SUPER_TENANT_DOMAIN_NAME,
|
||||
"Authentication failed for a valid request with " + CERTIFICATE_VERIFICATION_HEADER + " header");
|
||||
}
|
||||
|
||||
@Test(description = "This test case tests the behaviour of the Certificate Authenticator for the requests with "
|
||||
+ "Mutal Auth Header")
|
||||
public void testMutalAuthHeaderRequest() {
|
||||
Assert.assertTrue(certificateAuthenticator.canHandle(mutalAuthHeaderRequest),
|
||||
"canHandle method returned false for a request with all the required header");
|
||||
|
||||
AuthenticationInfo authenticationInfo = certificateAuthenticator.authenticate(mutalAuthHeaderRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertEquals(authenticationInfo.getMessage(), "No client certificate is present",
|
||||
"Authentication got passed without proper certificate");
|
||||
|
||||
X509Certificate[] x509Certificates = new X509Certificate[1];
|
||||
x509Certificates[0] = X509certificate;
|
||||
mutalAuthHeaderRequest.setAttribute(CLIENT_CERTIFICATE_ATTRIBUTE, x509Certificates);
|
||||
authenticationInfo = certificateAuthenticator.authenticate(mutalAuthHeaderRequest, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Authentication Info from Certificate Authenticator is null");
|
||||
Assert.assertEquals(authenticationInfo.getTenantDomain(), MultitenantConstants.SUPER_TENANT_DOMAIN_NAME,
|
||||
"Authentication failed even with proper certificate");
|
||||
}
|
||||
/**
|
||||
* To create a request that can be understandable by Certificate Authenticator.
|
||||
*
|
||||
* @param headerName Name of the header
|
||||
* @param value Value for the header
|
||||
* @return Request that is created.
|
||||
* @throws IllegalAccessException Illegal Access Exception.
|
||||
* @throws NoSuchFieldException No Such Field Exception.
|
||||
*/
|
||||
private Request createRequest(String headerName, String value) throws IllegalAccessException, NoSuchFieldException {
|
||||
Request request = new Request();
|
||||
Context context = new StandardContext();
|
||||
request.setContext(context);
|
||||
org.apache.coyote.Request coyoteRequest = new org.apache.coyote.Request();
|
||||
MimeHeaders mimeHeaders = new MimeHeaders();
|
||||
MessageBytes bytes = mimeHeaders.addValue(headerName);
|
||||
bytes.setString(value);
|
||||
headersField.set(coyoteRequest, mimeHeaders);
|
||||
|
||||
request.setCoyoteRequest(coyoteRequest);
|
||||
return request;
|
||||
}
|
||||
|
||||
/**
|
||||
* To create certificate management database.
|
||||
*
|
||||
* @return Datasource.
|
||||
* @throws SQLException SQL Exception.
|
||||
*/
|
||||
private DataSource createDatabase() throws SQLException {
|
||||
URL resourceURL = ClassLoader.getSystemResource("sql-scripts" + File.separator + "h2.sql");
|
||||
JdbcDataSource dataSource = new JdbcDataSource();
|
||||
dataSource.setURL("jdbc:h2:mem:cert;DB_CLOSE_DELAY=-1");
|
||||
dataSource.setUser("sa");
|
||||
dataSource.setPassword("sa");
|
||||
final String LOAD_DATA_QUERY = "RUNSCRIPT FROM '" + resourceURL.getPath() + "'";
|
||||
Connection conn = null;
|
||||
Statement statement = null;
|
||||
try {
|
||||
conn = dataSource.getConnection();
|
||||
statement = conn.createStatement();
|
||||
statement.execute(LOAD_DATA_QUERY);
|
||||
} finally {
|
||||
if (conn != null) {
|
||||
try {
|
||||
conn.close();
|
||||
} catch (SQLException e) {}
|
||||
}
|
||||
if (statement != null) {
|
||||
statement.close();
|
||||
}
|
||||
}
|
||||
return dataSource;
|
||||
}
|
||||
|
||||
/**
|
||||
* To create a encoded signature from certificate.
|
||||
*
|
||||
* @param x509Certificate Certificate that need to be encoded.
|
||||
* @return Encoded signature.
|
||||
* @throws CertificateEncodingException Certificate Encoding Exception.
|
||||
* @throws CMSException CMS Exception.
|
||||
* @throws IOException IO Exception.
|
||||
*/
|
||||
private String createEncodedSignature(X509Certificate x509Certificate) throws CertificateEncodingException,
|
||||
CMSException, IOException {
|
||||
CMSSignedDataGenerator generator = new CMSSignedDataGenerator();
|
||||
List<X509Certificate> list = new ArrayList<>();
|
||||
list.add(x509Certificate);
|
||||
JcaCertStore store = new JcaCertStore(list);
|
||||
generator.addCertificates(store);
|
||||
AtomicReference<CMSSignedData> degenerateSd = new AtomicReference<>(generator.generate(new CMSAbsentContent()));
|
||||
byte[] signature = degenerateSd.get().getEncoded();
|
||||
return Base64.getEncoder().encodeToString(signature);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,177 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.authenticator;
|
||||
|
||||
import org.apache.catalina.connector.Request;
|
||||
import org.apache.tomcat.util.buf.MessageBytes;
|
||||
import org.apache.tomcat.util.http.MimeHeaders;
|
||||
import org.testng.Assert;
|
||||
import org.testng.annotations.BeforeClass;
|
||||
import org.testng.annotations.Test;
|
||||
import org.wso2.carbon.base.MultitenantConstants;
|
||||
import org.wso2.carbon.identity.jwt.client.extension.dto.JWTConfig;
|
||||
import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientException;
|
||||
import org.wso2.carbon.identity.jwt.client.extension.util.JWTClientUtil;
|
||||
import org.wso2.carbon.webapp.authenticator.framework.AuthenticationInfo;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Field;
|
||||
import java.net.URL;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
|
||||
/**
|
||||
* This is a test class for {@link JWTAuthenticator}.
|
||||
*/
|
||||
public class JWTAuthenticatorTest {
|
||||
private JWTAuthenticator jwtAuthenticator;
|
||||
private Field headersField;
|
||||
private final String JWT_HEADER = "X-JWT-Assertion";
|
||||
private String jwtToken;
|
||||
private String wrongJwtToken;
|
||||
private String jwtTokenWithWrongUser;
|
||||
private static final String SIGNED_JWT_AUTH_USERNAME = "http://wso2.org/claims/enduser";
|
||||
private static final String SIGNED_JWT_AUTH_TENANT_ID = "http://wso2.org/claims/enduserTenantId";
|
||||
private Properties properties;
|
||||
private final String ISSUER = "wso2.org/products/iot";
|
||||
private final String ALIAS = "wso2carbon";
|
||||
|
||||
@BeforeClass
|
||||
public void setup() throws NoSuchFieldException, IOException, JWTClientException {
|
||||
jwtAuthenticator = new JWTAuthenticator();
|
||||
headersField = org.apache.coyote.Request.class.getDeclaredField("headers");
|
||||
headersField.setAccessible(true);
|
||||
ClassLoader classLoader = getClass().getClassLoader();
|
||||
URL resourceUrl = classLoader.getResource("jwt.properties");
|
||||
File jwtPropertyFile;
|
||||
JWTConfig jwtConfig = null;
|
||||
if (resourceUrl != null) {
|
||||
jwtPropertyFile = new File(resourceUrl.getFile());
|
||||
Properties jwtConfigProperties = new Properties();
|
||||
jwtConfigProperties.load(new FileInputStream(jwtPropertyFile));
|
||||
jwtConfig = new JWTConfig(jwtConfigProperties);
|
||||
}
|
||||
Map<String, String> customClaims = new HashMap<>();
|
||||
customClaims.put(SIGNED_JWT_AUTH_USERNAME, "admin");
|
||||
customClaims.put(SIGNED_JWT_AUTH_TENANT_ID, String.valueOf(MultitenantConstants.SUPER_TENANT_ID));
|
||||
jwtToken = JWTClientUtil.generateSignedJWTAssertion("admin", jwtConfig, false, customClaims);
|
||||
customClaims = new HashMap<>();
|
||||
customClaims.put(SIGNED_JWT_AUTH_USERNAME, "admin");
|
||||
customClaims.put(SIGNED_JWT_AUTH_TENANT_ID, "-1");
|
||||
wrongJwtToken = JWTClientUtil.generateSignedJWTAssertion("admin", jwtConfig, false, customClaims);
|
||||
customClaims = new HashMap<>();
|
||||
customClaims.put(SIGNED_JWT_AUTH_USERNAME, "notexisting");
|
||||
customClaims.put(SIGNED_JWT_AUTH_TENANT_ID, String.valueOf(MultitenantConstants.SUPER_TENANT_ID));
|
||||
jwtTokenWithWrongUser = JWTClientUtil.generateSignedJWTAssertion("notexisting", jwtConfig, false, customClaims);
|
||||
}
|
||||
|
||||
@Test(description = "This method tests the get methods in the JWTAuthenticator",
|
||||
dependsOnMethods = "testAuthenticate")
|
||||
public void testGetMethods() {
|
||||
Assert.assertEquals(jwtAuthenticator.getName(), "JWT", "GetName method returns wrong value");
|
||||
Assert.assertNotNull(jwtAuthenticator.getProperties(), "Properties are not properly added to JWT "
|
||||
+ "Authenticator");
|
||||
Assert.assertEquals(jwtAuthenticator.getProperties().size(), properties.size(),
|
||||
"Added properties do not match with retrieved properties");
|
||||
Assert.assertNull(jwtAuthenticator.getProperty("test"), "Retrieved a propety that was never added");
|
||||
Assert.assertNotNull(jwtAuthenticator.getProperty(ISSUER), ALIAS);
|
||||
}
|
||||
|
||||
@Test(description = "This method tests the canHandle method under different conditions of request")
|
||||
public void testHandle() throws IllegalAccessException, NoSuchFieldException {
|
||||
Request request = new Request();
|
||||
org.apache.coyote.Request coyoteRequest = new org.apache.coyote.Request();
|
||||
request.setCoyoteRequest(coyoteRequest);
|
||||
Assert.assertFalse(jwtAuthenticator.canHandle(request));
|
||||
MimeHeaders mimeHeaders = new MimeHeaders();
|
||||
MessageBytes bytes = mimeHeaders.addValue(JWT_HEADER);
|
||||
bytes.setString("test");
|
||||
headersField.set(coyoteRequest, mimeHeaders);
|
||||
request.setCoyoteRequest(coyoteRequest);
|
||||
Assert.assertTrue(jwtAuthenticator.canHandle(request));
|
||||
}
|
||||
|
||||
@Test(description = "This method tests authenticate method under the successful condition", dependsOnMethods =
|
||||
{ "testAuthenticateFailureScenarios" })
|
||||
public void testAuthenticate() throws IllegalAccessException, NoSuchFieldException {
|
||||
Request request = createJWTRequest(jwtToken, "test");
|
||||
AuthenticationInfo authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo.getUsername(), "Proper authentication request is not properly "
|
||||
+ "authenticated by the JWTAuthenticator");
|
||||
}
|
||||
|
||||
@Test(description = "This method tests the authenticate method under failure conditions")
|
||||
public void testAuthenticateFailureScenarios() throws NoSuchFieldException, IllegalAccessException {
|
||||
Request request = createJWTRequest("test", "");
|
||||
AuthenticationInfo authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Returned authentication info was null");
|
||||
Assert.assertNull(authenticationInfo.getUsername(), "Un-authenticated request contain username");
|
||||
request = createJWTRequest(jwtToken, "");
|
||||
authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Returned authentication info was null");
|
||||
Assert.assertNull(authenticationInfo.getUsername(), "Un-authenticated request contain username");
|
||||
properties = new Properties();
|
||||
properties.setProperty(ISSUER, "test");
|
||||
jwtAuthenticator.setProperties(properties);
|
||||
request = createJWTRequest(jwtToken, "");
|
||||
authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Returned authentication info was null");
|
||||
Assert.assertEquals(authenticationInfo.getStatus(), WebappAuthenticator.Status.FAILURE,
|
||||
"Un authenticated request does not contain status as failure");
|
||||
properties = new Properties();
|
||||
properties.setProperty(ISSUER, ALIAS);
|
||||
jwtAuthenticator.setProperties(properties);
|
||||
request = createJWTRequest(wrongJwtToken, "");
|
||||
authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Returned authentication info was null");
|
||||
Assert.assertEquals(authenticationInfo.getStatus(), WebappAuthenticator.Status.FAILURE,
|
||||
"Un authenticated request does not contain status as failure");
|
||||
request = createJWTRequest(jwtTokenWithWrongUser, "");
|
||||
authenticationInfo = jwtAuthenticator.authenticate(request, null);
|
||||
Assert.assertNotNull(authenticationInfo, "Returned authentication info was null");
|
||||
Assert.assertEquals(authenticationInfo.getStatus(), WebappAuthenticator.Status.FAILURE,
|
||||
"Un authenticated request does not contain status as failure");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* To create a JWT request with the given jwt header.
|
||||
* @param jwtToken JWT token to be added to the header
|
||||
* @param requestUri Request URI to be added to the request.
|
||||
*/
|
||||
private Request createJWTRequest(String jwtToken, String requestUri)
|
||||
throws IllegalAccessException, NoSuchFieldException {
|
||||
Request request = new Request();
|
||||
org.apache.coyote.Request coyoteRequest = new org.apache.coyote.Request();
|
||||
MimeHeaders mimeHeaders = new MimeHeaders();
|
||||
MessageBytes bytes = mimeHeaders.addValue(JWT_HEADER);
|
||||
bytes.setString(jwtToken);
|
||||
headersField.set(coyoteRequest, mimeHeaders);
|
||||
Field uriMB = org.apache.coyote.Request.class.getDeclaredField("uriMB");
|
||||
uriMB.setAccessible(true);
|
||||
bytes = MessageBytes.newInstance();
|
||||
bytes.setString(requestUri);
|
||||
uriMB.set(coyoteRequest, bytes);
|
||||
request.setCoyoteRequest(coyoteRequest);
|
||||
return request;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.internal;
|
||||
|
||||
import org.apache.sling.testing.mock.osgi.MockOsgi;
|
||||
import org.testng.annotations.Test;
|
||||
|
||||
/**
|
||||
* This is a test class for {@link WebappAuthenticatorFrameworkServiceComponent}
|
||||
*/
|
||||
public class WebappAuthenticatorFrameworkServiceComponentTest {
|
||||
|
||||
@Test(description = "This method tests whether the bundle activator does not throw any exceptions, even under "
|
||||
+ "possible exception scenarios")
|
||||
public void testActivateWithException() {
|
||||
WebappAuthenticatorFrameworkServiceComponent webappAuthenticatorFrameworkServiceComponent = new
|
||||
WebappAuthenticatorFrameworkServiceComponent();
|
||||
webappAuthenticatorFrameworkServiceComponent.activate(null);
|
||||
}
|
||||
|
||||
@Test(description = "This method tests whether bundle activation succeed with the proper confitions.")
|
||||
public void testActivateWithoutExceptions() {
|
||||
WebappAuthenticatorFrameworkServiceComponent webappAuthenticatorFrameworkServiceComponent = new
|
||||
WebappAuthenticatorFrameworkServiceComponent();
|
||||
webappAuthenticatorFrameworkServiceComponent.activate(MockOsgi.newComponentContext());
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,125 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.util;
|
||||
|
||||
import org.bouncycastle.cert.X509v3CertificateBuilder;
|
||||
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
|
||||
import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
|
||||
import org.bouncycastle.jce.provider.BouncyCastleProvider;
|
||||
import org.bouncycastle.operator.ContentSigner;
|
||||
import org.bouncycastle.operator.OperatorCreationException;
|
||||
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
|
||||
import org.wso2.carbon.certificate.mgt.core.bean.Certificate;
|
||||
import org.wso2.carbon.certificate.mgt.core.exception.KeystoreException;
|
||||
import org.wso2.carbon.certificate.mgt.core.impl.CertificateGenerator;
|
||||
import org.wso2.carbon.certificate.mgt.core.util.CertificateManagementConstants;
|
||||
import org.wso2.carbon.certificate.mgt.core.util.CommonUtil;
|
||||
import org.wso2.carbon.context.PrivilegedCarbonContext;
|
||||
|
||||
import javax.security.auth.x500.X500Principal;
|
||||
import java.math.BigInteger;
|
||||
import java.security.InvalidKeyException;
|
||||
import java.security.KeyPair;
|
||||
import java.security.KeyPairGenerator;
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.security.NoSuchProviderException;
|
||||
import java.security.SecureRandom;
|
||||
import java.security.Security;
|
||||
import java.security.SignatureException;
|
||||
import java.security.cert.CertificateException;
|
||||
import java.security.cert.CertificateExpiredException;
|
||||
import java.security.cert.CertificateNotYetValidException;
|
||||
import java.security.cert.X509Certificate;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* This is a mock implementation of {@link CertificateGenerator}.
|
||||
*/
|
||||
public class TestCertificateGenerator extends CertificateGenerator {
|
||||
private int count = 0;
|
||||
|
||||
public X509Certificate generateX509Certificate() throws KeystoreException {
|
||||
BigInteger serialNumber = CommonUtil.generateSerialNumber();
|
||||
String defaultPrinciple = "CN=" + serialNumber + ",O=WSO2,OU=Mobile,C=LK";
|
||||
CommonUtil commonUtil = new CommonUtil();
|
||||
Date validityBeginDate = commonUtil.getValidityStartDate();
|
||||
Date validityEndDate = commonUtil.getValidityEndDate();
|
||||
Security.addProvider(new BouncyCastleProvider());
|
||||
|
||||
try {
|
||||
KeyPairGenerator keyPairGenerator = KeyPairGenerator
|
||||
.getInstance(CertificateManagementConstants.RSA, CertificateManagementConstants.PROVIDER);
|
||||
keyPairGenerator.initialize(CertificateManagementConstants.RSA_KEY_LENGTH, new SecureRandom());
|
||||
KeyPair pair = keyPairGenerator.generateKeyPair();
|
||||
X500Principal principal = new X500Principal(defaultPrinciple);
|
||||
X509v3CertificateBuilder certificateBuilder = new JcaX509v3CertificateBuilder(principal, serialNumber,
|
||||
validityBeginDate, validityEndDate, principal, pair.getPublic());
|
||||
ContentSigner contentSigner = new JcaContentSignerBuilder(CertificateManagementConstants.SHA256_RSA)
|
||||
.setProvider(CertificateManagementConstants.PROVIDER).build(pair.getPrivate());
|
||||
X509Certificate certificate = new JcaX509CertificateConverter()
|
||||
.setProvider(CertificateManagementConstants.PROVIDER)
|
||||
.getCertificate(certificateBuilder.build(contentSigner));
|
||||
certificate.verify(certificate.getPublicKey());
|
||||
List<Certificate> certificates = new ArrayList<>();
|
||||
org.wso2.carbon.certificate.mgt.core.bean.Certificate certificateToStore =
|
||||
new org.wso2.carbon.certificate.mgt.core.bean.Certificate();
|
||||
certificateToStore.setTenantId(PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId());
|
||||
certificateToStore.setCertificate(certificate);
|
||||
certificates.add(certificateToStore);
|
||||
saveCertInKeyStore(certificates);
|
||||
return certificate;
|
||||
} catch (NoSuchAlgorithmException e) {
|
||||
String errorMsg = "No such algorithm found when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (NoSuchProviderException e) {
|
||||
String errorMsg = "No such provider found when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (OperatorCreationException e) {
|
||||
String errorMsg = "Issue in operator creation when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (CertificateExpiredException e) {
|
||||
String errorMsg = "Certificate expired after generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (CertificateNotYetValidException e) {
|
||||
String errorMsg = "Certificate not yet valid when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (CertificateException e) {
|
||||
String errorMsg = "Certificate issue occurred when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (InvalidKeyException e) {
|
||||
String errorMsg = "Invalid key used when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
} catch (SignatureException e) {
|
||||
String errorMsg = "Signature related issue occurred when generating certificate";
|
||||
throw new KeystoreException(errorMsg, e);
|
||||
}
|
||||
}
|
||||
|
||||
public String extractChallengeToken(X509Certificate certificate) {
|
||||
if (count != 0) {
|
||||
return "WSO2 (Challenge)";
|
||||
} else {
|
||||
count++;
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.util;
|
||||
|
||||
import org.wso2.carbon.registry.indexing.service.TenantIndexingLoader;
|
||||
|
||||
/**
|
||||
* This is a mock implementation of {@link TenantIndexingLoader}
|
||||
*/
|
||||
public class TestTenantIndexingLoader implements TenantIndexingLoader {
|
||||
@Override
|
||||
public void loadTenantIndex(int i) { }
|
||||
}
|
||||
@ -0,0 +1,30 @@
|
||||
/*
|
||||
* 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.webapp.authenticator.framework.util;
|
||||
|
||||
import org.wso2.carbon.registry.core.exceptions.RegistryException;
|
||||
import org.wso2.carbon.registry.core.service.TenantRegistryLoader;
|
||||
|
||||
/**
|
||||
* This is a mock implementation of {@link TenantRegistryLoader} for the test cases.
|
||||
*/
|
||||
public class TestTenantRegistryLoader implements TenantRegistryLoader {
|
||||
@Override
|
||||
public void loadTenantRegistry(int i) throws RegistryException { }
|
||||
}
|
||||
@ -0,0 +1,96 @@
|
||||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!--
|
||||
~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
|
||||
~
|
||||
~ WSO2 Inc. licenses this file to you under the Apache License,
|
||||
~ Version 2.0 (the "License"); you may not use this file except
|
||||
~ in compliance with the License.
|
||||
~ you may obtain a copy of the License at
|
||||
~
|
||||
~ http://www.apache.org/licenses/LICENSE-2.0
|
||||
~
|
||||
~ Unless required by applicable law or agreed to in writing,
|
||||
~ software distributed under the License is distributed on an
|
||||
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
~ KIND, either express or implied. See the License for the
|
||||
~ specific language governing permissions and limitations
|
||||
~ under the License.
|
||||
-->
|
||||
|
||||
<DeviceMgtConfiguration>
|
||||
<ManagementRepository>
|
||||
<DataSourceConfiguration>
|
||||
<JndiLookupDefinition>
|
||||
<Name>jdbc/DM_DS</Name>
|
||||
</JndiLookupDefinition>
|
||||
</DataSourceConfiguration>
|
||||
</ManagementRepository>
|
||||
<PushNotificationConfiguration>
|
||||
<SchedulerBatchSize>1000</SchedulerBatchSize>
|
||||
<SchedulerBatchDelayMills>60000</SchedulerBatchDelayMills>
|
||||
<SchedulerTaskInitialDelay>60000</SchedulerTaskInitialDelay>
|
||||
<SchedulerTaskEnabled>true</SchedulerTaskEnabled>
|
||||
<PushNotificationProviders>
|
||||
<Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.fcm.FCMBasedPushNotificationProvider</Provider>
|
||||
<!--<Provider>org.wso2.carbon.device.mgt.mobile.impl.ios.apns.APNSBasedPushNotificationProvider</Provider>-->
|
||||
<Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.mqtt.MQTTBasedPushNotificationProvider</Provider>
|
||||
<Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.http.HTTPBasedPushNotificationProvider</Provider>
|
||||
<Provider>org.wso2.carbon.device.mgt.extensions.push.notification.provider.xmpp.XMPPBasedPushNotificationProvider</Provider>
|
||||
</PushNotificationProviders>
|
||||
</PushNotificationConfiguration>
|
||||
<PullNotificationConfiguration>
|
||||
<Enabled>false</Enabled>
|
||||
</PullNotificationConfiguration>
|
||||
<IdentityConfiguration>
|
||||
<ServerUrl>https://localhost:9443</ServerUrl>
|
||||
<AdminUsername>admin</AdminUsername>
|
||||
<AdminPassword>admin</AdminPassword>
|
||||
</IdentityConfiguration>
|
||||
<PolicyConfiguration>
|
||||
<MonitoringClass>org.wso2.carbon.policy.mgt</MonitoringClass>
|
||||
<MonitoringEnable>true</MonitoringEnable>
|
||||
<MonitoringFrequency>60000</MonitoringFrequency>
|
||||
<MaxRetries>5</MaxRetries>
|
||||
<MinRetriesToMarkUnreachable>8</MinRetriesToMarkUnreachable>
|
||||
<MinRetriesToMarkInactive>20</MinRetriesToMarkInactive>
|
||||
<!--Set the policy evaluation point name-->
|
||||
<!--Simple -> Simple policy evaluation point-->
|
||||
<!--Merged -> Merged policy evaluation point -->
|
||||
<PolicyEvaluationPoint>Simple</PolicyEvaluationPoint>
|
||||
</PolicyConfiguration>
|
||||
<!-- Default Page size configuration for paginated DM APIs-->
|
||||
<PaginationConfiguration>
|
||||
<DeviceListPageSize>20</DeviceListPageSize>
|
||||
<GroupListPageSize>20</GroupListPageSize>
|
||||
<NotificationListPageSize>20</NotificationListPageSize>
|
||||
<ActivityListPageSize>20</ActivityListPageSize>
|
||||
<OperationListPageSize>20</OperationListPageSize>
|
||||
<TopicListPageSize>20</TopicListPageSize>
|
||||
</PaginationConfiguration>
|
||||
<!--This specifies whether to enable the DeviceStatus Task in this node. In clustered setup only master node
|
||||
should have to run this task.-->
|
||||
<DeviceStatusTaskConfig>
|
||||
<Enable>true</Enable>
|
||||
</DeviceStatusTaskConfig>
|
||||
<!--This controls the in-memory device cache which is local to this node. Setting it enable will activate the
|
||||
device caching for upto configured expiry-time in seconds. In clustered setup all worker nodes can enable the
|
||||
device-cache to improve performance. -->
|
||||
<DeviceCacheConfiguration>
|
||||
<Enable>true</Enable>
|
||||
<ExpiryTime>600</ExpiryTime>
|
||||
<!--This configuration specifies the number of cache entries in device cache. default capacity is 10000 entries.
|
||||
This can be configured to higher number if cache eviction happens due to large number of devices in the
|
||||
server environment-->
|
||||
<Capacity>10000</Capacity>
|
||||
</DeviceCacheConfiguration>
|
||||
<CertificateCacheConfiguration>
|
||||
<Enable>false</Enable>
|
||||
<ExpiryTime>86400</ExpiryTime>
|
||||
</CertificateCacheConfiguration>
|
||||
<GeoLocationConfiguration>
|
||||
<isEnabled>false</isEnabled>
|
||||
<PublishLocationOperationResponse>false</PublishLocationOperationResponse>
|
||||
</GeoLocationConfiguration>
|
||||
<DefaultGroupsConfiguration>BYOD,COPE</DefaultGroupsConfiguration>
|
||||
</DeviceMgtConfiguration>
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@ -0,0 +1,57 @@
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
|
||||
#issuer of the JWT
|
||||
iss=wso2.org/products/iot
|
||||
|
||||
TokenEndpoint=https://${iot.gateway.host}:${iot.gateway.https.port}/token?tenantDomain=carbon.super
|
||||
|
||||
#audience of JWT claim
|
||||
#comma seperated values
|
||||
aud=devicemgt
|
||||
|
||||
#expiration time of JWT (number of minutes from the current time)
|
||||
exp=1000
|
||||
|
||||
#issued at time of JWT (number of minutes from the current time)
|
||||
iat=0
|
||||
|
||||
#nbf time of JWT (number of minutes from current time)
|
||||
nbf=0
|
||||
|
||||
#skew between IDP and issuer(seconds)
|
||||
skew=0
|
||||
|
||||
# JWT Id
|
||||
#jti=token123
|
||||
|
||||
#KeyStore to cryptographic credentials
|
||||
KeyStore=target/test-classes/carbon-home/repository/resources/security/wso2carbon.jks
|
||||
|
||||
#Password of the KeyStore
|
||||
KeyStorePassword=wso2carbon
|
||||
|
||||
#Alias of the SP's private key
|
||||
PrivateKeyAlias=wso2carbon
|
||||
|
||||
#Private key password to retrieve the private key used to sign
|
||||
#AuthnRequest and LogoutRequest messages
|
||||
PrivateKeyPassword=wso2carbon
|
||||
|
||||
#this will be used as the default IDP config if there isn't any config available for tenants.
|
||||
default-jwt-client=false
|
||||
@ -0,0 +1,25 @@
|
||||
--
|
||||
-- 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.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE (
|
||||
ID INTEGER auto_increment NOT NULL,
|
||||
SERIAL_NUMBER VARCHAR(500) DEFAULT NULL,
|
||||
CERTIFICATE BLOB DEFAULT NULL,
|
||||
TENANT_ID INTEGER DEFAULT 0,
|
||||
USERNAME VARCHAR(500) DEFAULT NULL,
|
||||
PRIMARY KEY (ID)
|
||||
);
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue