Repository: incubator-ranger Updated Branches: refs/heads/ranger-0.6 4a332a93e -> 4a64c4fa1
RANGER-1170: Added Unit tests for PuclicAPIsv2 and PublicAPIs (0.6 branch) Signed-off-by: Velmurugan Periasamy <v...@apache.org> Project: http://git-wip-us.apache.org/repos/asf/incubator-ranger/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-ranger/commit/1b728ebe Tree: http://git-wip-us.apache.org/repos/asf/incubator-ranger/tree/1b728ebe Diff: http://git-wip-us.apache.org/repos/asf/incubator-ranger/diff/1b728ebe Branch: refs/heads/ranger-0.6 Commit: 1b728ebeab2e90dcb169599ff67dcc7b039fdcf9 Parents: 4a332a9 Author: Sailaja Polavarapu <spolavar...@hortonworks.com> Authored: Thu Oct 13 14:46:58 2016 -0700 Committer: Velmurugan Periasamy <v...@apache.org> Committed: Fri Oct 14 15:44:35 2016 -0400 ---------------------------------------------------------------------- .../org/apache/ranger/rest/TestPublicAPIs.java | 512 ++++++++++++++++++ .../apache/ranger/rest/TestPublicAPIsv2.java | 539 +++++++++++++++++++ 2 files changed, 1051 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1b728ebe/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java new file mode 100644 index 0000000..9faae93 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java @@ -0,0 +1,512 @@ +/* + * 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.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; + +import org.apache.commons.lang.StringUtils; +import org.apache.ranger.common.ContextUtil; +import org.apache.ranger.common.JSONUtil; +import org.apache.ranger.common.RESTErrorUtil; +import org.apache.ranger.common.RangerSearchUtil; +import org.apache.ranger.common.ServiceUtil; +import org.apache.ranger.common.UserSessionBase; +import org.apache.ranger.db.RangerDaoManager; +import org.apache.ranger.db.XXPolicyDao; +import org.apache.ranger.db.XXServiceDao; +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.RangerService; +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.service.RangerPolicyService; +import org.apache.ranger.service.XAssetService; +import org.apache.ranger.view.VXAsset; +import org.apache.ranger.view.VXLong; +import org.apache.ranger.view.VXPolicy; +import org.apache.ranger.view.VXPolicyList; +import org.apache.ranger.view.VXRepository; +import org.apache.ranger.view.VXRepositoryList; +import org.junit.Assert; +import org.junit.Before; +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 TestPublicAPIs { + + private static Long Id = 8L; + + @InjectMocks + PublicAPIs publicAPIs = new PublicAPIs(); + + @Mock + ServiceREST serviceREST; + + @Mock + ServiceUtil serviceUtil; + + @Mock + RESTErrorUtil restErrorUtil; + + @Mock + JSONUtil jsonUtil; + + @Mock + RangerDaoManager daoMgr; + + @Mock + RangerSearchUtil searchUtil; + + @Mock + XAssetService xAssetService; + + @Mock + RangerPolicyService policyService; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void setup() throws Exception { + RangerSecurityContext context = new RangerSecurityContext(); + context.setUserSession(new UserSessionBase()); + RangerContextHolder.setSecurityContext(context); + UserSessionBase currentUserSession = ContextUtil + .getCurrentUserSession(); + currentUserSession.setUserAdmin(true); + } + + 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 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()); + + return xService; + } + + private VXRepository vXRepository(RangerService service) { + VXRepository ret = new VXRepository(); + ret.setRepositoryType(service.getType()); + ret.setName(service.getName()); + ret.setDescription(service.getDescription()); + ret.setIsActive(service.getIsEnabled()); + ret.setConfig(jsonUtil.readMapToString(service.getConfigs())); + //ret.setVersion(Long.toString(service.getVersion())); + ret.setId(service.getId()); + ret.setCreateDate(service.getCreateTime()); + ret.setUpdateDate(service.getUpdateTime()); + ret.setOwner(service.getCreatedBy()); + ret.setUpdatedBy(service.getUpdatedBy()); + + return ret; + } + + private VXPolicy vXPolicy(RangerPolicy policy, RangerService service) { + VXPolicy ret = new VXPolicy(); + ret.setPolicyName(StringUtils.trim(policy.getName())); + ret.setDescription(policy.getDescription()); + ret.setRepositoryName(policy.getService()); + ret.setIsEnabled(policy.getIsEnabled() ? true : false); + ret.setRepositoryType(service.getType()); + ret.setIsAuditEnabled(policy.getIsAuditEnabled()); + return ret; + } + + 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); + policyResource.put("resource", rangerPolicyResource); + 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); + policy.setService("HDFS_1"); + + 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()); + xxPolicy.setVersion(Id); + return xxPolicy; + } + + @Test + public void test1getRepository() throws Exception { + RangerService rangerService = rangerService(); + VXRepository vXRepository = vXRepository(rangerService); + Mockito.when(serviceREST.getService(rangerService.getId())).thenReturn(rangerService); + Mockito.when(serviceUtil.toVXRepository(rangerService)).thenReturn(vXRepository); + VXRepository dbVXRepository = publicAPIs.getRepository(Id); + + Assert.assertNotNull(dbVXRepository); + Assert.assertEquals(dbVXRepository, vXRepository); + Assert.assertEquals(dbVXRepository.getId(), + vXRepository.getId()); + Assert.assertEquals(dbVXRepository.getName(), + vXRepository.getName()); + Mockito.verify(serviceREST).getService(Id); + Mockito.verify(serviceUtil).toVXRepository(rangerService); + + } + + @Test + public void test2createRepository() throws Exception { + VXAsset vXAsset = new VXAsset(); + RangerService rangerService = rangerService(); + VXRepository vXRepository = vXRepository(rangerService); + Mockito.when(serviceUtil.publicObjecttoVXAsset(vXRepository)).thenReturn(vXAsset); + Mockito.when(serviceUtil.toRangerService(vXAsset)).thenReturn(rangerService); + Mockito.when(serviceREST.createService(rangerService)).thenReturn(rangerService); + Mockito.when(serviceUtil.toVXAsset(rangerService)).thenReturn(vXAsset); + Mockito.when(serviceUtil.vXAssetToPublicObject(vXAsset)).thenReturn(vXRepository); + VXRepository dbVXRepository = publicAPIs.createRepository(vXRepository); + + Assert.assertNotNull(dbVXRepository); + Assert.assertEquals(dbVXRepository, vXRepository); + Assert.assertEquals(dbVXRepository.getId(), + vXRepository.getId()); + Assert.assertEquals(dbVXRepository.getName(), + vXRepository.getName()); + Mockito.verify(serviceREST).createService(rangerService); + Mockito.verify(serviceUtil).publicObjecttoVXAsset(vXRepository); + Mockito.verify(serviceUtil).toRangerService(vXAsset); + Mockito.verify(serviceUtil).toVXAsset(rangerService); + Mockito.verify(serviceUtil).vXAssetToPublicObject(vXAsset); + } + + @Test + public void test3updateRepository() throws Exception { + VXAsset vXAsset = new VXAsset(); + RangerService rangerService = rangerService(); + VXRepository vXRepository = vXRepository(rangerService); + XXService xService = xService(); + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + Mockito.when(daoMgr.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.getById(Id)).thenReturn(xService); + Mockito.when(serviceUtil.publicObjecttoVXAsset(vXRepository)).thenReturn(vXAsset); + Mockito.when(serviceUtil.toRangerService(vXAsset)).thenReturn(rangerService); + Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService); + Mockito.when(serviceUtil.toVXAsset(rangerService)).thenReturn(vXAsset); + Mockito.when(serviceUtil.vXAssetToPublicObject(vXAsset)).thenReturn(vXRepository); + VXRepository dbVXRepository = publicAPIs.updateRepository(vXRepository, Id); + + Assert.assertNotNull(dbVXRepository); + Assert.assertEquals(dbVXRepository, vXRepository); + Assert.assertEquals(dbVXRepository.getId(), + vXRepository.getId()); + Assert.assertEquals(dbVXRepository.getName(), + vXRepository.getName()); + Mockito.verify(serviceREST).updateService(rangerService); + Mockito.verify(serviceUtil).publicObjecttoVXAsset(vXRepository); + Mockito.verify(serviceUtil).toRangerService(vXAsset); + Mockito.verify(serviceUtil).toVXAsset(rangerService); + Mockito.verify(serviceUtil).vXAssetToPublicObject(vXAsset); + Mockito.verify(daoMgr).getXXService(); + } + + @Test + public void test4deleteRepository() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + Mockito.doNothing().when(serviceREST).deleteService(Id); + publicAPIs.deleteRepository(Id, request); + Mockito.verify(serviceREST).deleteService(Id); + } + + @Test + public void test5searchRepositories() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + List<RangerService> ret = new ArrayList<RangerService>(); + RangerService rangerService = rangerService(); + VXRepository vXRepository = vXRepository(rangerService); + List<VXRepository> repoList = new ArrayList<VXRepository>(); + repoList.add(vXRepository); + VXRepositoryList vXRepositoryList = new VXRepositoryList(repoList); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when(searchUtil.getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields)).thenReturn(filter); + Mockito.when(serviceREST.getServices(filter)).thenReturn(ret); + Mockito.when(serviceUtil.rangerServiceListToPublicObjectList(ret)).thenReturn(vXRepositoryList); + VXRepositoryList dbVXRepositoryList = publicAPIs.searchRepositories(request); + Assert.assertNotNull(dbVXRepositoryList); + Assert.assertEquals(dbVXRepositoryList.getResultSize(), vXRepositoryList.getResultSize()); + } + + @Test + public void test6countRepositories() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + VXLong vXLong = new VXLong(); + List<RangerService> ret = new ArrayList<RangerService>(); + RangerService rangerService = rangerService(); + VXRepository vXRepository = vXRepository(rangerService); + List<VXRepository> repoList = new ArrayList<VXRepository>(); + repoList.add(vXRepository); + VXRepositoryList vXRepositoryList = new VXRepositoryList(repoList); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + Mockito.when(searchUtil.getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields)).thenReturn(filter); + Mockito.when(serviceREST.getServices(filter)).thenReturn(ret); + Mockito.when(serviceUtil.rangerServiceListToPublicObjectList(ret)).thenReturn(vXRepositoryList); + VXRepositoryList dbVXRepositoryList = publicAPIs.searchRepositories(request); + vXLong.setValue(dbVXRepositoryList.getResultSize()); + Assert.assertNotNull(vXLong); + Assert.assertEquals(vXLong.getValue(), 1); + Mockito.verify(searchUtil).getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields); + Mockito.verify(serviceREST).getServices(filter); + Mockito.verify(serviceUtil).rangerServiceListToPublicObjectList(ret); + } + + @Test + public void test7getPolicy() throws Exception { + RangerPolicy policy = rangerPolicy(); + RangerService service = rangerService(); + VXPolicy vXPolicy = vXPolicy(policy, service); + Mockito.when(serviceREST.getPolicy(policy.getId())).thenReturn(policy); + Mockito.when(serviceREST.getServiceByName(policy.getService())).thenReturn(service); + Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy); + VXPolicy dbVXPolicy = publicAPIs.getPolicy(Id); + Assert.assertNotNull(dbVXPolicy); + Assert.assertEquals(dbVXPolicy, vXPolicy); + Assert.assertEquals(dbVXPolicy.getPolicyName(), vXPolicy.getPolicyName()); + Assert.assertEquals(dbVXPolicy.getRepositoryType(), vXPolicy.getRepositoryType()); + Mockito.verify(serviceREST).getPolicy(Id); + Mockito.verify(serviceREST).getServiceByName(policy.getService()); + Mockito.verify(serviceUtil).toVXPolicy(policy, service); + } + + @Test + public void test8createPolicy() throws Exception { + RangerPolicy policy = rangerPolicy(); + RangerService service = rangerService(); + VXPolicy vXPolicy = vXPolicy(policy, service); + Mockito.when(serviceREST.getServiceByName(vXPolicy.getRepositoryName())).thenReturn(service); + Mockito.when(serviceUtil.toRangerPolicy(vXPolicy,service)).thenReturn(policy); + Mockito.when(serviceREST.createPolicy(policy, null)).thenReturn(policy); + Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy); + VXPolicy dbVXPolicy = publicAPIs.createPolicy(vXPolicy); + Assert.assertNotNull(dbVXPolicy); + Assert.assertEquals(dbVXPolicy, vXPolicy); + Assert.assertEquals(dbVXPolicy.getId(), + vXPolicy.getId()); + Assert.assertEquals(dbVXPolicy.getRepositoryName(), + vXPolicy.getRepositoryName()); + Mockito.verify(serviceREST).createPolicy(policy, null); + Mockito.verify(serviceREST).getServiceByName(vXPolicy.getRepositoryName()); + Mockito.verify(serviceUtil).toVXPolicy(policy, service); + Mockito.verify(serviceUtil).toRangerPolicy(vXPolicy,service); + + } + + @Test + public void test9updatePolicy() throws Exception { + RangerPolicy policy = rangerPolicy(); + RangerService service = rangerService(); + VXPolicy vXPolicy = vXPolicy(policy, service); + XXPolicyDao xXPolicyDao = Mockito.mock(XXPolicyDao.class); + XXPolicy xXPolicy = policy(); + Mockito.when(daoMgr.getXXPolicy()).thenReturn(xXPolicyDao); + Mockito.when(xXPolicyDao.getById(Id)).thenReturn(xXPolicy); + Mockito.when(serviceREST.getServiceByName(vXPolicy.getRepositoryName())).thenReturn(service); + Mockito.when(serviceUtil.toRangerPolicy(vXPolicy,service)).thenReturn(policy); + Mockito.when(serviceREST.updatePolicy(policy)).thenReturn(policy); + Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy); + VXPolicy dbVXPolicy = publicAPIs.updatePolicy(vXPolicy, Id); + + Assert.assertNotNull(dbVXPolicy); + Assert.assertEquals(dbVXPolicy, vXPolicy); + Assert.assertEquals(dbVXPolicy.getId(), + vXPolicy.getId()); + Assert.assertEquals(dbVXPolicy.getRepositoryName(), + vXPolicy.getRepositoryName()); + Mockito.verify(serviceREST).updatePolicy(policy); + Mockito.verify(serviceREST).getServiceByName(vXPolicy.getRepositoryName()); + Mockito.verify(serviceUtil).toVXPolicy(policy, service); + Mockito.verify(serviceUtil).toRangerPolicy(vXPolicy,service); + Mockito.verify(daoMgr).getXXPolicy(); + Mockito.verify(xXPolicyDao).getById(Id); + } + + @Test + public void test10deletePolicy() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + Mockito.doNothing().when(serviceREST).deletePolicy(Id); + publicAPIs.deletePolicy(Id, request); + Mockito.verify(serviceREST).deletePolicy(Id); + } + + @Test + public void test11searchPolicies() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerService service = rangerService(); + RangerPolicy policy = rangerPolicy(); + List<RangerPolicy> policyList = new ArrayList<RangerPolicy>(); + policyList.add(policy); + VXPolicy vXPolicy = vXPolicy(policy, service); + List<VXPolicy> vXPolicies = new ArrayList<VXPolicy>(); + vXPolicies.add(vXPolicy); + VXPolicyList vXPolicyList = new VXPolicyList(vXPolicies); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + filter.setStartIndex(0); + filter.setMaxRows(10); + Mockito.when(searchUtil.getSearchFilterFromLegacyRequest(request, policyService.sortFields)).thenReturn(filter); + Mockito.when(serviceREST.getPolicies(filter)).thenReturn(policyList); + Mockito.when(serviceUtil.rangerPolicyListToPublic(policyList,filter)).thenReturn(vXPolicyList); + VXPolicyList dbVXPolicyList = publicAPIs.searchPolicies(request); + Assert.assertNotNull(dbVXPolicyList); + Assert.assertEquals(dbVXPolicyList.getResultSize(), vXPolicyList.getResultSize()); + Mockito.verify(searchUtil).getSearchFilterFromLegacyRequest(request, policyService.sortFields); + Mockito.verify(serviceREST).getPolicies(filter); + Mockito.verify(serviceUtil).rangerPolicyListToPublic(policyList,filter); + + } + + @Test + public void test12countPolicies() throws Exception { + VXLong vXLong = new VXLong(); + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerService service = rangerService(); + RangerPolicy policy = rangerPolicy(); + List<RangerPolicy> policyList = new ArrayList<RangerPolicy>(); + policyList.add(policy); + VXPolicy vXPolicy = vXPolicy(policy, service); + List<VXPolicy> vXPolicies = new ArrayList<VXPolicy>(); + vXPolicies.add(vXPolicy); + VXPolicyList vXPolicyList = new VXPolicyList(vXPolicies); + SearchFilter filter = new SearchFilter(); + filter.setParam(SearchFilter.POLICY_NAME, "policyName"); + filter.setParam(SearchFilter.SERVICE_NAME, "serviceName"); + filter.setStartIndex(0); + filter.setMaxRows(10); + Mockito.when(searchUtil.getSearchFilterFromLegacyRequest(request, policyService.sortFields)).thenReturn(filter); + Mockito.when(serviceREST.getPolicies(filter)).thenReturn(policyList); + Mockito.when(serviceUtil.rangerPolicyListToPublic(policyList,filter)).thenReturn(vXPolicyList); + VXPolicyList dbVXPolicyList = publicAPIs.searchPolicies(request); + vXLong.setValue(dbVXPolicyList.getResultSize()); + Assert.assertNotNull(vXLong); + Assert.assertEquals(vXLong.getValue(), 1); + Mockito.verify(searchUtil).getSearchFilterFromLegacyRequest(request, policyService.sortFields); + Mockito.verify(serviceREST).getPolicies(filter); + Mockito.verify(serviceUtil).rangerPolicyListToPublic(policyList,filter); + + } + + +} http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1b728ebe/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java new file mode 100644 index 0000000..85934f5 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java @@ -0,0 +1,539 @@ +/* + * 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.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; + +import org.apache.ranger.common.ContextUtil; +import org.apache.ranger.common.RESTErrorUtil; +import org.apache.ranger.common.UserSessionBase; +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.util.SearchFilter; +import org.apache.ranger.security.context.RangerContextHolder; +import org.apache.ranger.security.context.RangerSecurityContext; +import org.apache.ranger.view.RangerPolicyList; +import org.apache.ranger.view.RangerServiceDefList; +import org.apache.ranger.view.RangerServiceList; +import org.junit.Assert; +import org.junit.Before; +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 TestPublicAPIsv2 { + + private static Long Id = 8L; + + @InjectMocks + PublicAPIsv2 publicAPIsv2 = new PublicAPIsv2(); + + @Mock + ServiceREST serviceREST; + + @Mock + RESTErrorUtil restErrorUtil; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void setup() throws Exception { + 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.setName("RangerServiceHdfs"); + 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); + policyResource.put("resource", rangerPolicyResource); + 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); + policy.setService("HDFS_1"); + + return policy; + } + + @Test + public void test1getServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + Mockito.when(serviceREST.getServiceDef(rangerServiceDef.getId())).thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDef(Id); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(serviceREST).getServiceDef(Id); + } + + @Test + public void test2getServiceDefByName() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + String name = rangerServiceDef.getName(); + Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDefByName(name); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(serviceREST).getServiceDefByName(name); + } + + @Test + public void test3searchServiceDefs() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + List<RangerServiceDef> serviceDefsList = new ArrayList<RangerServiceDef>(); + RangerServiceDef serviceDef = rangerServiceDef(); + serviceDefsList.add(serviceDef); + RangerServiceDefList serviceDefList = new RangerServiceDefList(serviceDefsList); + Mockito.when(serviceREST.getServiceDefs(request)).thenReturn(serviceDefList); + List<RangerServiceDef> dbRangerServiceDefList = publicAPIsv2.searchServiceDefs(request); + Assert.assertNotNull(dbRangerServiceDefList); + Assert.assertEquals(dbRangerServiceDefList.size(), serviceDefsList.size()); + Mockito.verify(serviceREST).getServiceDefs(request); + } + + @Test + public void test4createServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + Mockito.when(serviceREST.createServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = publicAPIsv2.createServiceDef(rangerServiceDef); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(serviceREST).createServiceDef(rangerServiceDef); + } + + @Test + public void test5updateServiceDef() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + Mockito.when(serviceREST.updateServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDef(rangerServiceDef, Id); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef); + } + + @Test + public void test6updateServiceDefByName() throws Exception { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + String name = rangerServiceDef.getName(); + Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef); + Mockito.when(serviceREST.updateServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef); + RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDefByName(rangerServiceDef, name); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef); + Mockito.verify(serviceREST).getServiceDefByName(name); + } + + @Test + public void test7deleteServiceDef() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + Mockito.doNothing().when(serviceREST).deleteServiceDef(Id, request); + publicAPIsv2.deleteServiceDef(Id, request); + Mockito.verify(serviceREST).deleteServiceDef(Id, request); + } + + @Test + public void test8deleteServiceDefByName() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerServiceDef rangerServiceDef = rangerServiceDef(); + String name = rangerServiceDef.getName(); + Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef); + Mockito.doNothing().when(serviceREST).deleteServiceDef(rangerServiceDef.getId(), request); + publicAPIsv2.deleteServiceDefByName(name, request); + Mockito.verify(serviceREST).deleteServiceDef(rangerServiceDef.getId(), request); + Mockito.verify(serviceREST).getServiceDefByName(name); + } + + @Test + public void test9getService() throws Exception { + RangerService rangerService = rangerService(); + Mockito.when(serviceREST.getService(rangerService.getId())).thenReturn(rangerService); + RangerService dbRangerService = publicAPIsv2.getService(Id); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService, rangerService); + Assert.assertEquals(dbRangerService.getId(), + rangerService.getId()); + Assert.assertEquals(dbRangerService.getName(), + rangerService.getName()); + Mockito.verify(serviceREST).getService(Id); + } + + @Test + public void test10getServiceByName() throws Exception { + RangerService rangerService = rangerService(); + String name = rangerService.getName(); + Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService); + RangerService dbRangerService = publicAPIsv2.getServiceByName(name); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService, rangerService); + Assert.assertEquals(dbRangerService.getId(), + rangerService.getId()); + Assert.assertEquals(dbRangerService.getName(), + rangerService.getName()); + Mockito.verify(serviceREST).getServiceByName(name); + } + + @Test + public void test11searchServices() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + List<RangerService> servicesList = new ArrayList<RangerService>(); + RangerService service = rangerService(); + servicesList.add(service); + RangerServiceList serviceList = new RangerServiceList(servicesList); + Mockito.when(serviceREST.getServices(request)).thenReturn(serviceList); + List<RangerService> dbRangerServiceList = publicAPIsv2.searchServices(request); + Assert.assertNotNull(dbRangerServiceList); + Assert.assertEquals(dbRangerServiceList.size(), servicesList.size()); + Mockito.verify(serviceREST).getServices(request); + } + + @Test + public void test12createService() throws Exception { + RangerService rangerService = rangerService(); + Mockito.when(serviceREST.createService(rangerService)).thenReturn(rangerService); + RangerService dbRangerService = publicAPIsv2.createService(rangerService); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService, rangerService); + Assert.assertEquals(dbRangerService.getId(), + rangerService.getId()); + Assert.assertEquals(dbRangerService.getName(), + rangerService.getName()); + Mockito.verify(serviceREST).createService(rangerService); + } + + @Test + public void test13updateService() throws Exception { + RangerService rangerService = rangerService(); + Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService); + RangerService dbRangerService = publicAPIsv2.updateService(rangerService, Id); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService, rangerService); + Assert.assertEquals(dbRangerService.getId(), + rangerService.getId()); + Assert.assertEquals(dbRangerService.getName(), + rangerService.getName()); + Mockito.verify(serviceREST).updateService(rangerService); + } + + @Test + public void test14updateServiceByName() throws Exception { + RangerService rangerService = rangerService(); + String name = rangerService.getName(); + Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService); + Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService); + RangerService dbRangerService = publicAPIsv2.updateServiceByName(rangerService, name); + Assert.assertNotNull(dbRangerService); + Assert.assertEquals(dbRangerService, rangerService); + Assert.assertEquals(dbRangerService.getId(), + rangerService.getId()); + Assert.assertEquals(dbRangerService.getName(), + rangerService.getName()); + Mockito.verify(serviceREST).updateService(rangerService); + Mockito.verify(serviceREST).getServiceByName(name); + } + + @Test + public void test15deleteService() throws Exception { + Mockito.doNothing().when(serviceREST).deleteService(Id); + publicAPIsv2.deleteService(Id); + Mockito.verify(serviceREST).deleteService(Id); + } + + @Test + public void test16deleteServiceByName() throws Exception { + RangerService rangerService = rangerService(); + String name = rangerService.getName(); + Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService); + Mockito.doNothing().when(serviceREST).deleteService(rangerService.getId()); + publicAPIsv2.deleteServiceByName(name); + Mockito.verify(serviceREST).deleteService(rangerService.getId()); + Mockito.verify(serviceREST).getServiceByName(name); + } + + @Test + public void test17getPolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(serviceREST.getPolicy(rangerPolicy.getId())).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicy(Id); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).getPolicy(Id); + } + + @Test + public void test18getPolicyByName() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + RangerService rangerService = rangerService(); + String serviceName = rangerService.getName(); + String policyName = rangerPolicy.getName(); + List<RangerPolicy> policies = new ArrayList<RangerPolicy>(); + policies.add(rangerPolicy); + Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies); + RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicyByName(serviceName, policyName, request); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject()); + } + + @Test + public void test19searchPolicies() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + List<RangerPolicy> policiesList = new ArrayList<RangerPolicy>(); + RangerService service = rangerService(); + String serviceName = service.getName(); + RangerPolicy rangerPolicy = rangerPolicy(); + policiesList.add(rangerPolicy); + RangerPolicyList policyList = new RangerPolicyList(policiesList); + Mockito.when(serviceREST.getServicePoliciesByName(serviceName, request)).thenReturn(policyList); + List<RangerPolicy> dbRangerPolicyList = publicAPIsv2.searchPolicies(serviceName, request); + Assert.assertNotNull(dbRangerPolicyList); + Assert.assertEquals(dbRangerPolicyList.size(), policiesList.size()); + Mockito.verify(serviceREST).getServicePoliciesByName(serviceName, request); + } + + @Test + public void test20createPolicy() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(serviceREST.createPolicy(rangerPolicy, request)).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = publicAPIsv2.createPolicy(rangerPolicy, request); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).createPolicy(rangerPolicy, request); + } + + @Test + public void test21applyPolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(serviceREST.applyPolicy(rangerPolicy)).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = publicAPIsv2.applyPolicy(rangerPolicy); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).applyPolicy(rangerPolicy); + } + + @Test + public void test22updatePolicy() throws Exception { + RangerPolicy rangerPolicy = rangerPolicy(); + Mockito.when(serviceREST.updatePolicy(rangerPolicy)).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicy(rangerPolicy, Id); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).updatePolicy(rangerPolicy); + } + + @Test + public void test23updatePolicyByName() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + String policyName = rangerPolicy.getName(); + RangerService rangerService = rangerService(); + String serviceName = rangerService.getName(); + List<RangerPolicy> policies = new ArrayList<RangerPolicy>(); + policies.add(rangerPolicy); + Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies); + Mockito.when(serviceREST.updatePolicy(rangerPolicy)).thenReturn(rangerPolicy); + RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicyByName(rangerPolicy, serviceName, policyName, request); + Assert.assertNotNull(dbRangerPolicy); + Assert.assertEquals(dbRangerPolicy, rangerPolicy); + Assert.assertEquals(dbRangerPolicy.getId(), + rangerPolicy.getId()); + Assert.assertEquals(dbRangerPolicy.getName(), + rangerPolicy.getName()); + Mockito.verify(serviceREST).updatePolicy(rangerPolicy); + Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject()); + } + + @Test + public void test24deletePolicy() throws Exception { + Mockito.doNothing().when(serviceREST).deletePolicy(Id); + publicAPIsv2.deletePolicy(Id); + Mockito.verify(serviceREST).deletePolicy(Id); + } + + @Test + public void test25deletePolicyByName() throws Exception { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + RangerPolicy rangerPolicy = rangerPolicy(); + String policyName = rangerPolicy.getName(); + RangerService rangerService = rangerService(); + String serviceName = rangerService.getName(); + List<RangerPolicy> policies = new ArrayList<RangerPolicy>(); + policies.add(rangerPolicy); + Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies); + Mockito.doNothing().when(serviceREST).deletePolicy(Id); + publicAPIsv2.deletePolicyByName(serviceName, policyName, request); + Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject()); + Mockito.verify(serviceREST).deletePolicy(Id); + } +}
