http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java new file mode 100644 index 0000000..b523552 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java @@ -0,0 +1,872 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF 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.apache.ranger.rest; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.servlet.http.HttpServletRequest; +import org.apache.commons.lang.StringUtils; +import org.apache.ranger.admin.client.datatype.RESTResponse; +import org.apache.ranger.biz.RangerBizUtil; +import org.apache.ranger.biz.ServiceDBStore; +import org.apache.ranger.biz.ServiceMgr; +import org.apache.ranger.biz.XUserMgr; +import org.apache.ranger.common.ContextUtil; +import org.apache.ranger.common.RESTErrorUtil; +import org.apache.ranger.common.RangerSearchUtil; +import org.apache.ranger.common.ServiceUtil; +import org.apache.ranger.common.StringUtil; +import org.apache.ranger.common.UserSessionBase; +import org.apache.ranger.db.RangerDaoManager; +import org.apache.ranger.entity.XXDBBase; +import org.apache.ranger.plugin.model.RangerPolicy; +import org.apache.ranger.plugin.model.RangerService; +import org.apache.ranger.plugin.model.RangerServiceDef; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerAccessTypeDef; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerContextEnricherDef; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerEnumDef; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerPolicyConditionDef; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerResourceDef; +import org.apache.ranger.plugin.model.RangerServiceDef.RangerServiceConfigDef; +import org.apache.ranger.plugin.model.validation.RangerPolicyValidator; +import org.apache.ranger.plugin.model.validation.RangerServiceDefValidator; +import org.apache.ranger.plugin.model.validation.RangerServiceValidator; +import org.apache.ranger.plugin.model.validation.RangerValidatorFactory; +import org.apache.ranger.plugin.service.ResourceLookupContext; +import org.apache.ranger.plugin.util.GrantRevokeRequest; +import org.apache.ranger.plugin.util.SearchFilter; +import org.apache.ranger.plugin.util.ServicePolicies; +import org.apache.ranger.security.context.RangerContextHolder; +import org.apache.ranger.security.context.RangerSecurityContext; +import org.apache.ranger.service.RangerAuditFields; +import org.apache.ranger.service.RangerDataHistService; +import org.apache.ranger.service.RangerPolicyService; +import org.apache.ranger.service.RangerServiceDefService; +import org.apache.ranger.service.RangerServiceService; +import org.apache.ranger.service.XUserService; +import org.apache.ranger.view.RangerPolicyList; +import org.apache.ranger.view.RangerServiceDefList; +import org.apache.ranger.view.RangerServiceList; +import org.apache.ranger.view.VXResponse; +import org.apache.ranger.view.VXString; +import org.junit.Assert; +import org.junit.FixMethodOrder; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class TestServiceREST { + + private static Long Id = 8L; + + @InjectMocks + ServiceREST serviceREST = new ServiceREST(); + + @Mock + RangerValidatorFactory validatorFactory; + + @Mock + RangerDaoManager daoManager; + + @Mock + ServiceDBStore svcStore; + + @Mock + RangerServiceService svcService; + + @Mock + RangerDataHistService dataHistService; + + @Mock + RangerServiceDefService serviceDefService; + + @Mock + RangerPolicyService policyService; + + @Mock + StringUtil stringUtil; + + @Mock + XUserService xUserService; + + @Mock + XUserMgr xUserMgr; + + @Mock + RangerAuditFields<XXDBBase> rangerAuditFields; + + @Mock + ContextUtil contextUtil; + + @Mock + RangerBizUtil bizUtil; + + @Mock + RESTErrorUtil restErrorUtil; + + @Mock + RangerServiceDefValidator serviceDefValidator; + + @Mock + RangerServiceValidator serviceValidator; + + @Mock + RangerPolicyValidator policyValidator; + + @Mock + ServiceMgr serviceMgr; + + @Mock + VXResponse vXResponse; + + @Mock + ServiceUtil serviceUtil; + + @Mock + RangerSearchUtil searchUtil; + + @Mock + StringUtils stringUtils; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + public void setup() { + RangerSecurityContext context = new RangerSecurityContext(); + context.setUserSession(new UserSessionBase()); + RangerContextHolder.setSecurityContext(context); + UserSessionBase currentUserSession = ContextUtil + .getCurrentUserSession(); + currentUserSession.setUserAdmin(true); + } + + private RangerServiceDef rangerServiceDef() { + List<RangerServiceConfigDef> configs = new ArrayList<RangerServiceConfigDef>(); + List<RangerResourceDef> resources = new ArrayList<RangerResourceDef>(); + List<RangerAccessTypeDef> accessTypes = new ArrayList<RangerAccessTypeDef>(); + List<RangerPolicyConditionDef> policyConditions = new ArrayList<RangerPolicyConditionDef>(); + List<RangerContextEnricherDef> contextEnrichers = new ArrayList<RangerContextEnricherDef>(); + List<RangerEnumDef> enums = new ArrayList<RangerEnumDef>(); + + RangerServiceDef rangerServiceDef = new RangerServiceDef(); + rangerServiceDef.setId(Id); + rangerServiceDef.setImplClass("RangerServiceHdfs"); + rangerServiceDef.setLabel("HDFS Repository"); + rangerServiceDef.setDescription("HDFS Repository"); + rangerServiceDef.setRbKeyDescription(null); + rangerServiceDef.setUpdatedBy("Admin"); + rangerServiceDef.setUpdateTime(new Date()); + rangerServiceDef.setConfigs(configs); + rangerServiceDef.setResources(resources); + rangerServiceDef.setAccessTypes(accessTypes); + rangerServiceDef.setPolicyConditions(policyConditions); + rangerServiceDef.setContextEnrichers(contextEnrichers); + rangerServiceDef.setEnums(enums); + + return rangerServiceDef; + } + + private RangerService rangerService() { + Map<String, String> configs = new HashMap<String, String>(); + configs.put("username", "servicemgr"); + configs.put("password", "servicemgr"); + configs.put("namenode", "servicemgr"); + configs.put("hadoop.security.authorization", "No"); + configs.put("hadoop.security.authentication", "Simple"); + configs.put("hadoop.security.auth_to_local", ""); + configs.put("dfs.datanode.kerberos.principal", ""); + configs.put("dfs.namenode.kerberos.principal", ""); + configs.put("dfs.secondary.namenode.kerberos.principal", ""); + configs.put("hadoop.rpc.protection", "Privacy"); + configs.put("commonNameForCertificate", ""); + + RangerService rangerService = new RangerService(); + rangerService.setId(Id); + rangerService.setConfigs(configs); + rangerService.setCreateTime(new Date()); + rangerService.setDescription("service policy"); + rangerService.setGuid("1427365526516_835_0"); + rangerService.setIsEnabled(true); + rangerService.setName("HDFS_1"); + rangerService.setPolicyUpdateTime(new Date()); + rangerService.setType("1"); + rangerService.setUpdatedBy("Admin"); + rangerService.setUpdateTime(new Date()); + + return rangerService; + } + + private RangerPolicy rangerPolicy() { + List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>(); + List<String> users = new ArrayList<String>(); + List<String> groups = new ArrayList<String>(); + List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>(); + List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>(); + RangerPolicyItem rangerPolicyItem = new RangerPolicyItem(); + rangerPolicyItem.setAccesses(accesses); + rangerPolicyItem.setConditions(conditions); + rangerPolicyItem.setGroups(groups); + rangerPolicyItem.setUsers(users); + rangerPolicyItem.setDelegateAdmin(false); + + policyItems.add(rangerPolicyItem); + + Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>(); + RangerPolicyResource rangerPolicyResource = new RangerPolicyResource(); + rangerPolicyResource.setIsExcludes(true); + rangerPolicyResource.setIsRecursive(true); + rangerPolicyResource.setValue("1"); + rangerPolicyResource.setValues(users); + RangerPolicy policy = new RangerPolicy(); + policy.setId(Id); + policy.setCreateTime(new Date()); + policy.setDescription("policy"); + policy.setGuid("policyguid"); + policy.setIsEnabled(true); + policy.setName("HDFS_1-1-20150316062453"); + policy.setUpdatedBy("Admin"); + policy.setUpdateTime(new Date()); + policy.setService("HDFS_1-1-20150316062453"); + policy.setIsAuditEnabled(true); + policy.setPolicyItems(policyItems); + policy.setResources(policyResource); + + return policy; + } + + @Test + public void test1createServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + + Mockito.when( + svcStore.createServiceDef((RangerServiceDef) Mockito + .anyObject())).thenReturn(rangerServiceDef); + + RangerServiceDef dbRangerServiceDef = serviceREST + .createServiceDef(rangerServiceDef); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Assert.assertEquals(dbRangerServiceDef.getImplClass(), + rangerServiceDef.getImplClass()); + Assert.assertEquals(dbRangerServiceDef.getLabel(), + rangerServiceDef.getLabel()); + Assert.assertEquals(dbRangerServiceDef.getDescription(), + rangerServiceDef.getDescription()); + Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), + rangerServiceDef.getRbKeyDescription()); + Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), + rangerServiceDef.getUpdatedBy()); + Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), + rangerServiceDef.getUpdateTime()); + Assert.assertEquals(dbRangerServiceDef.getVersion(), + rangerServiceDef.getVersion()); + Assert.assertEquals(dbRangerServiceDef.getConfigs(), + rangerServiceDef.getConfigs()); + + Mockito.verify(validatorFactory).getServiceDefValidator(svcStore); + Mockito.verify(svcStore).createServiceDef(rangerServiceDef); + } + + @Test + public void test2updateServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + + Mockito.when( + svcStore.updateServiceDef((RangerServiceDef) Mockito + .anyObject())).thenReturn(rangerServiceDef); + + RangerServiceDef dbRangerServiceDef = serviceREST + .updateServiceDef(rangerServiceDef); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Assert.assertEquals(dbRangerServiceDef.getImplClass(), + rangerServiceDef.getImplClass()); + Assert.assertEquals(dbRangerServiceDef.getLabel(), + rangerServiceDef.getLabel()); + Assert.assertEquals(dbRangerServiceDef.getDescription(), + rangerServiceDef.getDescription()); + Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(), + rangerServiceDef.getRbKeyDescription()); + Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(), + rangerServiceDef.getUpdatedBy()); + Assert.assertEquals(dbRangerServiceDef.getUpdateTime(), + rangerServiceDef.getUpdateTime()); + Assert.assertEquals(dbRangerServiceDef.getVersion(), + rangerServiceDef.getVersion()); + Assert.assertEquals(dbRangerServiceDef.getConfigs(), + rangerServiceDef.getConfigs()); + + Mockito.verify(validatorFactory).getServiceDefValidator(svcStore); + Mockito.verify(svcStore).updateServiceDef(rangerServiceDef); + } + + @Test + public void test3deleteServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + serviceREST.deleteServiceDef(rangerServiceDef.getId()); + Mockito.verify(validatorFactory).getServiceDefValidator(svcStore); + } + + @Test + public void test4getServiceDefById() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + Mockito.when(svcStore.getServiceDef(rangerServiceDef.getId())) + .thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = serviceREST + .getServiceDef(rangerServiceDef.getId()); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Mockito.verify(svcStore).getServiceDef(rangerServiceDef.getId()); + } + + @Test + public void test5getServiceDefByName() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + Mockito.when(svcStore.getServiceDefByName(rangerServiceDef.getName())) + .thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = serviceREST + .getServiceDefByName(rangerServiceDef.getName()); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(svcStore) + .getServiceDefByName(rangerServiceDef.getName()); + } + + @Test + public void test6getServiceDefs() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + RangerServiceDefList dbRangerServiceDef = serviceREST + .getServiceDefs(request); + Assert.assertNull(dbRangerServiceDef); + } + + @Test + public void test7createService() throws Exception { + + RangerService rangerService = rangerService(); + Mockito.when(validatorFactory.getServiceValidator(svcStore)) + .thenReturn(serviceValidator); + Mockito.when( + svcStore.createService((RangerService) Mockito.anyObject())) + .thenReturn(rangerService); + + RangerService dbRangerService = serviceREST + .createService(rangerService); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(rangerService, dbRangerService); + Assert.assertEquals(rangerService.getId(), dbRangerService.getId()); + Assert.assertEquals(rangerService.getConfigs(), + dbRangerService.getConfigs()); + Assert.assertEquals(rangerService.getDescription(), + dbRangerService.getDescription()); + Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid()); + Assert.assertEquals(rangerService.getName(), dbRangerService.getName()); + Assert.assertEquals(rangerService.getPolicyVersion(), + dbRangerService.getPolicyVersion()); + Assert.assertEquals(rangerService.getType(), dbRangerService.getType()); + Assert.assertEquals(rangerService.getVersion(), + dbRangerService.getVersion()); + Assert.assertEquals(rangerService.getCreateTime(), + dbRangerService.getCreateTime()); + Assert.assertEquals(rangerService.getUpdateTime(), + dbRangerService.getUpdateTime()); + Assert.assertEquals(rangerService.getUpdatedBy(), + dbRangerService.getUpdatedBy()); + + Mockito.verify(validatorFactory).getServiceValidator(svcStore); + Mockito.verify(svcStore).createService(rangerService); + } + + @Test + public void test8updateServiceDef() throws Exception { + + RangerService rangerService = rangerService(); + Mockito.when(validatorFactory.getServiceValidator(svcStore)) + .thenReturn(serviceValidator); + + Mockito.when( + svcStore.updateService((RangerService) Mockito.anyObject())) + .thenReturn(rangerService); + + RangerService dbRangerService = serviceREST + .updateService(rangerService); + Assert.assertNotNull(dbRangerService); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(rangerService, dbRangerService); + Assert.assertEquals(rangerService.getId(), dbRangerService.getId()); + Assert.assertEquals(rangerService.getConfigs(), + dbRangerService.getConfigs()); + Assert.assertEquals(rangerService.getDescription(), + dbRangerService.getDescription()); + Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid()); + Assert.assertEquals(rangerService.getName(), dbRangerService.getName()); + Assert.assertEquals(rangerService.getPolicyVersion(), + dbRangerService.getPolicyVersion()); + Assert.assertEquals(rangerService.getType(), dbRangerService.getType()); + Assert.assertEquals(rangerService.getVersion(), + dbRangerService.getVersion()); + Assert.assertEquals(rangerService.getCreateTime(), + dbRangerService.getCreateTime()); + Assert.assertEquals(rangerService.getUpdateTime(), + dbRangerService.getUpdateTime()); + Assert.assertEquals(rangerService.getUpdatedBy(), + dbRangerService.getUpdatedBy()); + Mockito.verify(validatorFactory).getServiceValidator(svcStore); + Mockito.verify(svcStore).updateService(rangerService); + } + + @Test + public void test9deleteService() throws Exception { + + RangerService rangerService = rangerService(); + Mockito.when(validatorFactory.getServiceValidator(svcStore)) + .thenReturn(serviceValidator); + serviceREST.deleteService(rangerService.getId()); + + Mockito.verify(validatorFactory).getServiceValidator(svcStore); + } + + @Test + public void test10getServiceById() throws Exception { + RangerService rangerService = rangerService(); + RangerServiceDef rangerServiceDef = rangerServiceDef(); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + serviceREST.deleteServiceDef(rangerServiceDef.getId()); + Mockito.verify(validatorFactory).getServiceDefValidator(svcStore); + Mockito.when(svcStore.getService(rangerService.getId())).thenReturn( + rangerService); + RangerService dbRangerService = serviceREST.getService(rangerService + .getId()); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService.getId(), dbRangerService.getId()); + Mockito.verify(svcStore).getService(dbRangerService.getId()); + } + + @Test + public void test11getServiceByName() throws Exception { + RangerService rangerService = rangerService(); + Mockito.when(svcStore.getServiceByName(rangerService.getName())) + .thenReturn(rangerService); + RangerService dbRangerService = serviceREST + .getServiceByName(rangerService.getName()); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService.getName(), + dbRangerService.getName()); + Mockito.verify(svcStore).getServiceByName(dbRangerService.getName()); + } + + @Test + public void test12deleteServiceDef() throws Exception { + RangerService rangerService = rangerService(); + Mockito.when(serviceMgr.validateConfig(rangerService, svcStore)) + .thenReturn(vXResponse); + VXResponse dbVXResponse = serviceREST.validateConfig(rangerService); + Assert.assertNotNull(dbVXResponse); + RangerServiceDef rangerServiceDef = rangerServiceDef(); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + serviceREST.deleteServiceDef(rangerServiceDef.getId()); + Mockito.verify(validatorFactory).getServiceDefValidator(svcStore); + Mockito.verify(serviceMgr).validateConfig(rangerService, svcStore); + } + + @Test + public void test13lookupResource() throws Exception { + String serviceName = "HDFS_1"; + ResourceLookupContext context = new ResourceLookupContext(); + context.setResourceName(serviceName); + context.setUserInput("HDFS"); + List<String> list = serviceREST.lookupResource(serviceName, context); + Assert.assertNotNull(list); + } + + @Test + public void test14grantAccess() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String serviceName = "HDFS_1"; + GrantRevokeRequest grantRequestObj = new GrantRevokeRequest(); + grantRequestObj.setAccessTypes(null); + grantRequestObj.setDelegateAdmin(true); + grantRequestObj.setEnableAudit(true); + grantRequestObj.setGrantor("read"); + grantRequestObj.setIsRecursive(true); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + Mockito.when( + serviceUtil.isValidateHttpsAuthentication(serviceName, request)) + .thenReturn(false); + RESTResponse restResponse = serviceREST.grantAccess(serviceName, + grantRequestObj, request); + Assert.assertNotNull(restResponse); + Mockito.verify(serviceUtil).isValidateHttpsAuthentication(serviceName, + request); + } + + @Test + public void test15revokeAccess() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String serviceName = "HDFS_1"; + Set<String> userList = new HashSet<String>(); + userList.add("user1"); + userList.add("user2"); + userList.add("user3"); + Set<String> groupList = new HashSet<String>(); + groupList.add("group1"); + groupList.add("group2"); + groupList.add("group3"); + GrantRevokeRequest revokeRequest = new GrantRevokeRequest(); + revokeRequest.setDelegateAdmin(true); + revokeRequest.setEnableAudit(true); + revokeRequest.setGrantor("read"); + revokeRequest.setGroups(groupList); + revokeRequest.setUsers(userList); + + Mockito.when(validatorFactory.getServiceDefValidator(svcStore)) + .thenReturn(serviceDefValidator); + + RESTResponse restResponse = serviceREST.revokeAccess(serviceName, + revokeRequest, request); + Assert.assertNotNull(restResponse); + + } + + @Test + public void test16createPolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(svcStore.createPolicy(rangerPolicy)).thenReturn( + rangerPolicy); + + RangerPolicy dbRangerPolicy = serviceREST.createPolicy(rangerPolicy); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getDescription(), + rangerPolicy.getDescription()); + Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid()); + Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName()); + Assert.assertEquals(dbRangerPolicy.getVersion(), + rangerPolicy.getVersion()); + Assert.assertEquals(dbRangerPolicy.getCreateTime(), + rangerPolicy.getCreateTime()); + Assert.assertEquals(dbRangerPolicy.getUpdateTime(), + rangerPolicy.getUpdateTime()); + Assert.assertEquals(dbRangerPolicy.getUpdatedBy(), + rangerPolicy.getUpdatedBy()); + Assert.assertEquals(dbRangerPolicy.getService(), + rangerPolicy.getService()); + Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(), + rangerPolicy.getIsAuditEnabled()); + Assert.assertEquals(dbRangerPolicy.getPolicyItems(), + rangerPolicy.getPolicyItems()); + Assert.assertEquals(dbRangerPolicy.getResources(), + rangerPolicy.getResources()); + Mockito.verify(svcStore).createPolicy(rangerPolicy); + } + + @Test + public void test17updatePolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(svcStore.updatePolicy(rangerPolicy)).thenReturn( + rangerPolicy); + RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getDescription(), + rangerPolicy.getDescription()); + Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid()); + Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName()); + Assert.assertEquals(dbRangerPolicy.getVersion(), + rangerPolicy.getVersion()); + Assert.assertEquals(dbRangerPolicy.getCreateTime(), + rangerPolicy.getCreateTime()); + Assert.assertEquals(dbRangerPolicy.getUpdateTime(), + rangerPolicy.getUpdateTime()); + Assert.assertEquals(dbRangerPolicy.getUpdatedBy(), + rangerPolicy.getUpdatedBy()); + Assert.assertEquals(dbRangerPolicy.getService(), + rangerPolicy.getService()); + Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(), + rangerPolicy.getIsAuditEnabled()); + Assert.assertEquals(dbRangerPolicy.getPolicyItems(), + rangerPolicy.getPolicyItems()); + Assert.assertEquals(dbRangerPolicy.getResources(), + rangerPolicy.getResources()); + Mockito.verify(svcStore).updatePolicy(rangerPolicy); + } + + @Test + public void test18deletePolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + + Mockito.when(validatorFactory.getPolicyValidator(svcStore)).thenReturn( + policyValidator); + serviceREST.deletePolicy(rangerPolicy.getId()); + Mockito.verify(validatorFactory).getPolicyValidator(svcStore); + } + + @Test + public void test19getPolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(svcStore.getPolicy(rangerPolicy.getId())).thenReturn( + rangerPolicy); + RangerPolicy dbRangerPolicy = serviceREST.getPolicy(rangerPolicy + .getId()); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId()); + Mockito.verify(svcStore).getPolicy(rangerPolicy.getId()); + } + + @Test + public void test20getPolicies() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + searchUtil.getSearchFilter(request, policyService.sortFields)) + .thenReturn(filter); + RangerPolicyList dbRangerPolicy = serviceREST.getPolicies(request); + Assert.assertNull(dbRangerPolicy); + Mockito.verify(searchUtil).getSearchFilter(request, + policyService.sortFields); + } + + @Test + public void test21countPolicies() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicyList ret = Mockito.mock(RangerPolicyList.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + searchUtil.getSearchFilter(request, policyService.sortFields)) + .thenReturn(filter); + + Mockito.when( + svcStore.getPaginatedPolicies(filter)) + .thenReturn(ret); + + Long data = serviceREST.countPolicies(request); + Assert.assertNotNull(data); + Mockito.verify(searchUtil).getSearchFilter(request, + policyService.sortFields); + Mockito.verify(svcStore).getPaginatedPolicies(filter); + } + + + + @Test + public void test22getServicePoliciesById() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + + RangerPolicyList ret = Mockito.mock(RangerPolicyList.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + searchUtil.getSearchFilter(request, policyService.sortFields)) + .thenReturn(filter); + + Mockito.when( + svcStore.getPaginatedServicePolicies(Id,filter)) + .thenReturn(ret); + + + RangerPolicyList dbRangerPolicy = serviceREST.getServicePolicies( + rangerPolicy.getId(), request); + Assert.assertNotNull(dbRangerPolicy); + Mockito.verify(searchUtil).getSearchFilter(request, + policyService.sortFields); + Mockito.verify(svcStore).getPaginatedServicePolicies(Id,filter); + } + + @Test + public void test23getServicePoliciesByName() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + RangerPolicyList ret = Mockito.mock(RangerPolicyList.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + searchUtil.getSearchFilter(request, policyService.sortFields)) + .thenReturn(filter); + + + Mockito.when( + svcStore.getPaginatedServicePolicies(rangerPolicy.getName(),filter)) + .thenReturn(ret); + + RangerPolicyList dbRangerPolicy = serviceREST.getServicePolicies( + rangerPolicy.getName(), request); + Assert.assertNotNull(dbRangerPolicy); + } + + @Test + public void test24getServicePoliciesIfUpdated() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String serviceName = "HDFS_1"; + Long lastKnownVersion = 1L; + String pluginId = "1"; + ServicePolicies dbServicePolicies = serviceREST + .getServicePoliciesIfUpdated(serviceName, lastKnownVersion, + pluginId, request); + Assert.assertNull(dbServicePolicies); + } + + @Test + public void test25getPolicies() throws Exception { + List<RangerPolicy> ret = new ArrayList<RangerPolicy>(); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + svcStore.getPolicies(filter)) + .thenReturn(ret); + + + List<RangerPolicy> dbRangerPolicyList = serviceREST.getPolicies(filter); + Assert.assertNotNull(dbRangerPolicyList); + Mockito.verify(svcStore).getPolicies(filter); + + } + + @Test + public void test26getServices() throws Exception { + List<RangerService> ret = new ArrayList<RangerService>(); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + svcStore.getServices(filter)) + .thenReturn(ret); + + List<RangerService> dbRangerService = serviceREST.getServices(filter); + Assert.assertNotNull(dbRangerService); + Mockito.verify(svcStore).getServices(filter); + } + + @Test + public void test30getPolicyFromEventTime() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + Mockito.when(request.getParameter("eventTime")).thenReturn( + new Date().toString()); + Mockito.when(request.getParameter("policyId")).thenReturn("1"); + + RangerPolicy dbRangerPolicy = serviceREST + .getPolicyFromEventTime(request); + Assert.assertNull(dbRangerPolicy); + Mockito.verify(request).getParameter("eventTime"); + Mockito.verify(request).getParameter("policyId"); + } + + @Test + public void test31getServices() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + RangerServiceList dbRangerService = serviceREST.getServices(request); + Assert.assertNull(dbRangerService); + } + + @Test + public void test32getPolicyVersionList() throws Exception { + VXString vXString = new VXString(); + vXString.setValue("1"); + Mockito.when(svcStore.getPolicyVersionList(Id)).thenReturn(vXString); + + VXString dbVXString = serviceREST.getPolicyVersionList(Id); + Assert.assertNotNull(dbVXString); + Mockito.verify(svcStore).getPolicyVersionList(Id); + } + + @Test + public void test33getPolicyForVersionNumber() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(svcStore.getPolicyForVersionNumber(Id,1)).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = serviceREST.getPolicyForVersionNumber(Id, 1); + Assert.assertNotNull(dbRangerPolicy); + Mockito.verify(svcStore).getPolicyForVersionNumber(Id,1); + } + + @Test + public void test34countServices() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerServiceList ret = Mockito.mock(RangerServiceList.class); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when( + searchUtil.getSearchFilter(request, policyService.sortFields)) + .thenReturn(filter); + + Mockito.when( + svcStore.getPaginatedServices(filter)) + .thenReturn(ret); + Long data = serviceREST.countServices(request); + Assert.assertNotNull(data); + Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields); + Mockito.verify(svcStore).getPaginatedServices(filter); + } + +}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java new file mode 100644 index 0000000..bac5261 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java @@ -0,0 +1,1007 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF 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.apache.ranger.service; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.ranger.common.ContextUtil; +import org.apache.ranger.common.JSONUtil; +import org.apache.ranger.common.StringUtil; +import org.apache.ranger.common.UserSessionBase; +import org.apache.ranger.db.RangerDaoManager; +import org.apache.ranger.db.XXAccessTypeDefDao; +import org.apache.ranger.db.XXGroupDao; +import org.apache.ranger.db.XXPolicyConditionDefDao; +import org.apache.ranger.db.XXPolicyItemAccessDao; +import org.apache.ranger.db.XXPolicyItemConditionDao; +import org.apache.ranger.db.XXPolicyItemDao; +import org.apache.ranger.db.XXPolicyResourceDao; +import org.apache.ranger.db.XXPolicyResourceMapDao; +import org.apache.ranger.db.XXPortalUserDao; +import org.apache.ranger.db.XXResourceDefDao; +import org.apache.ranger.db.XXServiceConfigMapDao; +import org.apache.ranger.db.XXServiceDao; +import org.apache.ranger.db.XXServiceDefDao; +import org.apache.ranger.db.XXUserDao; +import org.apache.ranger.entity.XXAccessTypeDef; +import org.apache.ranger.entity.XXPolicy; +import org.apache.ranger.entity.XXPolicyConditionDef; +import org.apache.ranger.entity.XXPolicyItem; +import org.apache.ranger.entity.XXPolicyItemAccess; +import org.apache.ranger.entity.XXPolicyItemCondition; +import org.apache.ranger.entity.XXPolicyResource; +import org.apache.ranger.entity.XXPolicyResourceMap; +import org.apache.ranger.entity.XXPortalUser; +import org.apache.ranger.entity.XXResourceDef; +import org.apache.ranger.entity.XXService; +import org.apache.ranger.entity.XXServiceConfigMap; +import org.apache.ranger.entity.XXServiceDef; +import org.apache.ranger.entity.XXTrxLog; +import org.apache.ranger.plugin.model.RangerPolicy; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource; +import org.apache.ranger.security.context.RangerContextHolder; +import org.apache.ranger.security.context.RangerSecurityContext; +import org.junit.Assert; +import org.junit.FixMethodOrder; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class TestRangerPolicyService { + + private static Long Id = 8L; + + @InjectMocks + RangerPolicyService policyService = new RangerPolicyService(); + + @Mock + RangerDaoManager daoManager; + + @Mock + RangerServiceService svcService; + + @Mock + JSONUtil jsonUtil; + + @Mock + RangerServiceDefService serviceDefService; + + @Mock + StringUtil stringUtil; + + @Mock + XUserService xUserService; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + public void setup() { + RangerSecurityContext context = new RangerSecurityContext(); + context.setUserSession(new UserSessionBase()); + RangerContextHolder.setSecurityContext(context); + UserSessionBase currentUserSession = ContextUtil + .getCurrentUserSession(); + currentUserSession.setUserAdmin(true); + } + + private RangerPolicy rangerPolicy() { + List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>(); + List<String> users = new ArrayList<String>(); + List<String> groups = new ArrayList<String>(); + List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>(); + List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>(); + RangerPolicyItem rangerPolicyItem = new RangerPolicyItem(); + rangerPolicyItem.setAccesses(accesses); + rangerPolicyItem.setConditions(conditions); + rangerPolicyItem.setGroups(groups); + rangerPolicyItem.setUsers(users); + rangerPolicyItem.setDelegateAdmin(false); + + policyItems.add(rangerPolicyItem); + + Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>(); + RangerPolicyResource rangerPolicyResource = new RangerPolicyResource(); + rangerPolicyResource.setIsExcludes(true); + rangerPolicyResource.setIsRecursive(true); + rangerPolicyResource.setValue("1"); + rangerPolicyResource.setValues(users); + RangerPolicy policy = new RangerPolicy(); + policy.setId(Id); + policy.setCreateTime(new Date()); + policy.setDescription("policy"); + policy.setGuid("policyguid"); + policy.setIsEnabled(true); + policy.setName("HDFS_1-1-20150316062453"); + policy.setUpdatedBy("Admin"); + policy.setUpdateTime(new Date()); + policy.setService("HDFS_1-1-20150316062453"); + policy.setIsAuditEnabled(true); + policy.setPolicyItems(policyItems); + policy.setResources(policyResource); + + return policy; + } + + private XXPolicy policy() { + XXPolicy xxPolicy = new XXPolicy(); + xxPolicy.setId(Id); + xxPolicy.setName("HDFS_1-1-20150316062453"); + xxPolicy.setAddedByUserId(Id); + xxPolicy.setCreateTime(new Date()); + xxPolicy.setDescription("test"); + xxPolicy.setIsAuditEnabled(false); + xxPolicy.setIsEnabled(false); + xxPolicy.setService(1L); + xxPolicy.setUpdatedByUserId(Id); + xxPolicy.setUpdateTime(new Date()); + return xxPolicy; + } + + private XXService xService() { + XXService xService = new XXService(); + xService.setAddedByUserId(Id); + xService.setCreateTime(new Date()); + xService.setDescription("Hdfs service"); + xService.setGuid("serviceguid"); + xService.setId(Id); + xService.setIsEnabled(true); + xService.setName("Hdfs"); + xService.setPolicyUpdateTime(new Date()); + xService.setPolicyVersion(1L); + xService.setType(1L); + xService.setUpdatedByUserId(Id); + xService.setUpdateTime(new Date()); + xService.setVersion(1L); + + return xService; + } + + @Test + public void test1ValidateForCreate() { + RangerPolicy rangerPolicy = rangerPolicy(); + policyService.validateForCreate(rangerPolicy); + Assert.assertNotNull(rangerPolicy); + } + + @Test + public void test2ValidateForUpdate() { + RangerPolicy rangerPolicy = rangerPolicy(); + XXPolicy policy = policy(); + policyService.validateForUpdate(rangerPolicy, policy); + + Assert.assertNotNull(rangerPolicy); + } + + @Test + public void test3PopulateViewBean() { + XXServiceConfigMapDao xServiceConfigMapDao = Mockito + .mock(XXServiceConfigMapDao.class); + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXPolicyResourceDao xPolicyResourceDao = Mockito + .mock(XXPolicyResourceDao.class); + XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito + .mock(XXPolicyResourceMapDao.class); + XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class); + XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito + .mock(XXPolicyItemAccessDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito + .mock(XXPolicyItemConditionDao.class); + + XXUserDao xUserDao = Mockito.mock(XXUserDao.class); + XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class); + + XXPolicy policy = policy(); + + XXService xService = xService(); + String name = "fdfdfds"; + + List<XXServiceConfigMap> svcConfigMapList = new ArrayList<XXServiceConfigMap>(); + XXServiceConfigMap xConfMap = new XXServiceConfigMap(); + xConfMap.setAddedByUserId(null); + xConfMap.setConfigkey(name); + xConfMap.setConfigvalue(name); + xConfMap.setCreateTime(new Date()); + xConfMap.setServiceId(null); + + xConfMap.setUpdatedByUserId(null); + xConfMap.setUpdateTime(new Date()); + svcConfigMapList.add(xConfMap); + + XXPortalUser tUser = new XXPortalUser(); + tUser.setAddedByUserId(Id); + tUser.setCreateTime(new Date()); + tUser.setEmailAddress("[email protected]"); + tUser.setFirstName(name); + tUser.setId(Id); + tUser.setLastName(name); + + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(Id); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("test"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(Id); + + List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>(); + XXResourceDef resourceDef = new XXResourceDef(); + resourceDef.setAddedByUserId(Id); + resourceDef.setCreateTime(new Date()); + resourceDef.setDefid(Id); + resourceDef.setDescription("test"); + resourceDef.setId(Id); + resDefList.add(resourceDef); + + XXPolicyResource policyResource = new XXPolicyResource(); + policyResource.setId(Id); + policyResource.setCreateTime(new Date()); + policyResource.setAddedByUserId(Id); + policyResource.setIsExcludes(false); + policyResource.setIsRecursive(false); + policyResource.setPolicyId(Id); + policyResource.setResDefId(Id); + policyResource.setUpdatedByUserId(Id); + policyResource.setUpdateTime(new Date()); + + List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>(); + XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap(); + policyResourceMap.setAddedByUserId(Id); + policyResourceMap.setCreateTime(new Date()); + policyResourceMap.setId(Id); + policyResourceMap.setOrder(1); + policyResourceMap.setResourceId(Id); + policyResourceMap.setUpdatedByUserId(Id); + policyResourceMap.setUpdateTime(new Date()); + policyResourceMap.setValue("1L"); + policyResourceMapList.add(policyResourceMap); + + List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>(); + XXPolicyItem xPolicyItem = new XXPolicyItem(); + xPolicyItem.setDelegateAdmin(false); + xPolicyItem.setAddedByUserId(null); + xPolicyItem.setCreateTime(new Date()); + xPolicyItem.setGUID(null); + xPolicyItem.setId(Id); + xPolicyItem.setOrder(null); + xPolicyItem.setPolicyId(Id); + xPolicyItem.setUpdatedByUserId(null); + xPolicyItem.setUpdateTime(new Date()); + xPolicyItemList.add(xPolicyItem); + + List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>(); + XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess(); + policyItemAccess.setAddedByUserId(Id); + policyItemAccess.setCreateTime(new Date()); + policyItemAccess.setPolicyitemid(Id); + policyItemAccess.setId(Id); + policyItemAccess.setOrder(1); + policyItemAccess.setUpdatedByUserId(Id); + policyItemAccess.setUpdateTime(new Date()); + policyItemAccessList.add(policyItemAccess); + + List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>(); + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy conditio"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName(name); + policyConditionDefObj.setOrder(1); + policyConditionDefObj.setLabel("label"); + xConditionDefList.add(policyConditionDefObj); + + List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>(); + XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition(); + policyItemCondition.setAddedByUserId(Id); + policyItemCondition.setCreateTime(new Date()); + policyItemCondition.setType(1L); + policyItemCondition.setId(Id); + policyItemCondition.setOrder(1); + policyItemCondition.setPolicyItemId(Id); + policyItemCondition.setUpdatedByUserId(Id); + policyItemCondition.setUpdateTime(new Date()); + policyItemConditionList.add(policyItemCondition); + + List<String> usersList = new ArrayList<String>(); + List<String> groupsList = new ArrayList<String>(); + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn( + xServiceDef); + + Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn( + xServiceConfigMapDao); + Mockito.when(xServiceConfigMapDao.findByServiceId(xService.getId())) + .thenReturn(svcConfigMapList); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.getById(policy.getService())).thenReturn( + xService); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + Mockito.when(daoManager.getXXPolicyResource()).thenReturn( + xPolicyResourceDao); + Mockito.when( + xPolicyResourceDao.findByResDefIdAndPolicyId( + resourceDef.getId(), policy.getId())).thenReturn( + policyResource); + + Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn( + xPolicyResourceMapDao); + Mockito.when( + xPolicyResourceMapDao.findByPolicyResId(policyResource.getId())) + .thenReturn(policyResourceMapList); + + Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao); + Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn( + xPolicyItemList); + + Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn( + xPolicyItemAccessDao); + Mockito.when( + xPolicyItemAccessDao.findByPolicyItemId(policyItemAccess + .getId())).thenReturn(policyItemAccessList); + + Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn( + xAccessTypeDefDao); + Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType())) + .thenReturn(xAccessTypeDef); + + Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn( + xPolicyConditionDefDao); + Mockito.when( + xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(xConditionDefList); + + Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn( + xPolicyItemConditionDao); + Mockito.when( + xPolicyItemConditionDao.findByPolicyItemAndDefId( + xPolicyItem.getId(), policyConditionDefObj.getId())) + .thenReturn(policyItemConditionList); + + Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao); + Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(usersList); + + Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao); + Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(groupsList); + + RangerPolicy dbRangerPolicy = policyService.populateViewBean(policy); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), policy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), policy.getName()); + + Assert.assertEquals(dbRangerPolicy.getDescription(), + policy.getDescription()); + Assert.assertEquals(dbRangerPolicy.getGuid(), policy.getGuid()); + + Assert.assertEquals(dbRangerPolicy.getVersion(), policy.getVersion()); + Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(), + policy.getIsAuditEnabled()); + + Mockito.verify(daoManager).getXXService(); + Mockito.verify(daoManager).getXXResourceDef(); + Mockito.verify(daoManager).getXXPolicyResource(); + Mockito.verify(daoManager).getXXPolicyResourceMap(); + Mockito.verify(daoManager).getXXPolicyItem(); + Mockito.verify(daoManager).getXXPolicyItemAccess(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXPolicyItemCondition(); + Mockito.verify(daoManager).getXXUser(); + Mockito.verify(daoManager).getXXGroup(); + } + + @Test + public void test4GetPolicyItemListForXXPolicy() { + + XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class); + XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito + .mock(XXPolicyItemAccessDao.class); + XXUserDao xUserDao = Mockito.mock(XXUserDao.class); + XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito + .mock(XXPolicyItemConditionDao.class); + + XXPolicy policy = policy(); + String name = "fdfdfds"; + + List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>(); + XXPolicyItem xPolicyItem = new XXPolicyItem(); + xPolicyItem.setDelegateAdmin(false); + xPolicyItem.setAddedByUserId(null); + xPolicyItem.setCreateTime(new Date()); + xPolicyItem.setGUID(null); + xPolicyItem.setId(Id); + xPolicyItem.setOrder(null); + xPolicyItem.setPolicyId(Id); + xPolicyItem.setUpdatedByUserId(null); + xPolicyItem.setUpdateTime(new Date()); + xPolicyItemList.add(xPolicyItem); + + List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>(); + XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess(); + policyItemAccess.setAddedByUserId(Id); + policyItemAccess.setCreateTime(new Date()); + policyItemAccess.setPolicyitemid(Id); + policyItemAccess.setId(Id); + policyItemAccess.setOrder(1); + policyItemAccess.setUpdatedByUserId(Id); + policyItemAccess.setUpdateTime(new Date()); + policyItemAccessList.add(policyItemAccess); + + List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>(); + XXResourceDef resourceDef = new XXResourceDef(); + resourceDef.setAddedByUserId(Id); + resourceDef.setCreateTime(new Date()); + resourceDef.setDefid(Id); + resourceDef.setDescription("test"); + resourceDef.setId(Id); + resDefList.add(resourceDef); + + XXPolicyResource policyResource = new XXPolicyResource(); + policyResource.setId(Id); + policyResource.setCreateTime(new Date()); + policyResource.setAddedByUserId(Id); + policyResource.setIsExcludes(false); + policyResource.setIsRecursive(false); + policyResource.setPolicyId(Id); + policyResource.setResDefId(Id); + policyResource.setUpdatedByUserId(Id); + policyResource.setUpdateTime(new Date()); + + List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>(); + XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap(); + policyResourceMap.setAddedByUserId(Id); + policyResourceMap.setCreateTime(new Date()); + policyResourceMap.setId(Id); + policyResourceMap.setOrder(1); + policyResourceMap.setResourceId(Id); + policyResourceMap.setUpdatedByUserId(Id); + policyResourceMap.setUpdateTime(new Date()); + policyResourceMap.setValue("1L"); + policyResourceMapList.add(policyResourceMap); + + List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>(); + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy conditio"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName(name); + policyConditionDefObj.setOrder(1); + policyConditionDefObj.setLabel("label"); + xConditionDefList.add(policyConditionDefObj); + + List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>(); + XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition(); + policyItemCondition.setAddedByUserId(Id); + policyItemCondition.setCreateTime(new Date()); + policyItemCondition.setType(1L); + policyItemCondition.setId(Id); + policyItemCondition.setOrder(1); + policyItemCondition.setPolicyItemId(Id); + policyItemCondition.setUpdatedByUserId(Id); + policyItemCondition.setUpdateTime(new Date()); + policyItemConditionList.add(policyItemCondition); + + List<String> usersList = new ArrayList<String>(); + List<String> groupsList = new ArrayList<String>(); + + Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao); + Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn( + xPolicyItemList); + + Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn( + xPolicyItemAccessDao); + Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(policy.getId())) + .thenReturn(policyItemAccessList); + + Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn( + xAccessTypeDefDao); + Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType())) + .thenReturn(xAccessTypeDef); + + Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn( + xPolicyConditionDefDao); + Mockito.when( + xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(xConditionDefList); + + Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn( + xPolicyItemConditionDao); + Mockito.when( + xPolicyItemConditionDao.findByPolicyItemAndDefId( + xPolicyItem.getId(), policyConditionDefObj.getId())) + .thenReturn(policyItemConditionList); + + Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao); + Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(usersList); + + Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao); + Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(groupsList); + + List<RangerPolicyItem> dbRangerPolicyItem = policyService + .getPolicyItemListForXXPolicy(policy); + Assert.assertNotNull(dbRangerPolicyItem); + + Mockito.verify(daoManager).getXXPolicyItemAccess(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXPolicyItemCondition(); + Mockito.verify(daoManager).getXXUser(); + Mockito.verify(daoManager).getXXGroup(); + } + + @Test + public void test5PopulateXXToRangerPolicyItem() { + String name = "fdfdfds"; + + XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito + .mock(XXPolicyItemAccessDao.class); + XXUserDao xUserDao = Mockito.mock(XXUserDao.class); + XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito + .mock(XXPolicyItemConditionDao.class); + + List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>(); + XXPolicyItem xPolicyItem = new XXPolicyItem(); + xPolicyItem.setDelegateAdmin(false); + xPolicyItem.setAddedByUserId(null); + xPolicyItem.setCreateTime(new Date()); + xPolicyItem.setGUID(null); + xPolicyItem.setId(Id); + xPolicyItem.setOrder(null); + xPolicyItem.setPolicyId(Id); + xPolicyItem.setUpdatedByUserId(null); + xPolicyItem.setUpdateTime(new Date()); + xPolicyItemList.add(xPolicyItem); + + List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>(); + XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess(); + policyItemAccess.setAddedByUserId(Id); + policyItemAccess.setCreateTime(new Date()); + policyItemAccess.setPolicyitemid(Id); + policyItemAccess.setId(Id); + policyItemAccess.setOrder(1); + policyItemAccess.setUpdatedByUserId(Id); + policyItemAccess.setUpdateTime(new Date()); + policyItemAccessList.add(policyItemAccess); + + List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>(); + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy conditio"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName(name); + policyConditionDefObj.setOrder(1); + policyConditionDefObj.setLabel("label"); + xConditionDefList.add(policyConditionDefObj); + + List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>(); + XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition(); + policyItemCondition.setAddedByUserId(Id); + policyItemCondition.setCreateTime(new Date()); + policyItemCondition.setType(1L); + policyItemCondition.setId(Id); + policyItemCondition.setOrder(1); + policyItemCondition.setPolicyItemId(Id); + policyItemCondition.setUpdatedByUserId(Id); + policyItemCondition.setUpdateTime(new Date()); + policyItemConditionList.add(policyItemCondition); + + List<String> usersList = new ArrayList<String>(); + List<String> groupsList = new ArrayList<String>(); + + Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn( + xPolicyItemAccessDao); + Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(Id)).thenReturn( + policyItemAccessList); + + Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn( + xAccessTypeDefDao); + Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType())) + .thenReturn(xAccessTypeDef); + + Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn( + xPolicyConditionDefDao); + Mockito.when( + xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(xConditionDefList); + + Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn( + xPolicyItemConditionDao); + Mockito.when( + xPolicyItemConditionDao.findByPolicyItemAndDefId( + xPolicyItem.getId(), policyConditionDefObj.getId())) + .thenReturn(policyItemConditionList); + + Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao); + Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(usersList); + + Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao); + Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(groupsList); + + RangerPolicyItem dbRangerPolicyItem = policyService + .populateXXToRangerPolicyItem(xPolicyItem); + Assert.assertNotNull(dbRangerPolicyItem); + + Mockito.verify(daoManager).getXXPolicyItemAccess(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXPolicyItemCondition(); + Mockito.verify(daoManager).getXXUser(); + Mockito.verify(daoManager).getXXGroup(); + } + + @Test + public void test6GetResourcesForXXPolicy() { + + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXPolicyResourceDao xPolicyResourceDao = Mockito + .mock(XXPolicyResourceDao.class); + XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito + .mock(XXPolicyResourceMapDao.class); + + XXPolicy policy = policy(); + + List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>(); + XXResourceDef resourceDef = new XXResourceDef(); + resourceDef.setAddedByUserId(Id); + resourceDef.setCreateTime(new Date()); + resourceDef.setDefid(Id); + resourceDef.setDescription("test"); + resourceDef.setId(Id); + resDefList.add(resourceDef); + + XXPolicyResource policyResource = new XXPolicyResource(); + policyResource.setId(Id); + policyResource.setCreateTime(new Date()); + policyResource.setAddedByUserId(Id); + policyResource.setIsExcludes(false); + policyResource.setIsRecursive(false); + policyResource.setPolicyId(Id); + policyResource.setResDefId(Id); + policyResource.setUpdatedByUserId(Id); + policyResource.setUpdateTime(new Date()); + + List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>(); + XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap(); + policyResourceMap.setAddedByUserId(Id); + policyResourceMap.setCreateTime(new Date()); + policyResourceMap.setId(Id); + policyResourceMap.setOrder(1); + policyResourceMap.setResourceId(Id); + policyResourceMap.setUpdatedByUserId(Id); + policyResourceMap.setUpdateTime(new Date()); + policyResourceMap.setValue("1L"); + policyResourceMapList.add(policyResourceMap); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + Mockito.when(daoManager.getXXPolicyResource()).thenReturn( + xPolicyResourceDao); + Mockito.when( + xPolicyResourceDao.findByResDefIdAndPolicyId( + resourceDef.getId(), policy.getId())).thenReturn( + policyResource); + + Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn( + xPolicyResourceMapDao); + Mockito.when( + xPolicyResourceMapDao.findByPolicyResId(policyResource.getId())) + .thenReturn(policyResourceMapList); + + Map<String, RangerPolicyResource> dbListMap = policyService + .getResourcesForXXPolicy(policy); + Assert.assertNotNull(dbListMap); + + Mockito.verify(daoManager).getXXResourceDef(); + Mockito.verify(daoManager).getXXPolicyResource(); + Mockito.verify(daoManager).getXXPolicyResourceMap(); + } + + @Test + public void test7GetPopulatedViewObject() { + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXServiceConfigMapDao xServiceConfigMapDao = Mockito + .mock(XXServiceConfigMapDao.class); + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXPolicyResourceDao xPolicyResourceDao = Mockito + .mock(XXPolicyResourceDao.class); + XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito + .mock(XXPolicyResourceMapDao.class); + XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class); + XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito + .mock(XXPolicyItemAccessDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito + .mock(XXPolicyItemConditionDao.class); + XXUserDao xUserDao = Mockito.mock(XXUserDao.class); + XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class); + + XXPolicy policy = policy(); + XXService xService = xService(); + String name = "fdfdfds"; + + XXPortalUser tUser = new XXPortalUser(); + tUser.setAddedByUserId(Id); + tUser.setCreateTime(new Date()); + tUser.setEmailAddress("[email protected]"); + tUser.setFirstName(name); + tUser.setId(Id); + tUser.setLastName(name); + + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(Id); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("test"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(Id); + + List<XXServiceConfigMap> srcConfigMapList = new ArrayList<XXServiceConfigMap>(); + XXServiceConfigMap xConfMap = new XXServiceConfigMap(); + xConfMap.setAddedByUserId(null); + xConfMap.setConfigkey(name); + xConfMap.setConfigvalue(name); + xConfMap.setCreateTime(new Date()); + xConfMap.setServiceId(null); + xConfMap.setUpdatedByUserId(null); + xConfMap.setUpdateTime(new Date()); + srcConfigMapList.add(xConfMap); + + List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>(); + XXResourceDef resourceDef = new XXResourceDef(); + resourceDef.setAddedByUserId(Id); + resourceDef.setCreateTime(new Date()); + resourceDef.setDefid(Id); + resourceDef.setDescription("test"); + resourceDef.setId(Id); + resDefList.add(resourceDef); + + XXPolicyResource policyResource = new XXPolicyResource(); + policyResource.setId(Id); + policyResource.setCreateTime(new Date()); + policyResource.setAddedByUserId(Id); + policyResource.setIsExcludes(false); + policyResource.setIsRecursive(false); + policyResource.setPolicyId(Id); + policyResource.setResDefId(Id); + policyResource.setUpdatedByUserId(Id); + policyResource.setUpdateTime(new Date()); + + List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>(); + XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap(); + policyResourceMap.setAddedByUserId(Id); + policyResourceMap.setCreateTime(new Date()); + policyResourceMap.setId(Id); + policyResourceMap.setOrder(1); + policyResourceMap.setResourceId(Id); + policyResourceMap.setUpdatedByUserId(Id); + policyResourceMap.setUpdateTime(new Date()); + policyResourceMap.setValue("1L"); + policyResourceMapList.add(policyResourceMap); + + List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>(); + XXPolicyItem xPolicyItem = new XXPolicyItem(); + xPolicyItem.setDelegateAdmin(false); + xPolicyItem.setAddedByUserId(null); + xPolicyItem.setCreateTime(new Date()); + xPolicyItem.setGUID(null); + xPolicyItem.setId(Id); + xPolicyItem.setOrder(null); + xPolicyItem.setPolicyId(Id); + xPolicyItem.setUpdatedByUserId(null); + xPolicyItem.setUpdateTime(new Date()); + xPolicyItemList.add(xPolicyItem); + + List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>(); + XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess(); + policyItemAccess.setAddedByUserId(Id); + policyItemAccess.setCreateTime(new Date()); + policyItemAccess.setPolicyitemid(Id); + policyItemAccess.setId(Id); + policyItemAccess.setOrder(1); + policyItemAccess.setUpdatedByUserId(Id); + policyItemAccess.setUpdateTime(new Date()); + policyItemAccessList.add(policyItemAccess); + + List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>(); + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy conditio"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName(name); + policyConditionDefObj.setOrder(1); + policyConditionDefObj.setLabel("label"); + xConditionDefList.add(policyConditionDefObj); + + List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>(); + XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition(); + policyItemCondition.setAddedByUserId(Id); + policyItemCondition.setCreateTime(new Date()); + policyItemCondition.setType(1L); + policyItemCondition.setId(Id); + policyItemCondition.setOrder(1); + policyItemCondition.setPolicyItemId(Id); + policyItemCondition.setUpdatedByUserId(Id); + policyItemCondition.setUpdateTime(new Date()); + policyItemConditionList.add(policyItemCondition); + + List<String> usersList = new ArrayList<String>(); + List<String> groupsList = new ArrayList<String>(); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn( + xServiceDef); + + Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn( + xServiceConfigMapDao); + Mockito.when(xServiceConfigMapDao.findByServiceId(xService.getId())) + .thenReturn(srcConfigMapList); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.getById(policy.getService())).thenReturn( + xService); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + Mockito.when(daoManager.getXXPolicyResource()).thenReturn( + xPolicyResourceDao); + Mockito.when( + xPolicyResourceDao.findByResDefIdAndPolicyId( + resourceDef.getId(), policy.getId())).thenReturn( + policyResource); + + Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn( + xPolicyResourceMapDao); + Mockito.when( + xPolicyResourceMapDao.findByPolicyResId(policyResource.getId())) + .thenReturn(policyResourceMapList); + + Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao); + Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn( + xPolicyItemList); + + Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn( + xPolicyItemAccessDao); + Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(policy.getId())) + .thenReturn(policyItemAccessList); + + Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn( + xAccessTypeDefDao); + Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType())) + .thenReturn(xAccessTypeDef); + + Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn( + xPolicyConditionDefDao); + Mockito.when( + xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(xConditionDefList); + + Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn( + xPolicyItemConditionDao); + Mockito.when( + xPolicyItemConditionDao.findByPolicyItemAndDefId( + xPolicyItem.getId(), policyConditionDefObj.getId())) + .thenReturn(policyItemConditionList); + + Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao); + Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(usersList); + + Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao); + Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId())) + .thenReturn(groupsList); + + RangerPolicy dbRangerPolicy = policyService + .getPopulatedViewObject(policy); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), policy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), policy.getName()); + Assert.assertEquals(dbRangerPolicy.getDescription(), + policy.getDescription()); + Assert.assertEquals(dbRangerPolicy.getGuid(), policy.getGuid()); + Assert.assertEquals(dbRangerPolicy.getVersion(), policy.getVersion()); + Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(), + policy.getIsAuditEnabled()); + Mockito.verify(daoManager).getXXPolicyItemAccess(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXPolicyItemCondition(); + Mockito.verify(daoManager).getXXUser(); + Mockito.verify(daoManager).getXXGroup(); + } + + @Test + public void test8getTransactionLog() { + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + RangerPolicy rangerPolicy = rangerPolicy(); + XXService xService = xService(); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.findByName(rangerPolicy.getService())) + .thenReturn(xService); + + List<XXTrxLog> dbXXTrxLogList = policyService.getTransactionLog( + rangerPolicy, 1); + Assert.assertNotNull(dbXXTrxLogList); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java new file mode 100644 index 0000000..75e2ebd --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java @@ -0,0 +1,275 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF 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.apache.ranger.service; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.ws.rs.WebApplicationException; + +import org.apache.ranger.biz.RangerBizUtil; +import org.apache.ranger.common.ContextUtil; +import org.apache.ranger.common.MessageEnums; +import org.apache.ranger.common.RESTErrorUtil; +import org.apache.ranger.common.RangerSearchUtil; +import org.apache.ranger.common.SearchField; +import org.apache.ranger.common.UserSessionBase; +import org.apache.ranger.common.db.BaseDao; +import org.apache.ranger.db.RangerDaoManager; +import org.apache.ranger.db.XXServiceDao; +import org.apache.ranger.entity.XXDBBase; +import org.apache.ranger.entity.XXPolicy; +import org.apache.ranger.entity.XXService; +import org.apache.ranger.plugin.model.RangerPolicy; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource; +import org.apache.ranger.plugin.util.SearchFilter; +import org.apache.ranger.security.context.RangerContextHolder; +import org.apache.ranger.security.context.RangerSecurityContext; +import org.apache.ranger.view.RangerPolicyList; +import org.junit.Assert; +import org.junit.FixMethodOrder; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class TestRangerPolicyServiceBase { + + private static Long Id = 8L; + + @InjectMocks + RangerPolicyService policyService = new RangerPolicyService(); + + @Mock + RangerDaoManager daoManager; + + @Mock + RESTErrorUtil restErrorUtil; + + @Mock + ContextUtil contextUtil; + + @Mock + RangerAuditFields<XXDBBase> rangerAuditFields; + + @Mock + RangerBizUtil rangerBizUtil; + + @Mock + RangerSearchUtil searchUtil; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + public void setup() { + RangerSecurityContext context = new RangerSecurityContext(); + context.setUserSession(new UserSessionBase()); + RangerContextHolder.setSecurityContext(context); + UserSessionBase currentUserSession = ContextUtil + .getCurrentUserSession(); + currentUserSession.setUserAdmin(true); + } + + private RangerPolicy rangerPolicy() { + List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>(); + List<String> users = new ArrayList<String>(); + List<String> groups = new ArrayList<String>(); + List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>(); + List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>(); + RangerPolicyItem rangerPolicyItem = new RangerPolicyItem(); + rangerPolicyItem.setAccesses(accesses); + rangerPolicyItem.setConditions(conditions); + rangerPolicyItem.setGroups(groups); + rangerPolicyItem.setUsers(users); + rangerPolicyItem.setDelegateAdmin(false); + + policyItems.add(rangerPolicyItem); + + Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>(); + RangerPolicyResource rangerPolicyResource = new RangerPolicyResource(); + rangerPolicyResource.setIsExcludes(true); + rangerPolicyResource.setIsRecursive(true); + rangerPolicyResource.setValue("1"); + rangerPolicyResource.setValues(users); + RangerPolicy policy = new RangerPolicy(); + policy.setId(Id); + policy.setCreateTime(new Date()); + policy.setDescription("policy"); + policy.setGuid("policyguid"); + policy.setIsEnabled(true); + policy.setName("HDFS_1-1-20150316062453"); + policy.setUpdatedBy("Admin"); + policy.setUpdateTime(new Date()); + policy.setService("HDFS_1-1-20150316062453"); + policy.setIsAuditEnabled(true); + policy.setPolicyItems(policyItems); + policy.setResources(policyResource); + + return policy; + } + + private XXPolicy policy() { + XXPolicy xxPolicy = new XXPolicy(); + xxPolicy.setId(Id); + xxPolicy.setName("HDFS_1-1-20150316062453"); + xxPolicy.setAddedByUserId(Id); + xxPolicy.setCreateTime(new Date()); + xxPolicy.setDescription("test"); + xxPolicy.setIsAuditEnabled(false); + xxPolicy.setIsEnabled(false); + xxPolicy.setService(1L); + xxPolicy.setUpdatedByUserId(Id); + xxPolicy.setUpdateTime(new Date()); + return xxPolicy; + } + + @Test + public void test1mapViewToEntityBean() { + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + XXService xService = Mockito.mock(XXService.class); + RangerPolicy rangerPolicy = rangerPolicy(); + XXPolicy policy = policy(); + int OPERATION_CONTEXT = 0; + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.findByName(rangerPolicy.getService())) + .thenReturn(xService); + + XXPolicy dbPolicy = policyService.mapViewToEntityBean(rangerPolicy, + policy, OPERATION_CONTEXT); + Assert.assertNotNull(dbPolicy); + Assert.assertEquals(dbPolicy.getId(), policy.getId()); + Assert.assertEquals(dbPolicy.getGuid(), policy.getGuid()); + Assert.assertEquals(dbPolicy.getName(), policy.getName()); + Assert.assertEquals(dbPolicy.getAddedByUserId(), + policy.getAddedByUserId()); + Assert.assertEquals(dbPolicy.getIsEnabled(), policy.getIsEnabled()); + Assert.assertEquals(dbPolicy.getVersion(), policy.getVersion()); + Assert.assertEquals(dbPolicy.getDescription(), policy.getDescription()); + + Mockito.verify(daoManager).getXXService(); + } + + @Test + public void test2mapViewToEntityBeanNullValue() { + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + RangerPolicy rangerPolicy = rangerPolicy(); + XXPolicy policy = policy(); + int OPERATION_CONTEXT = 0; + + Mockito.when( + restErrorUtil.createRESTException( + "No corresponding service found for policyName: " + + rangerPolicy.getName() + + "Service Not Found : " + + rangerPolicy.getName(), + MessageEnums.INVALID_INPUT_DATA)).thenThrow( + new WebApplicationException()); + + thrown.expect(WebApplicationException.class); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.findByName(rangerPolicy.getService())) + .thenReturn(null); + + XXPolicy dbPolicy = policyService.mapViewToEntityBean(rangerPolicy, + policy, OPERATION_CONTEXT); + Assert.assertNotNull(dbPolicy); + Assert.assertEquals(dbPolicy.getId(), policy.getId()); + Assert.assertEquals(dbPolicy.getGuid(), policy.getGuid()); + Assert.assertEquals(dbPolicy.getName(), policy.getName()); + Assert.assertEquals(dbPolicy.getAddedByUserId(), + policy.getAddedByUserId()); + Assert.assertEquals(dbPolicy.getIsEnabled(), policy.getIsEnabled()); + Assert.assertEquals(dbPolicy.getVersion(), policy.getVersion()); + Assert.assertEquals(dbPolicy.getDescription(), policy.getDescription()); + + Mockito.verify(daoManager).getXXService(); + } + + @Test + public void test3mapEntityToViewBean() { + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + XXService xService = Mockito.mock(XXService.class); + RangerPolicy rangerPolicy = rangerPolicy(); + XXPolicy policy = policy(); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.getById(policy.getService())).thenReturn( + xService); + + RangerPolicy dbRangerPolicy = policyService.mapEntityToViewBean( + rangerPolicy, policy); + + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid()); + Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName()); + Assert.assertEquals(dbRangerPolicy.getIsEnabled(), + rangerPolicy.getIsEnabled()); + Assert.assertEquals(dbRangerPolicy.getVersion(), + rangerPolicy.getVersion()); + Assert.assertEquals(dbRangerPolicy.getDescription(), + rangerPolicy.getDescription()); + + Mockito.verify(daoManager).getXXService(); + } + + @Test + public void test4searchRangerPolicies() { + EntityManager entityManager = Mockito.mock(EntityManager.class); + SearchFilter searchFilter = new SearchFilter(); + searchFilter.setParam(SearchFilter.POLICY_NAME, "policyName"); + searchFilter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + + String searchString = "policyName"; + String sortString = "asc"; + List<SearchField> searchFieldList = new ArrayList<SearchField>(); + boolean isCountQuery = false; + + BaseDao baseDao = Mockito.mock(BaseDao.class); + + Mockito.when(daoManager.getDaoForClassName(Mockito.anyString())) + .thenReturn(baseDao); + Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager); + Mockito.when( + searchUtil + .createSearchQuery(entityManager, searchString, + sortString, searchFilter, searchFieldList, + isCountQuery)).thenReturn(null); + + RangerPolicyList dbRangerPolicyList = policyService + .searchRangerPolicies(searchFilter); + Assert.assertNotNull(dbRangerPolicyList); + Mockito.verify(daoManager).getDaoForClassName(Mockito.anyString()); + } + +}
