http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefService.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefService.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefService.java new file mode 100644 index 0000000..94680c3 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefService.java @@ -0,0 +1,792 @@ +/* + * 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.List; +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.XXContextEnricherDefDao; +import org.apache.ranger.db.XXEnumDefDao; +import org.apache.ranger.db.XXEnumElementDefDao; +import org.apache.ranger.db.XXPolicyConditionDefDao; +import org.apache.ranger.db.XXPortalUserDao; +import org.apache.ranger.db.XXResourceDefDao; +import org.apache.ranger.db.XXServiceConfigDefDao; + +import org.apache.ranger.db.XXServiceDefDao; +import org.apache.ranger.entity.XXAccessTypeDef; +import org.apache.ranger.entity.XXContextEnricherDef; +import org.apache.ranger.entity.XXEnumDef; +import org.apache.ranger.entity.XXEnumElementDef; +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.XXPortalUser; +import org.apache.ranger.entity.XXResourceDef; +import org.apache.ranger.entity.XXServiceConfigDef; +import org.apache.ranger.entity.XXServiceDef; + +import org.apache.ranger.plugin.model.RangerServiceDef; +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.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 TestRangerServiceDefService { + + private static Long Id = 8L; + + @InjectMocks + RangerServiceDefService serviceDefService = new RangerServiceDefService(); + + @Mock + RangerDaoManager daoManager; + + @Mock + JSONUtil jsonUtil; + + @Mock + RangerPolicyService policyService; + + @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 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 XXServiceDef serviceDef() { + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(Id); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("HDFS Repository"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(Id); + xServiceDef.setVersion(Id); + xServiceDef.setUpdateTime(new Date()); + xServiceDef.setUpdatedByUserId(Id); + xServiceDef.setImplclassname("RangerServiceHdfs"); + xServiceDef.setLabel("HDFS Repository"); + xServiceDef.setRbkeylabel(null); + xServiceDef.setRbkeydescription(null); + xServiceDef.setIsEnabled(true); + + return xServiceDef; + } + + 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 test1ValidateForCreate() { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + serviceDefService.validateForCreate(rangerServiceDef); + Assert.assertNotNull(rangerServiceDef); + } + + @Test + public void test2ValidateForUpdate() { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + XXServiceDef serviceDef = serviceDef(); + serviceDefService.validateForUpdate(rangerServiceDef, serviceDef); + + Assert.assertNotNull(rangerServiceDef); + } + + @Test + public void test3PopulateViewBean() { + + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXServiceConfigDefDao xServiceConfigDefDao = Mockito + .mock(XXServiceConfigDefDao.class); + XXContextEnricherDefDao xContextEnricherDefDao = Mockito + .mock(XXContextEnricherDefDao.class); + XXEnumDefDao xEnumDefDao = Mockito.mock(XXEnumDefDao.class); + XXEnumElementDefDao xEnumElementDefDao = Mockito + .mock(XXEnumElementDefDao.class); + + XXServiceDef serviceDef = serviceDef(); + XXPolicy policy = policy(); + + 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); + + 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); + + 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<XXServiceConfigDef> serviceConfigDefList = new ArrayList<XXServiceConfigDef>(); + XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef(); + serviceConfigDefObj.setAddedByUserId(Id); + serviceConfigDefObj.setCreateTime(new Date()); + serviceConfigDefObj.setDefaultvalue("simple"); + serviceConfigDefObj.setDescription("service config"); + serviceConfigDefObj.setId(Id); + serviceConfigDefObj.setIsMandatory(true); + serviceConfigDefObj.setName(name); + serviceConfigDefObj.setLabel("username"); + serviceConfigDefObj.setRbkeydescription(null); + serviceConfigDefObj.setRbkeylabel(null); + serviceConfigDefObj.setRbKeyValidationMessage(null); + serviceConfigDefObj.setType("password"); + serviceConfigDefList.add(serviceConfigDefObj); + + List<XXContextEnricherDef> contextEnrichersList = new ArrayList<XXContextEnricherDef>(); + XXContextEnricherDef contextEnricherDefObj = new XXContextEnricherDef(); + contextEnricherDefObj.setAddedByUserId(Id); + contextEnricherDefObj.setCreateTime(new Date()); + contextEnricherDefObj.setDefid(Id); + contextEnricherDefObj.setEnricher("RangerCountryProvider"); + contextEnricherDefObj.setName("country-provider"); + contextEnricherDefObj.setId(Id); + contextEnricherDefObj.setOrder(0); + contextEnricherDefObj.setUpdatedByUserId(Id); + contextEnricherDefObj.setUpdateTime(new Date()); + contextEnrichersList.add(contextEnricherDefObj); + + List<XXEnumDef> xEnumList = new ArrayList<XXEnumDef>(); + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(null); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName(name); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + xEnumList.add(enumDefObj); + + List<XXEnumElementDef> xElementsList = new ArrayList<XXEnumElementDef>(); + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Authentication"); + enumElementDefObj.setName("authentication"); + enumElementDefObj.setUpdateTime(new Date()); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setRbkeylabel(null); + enumElementDefObj.setOrder(0); + xElementsList.add(enumElementDefObj); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser); + + Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn( + xServiceConfigDefDao); + Mockito.when( + xServiceConfigDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(serviceConfigDefList); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + 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.getXXContextEnricherDef()).thenReturn( + xContextEnricherDefDao); + Mockito.when( + xContextEnricherDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(contextEnrichersList); + + Mockito.when(daoManager.getXXEnumDef()).thenReturn(xEnumDefDao); + Mockito.when(xEnumDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(xEnumList); + + Mockito.when(daoManager.getXXEnumElementDef()).thenReturn( + xEnumElementDefDao); + Mockito.when( + xEnumElementDefDao.findByEnumDefId(enumElementDefObj.getId())) + .thenReturn(xElementsList); + + RangerServiceDef dbRangerServiceDef = serviceDefService + .populateViewBean(serviceDef); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getId(), serviceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getName(), serviceDef.getName()); + Assert.assertEquals(dbRangerServiceDef.getDescription(), + serviceDef.getDescription()); + Assert.assertEquals(dbRangerServiceDef.getGuid(), serviceDef.getGuid()); + Assert.assertEquals(dbRangerServiceDef.getVersion(), + serviceDef.getVersion()); + Mockito.verify(daoManager).getXXServiceConfigDef(); + Mockito.verify(daoManager).getXXResourceDef(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXContextEnricherDef(); + Mockito.verify(daoManager).getXXEnumDef(); + Mockito.verify(daoManager).getXXEnumElementDef(); + } + + @Test + public void test4getAllServiceDefs() { + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXServiceConfigDefDao xServiceConfigDefDao = Mockito + .mock(XXServiceConfigDefDao.class); + XXContextEnricherDefDao xContextEnricherDefDao = Mockito + .mock(XXContextEnricherDefDao.class); + XXEnumDefDao xEnumDefDao = Mockito.mock(XXEnumDefDao.class); + XXEnumElementDefDao xEnumElementDefDao = Mockito + .mock(XXEnumElementDefDao.class); + + List<XXServiceDef> xServiceDefList = new ArrayList<XXServiceDef>(); + XXServiceDef serviceDef = new XXServiceDef(); + serviceDef.setAddedByUserId(Id); + serviceDef.setCreateTime(new Date()); + serviceDef.setDescription("HDFS Repository"); + serviceDef.setGuid("1427365526516_835_0"); + serviceDef.setId(Id); + serviceDef.setVersion(Id); + serviceDef.setUpdateTime(new Date()); + serviceDef.setUpdatedByUserId(Id); + serviceDef.setImplclassname("RangerServiceHdfs"); + serviceDef.setLabel("HDFS Repository"); + serviceDef.setRbkeylabel(null); + serviceDef.setRbkeydescription(null); + serviceDef.setIsEnabled(true); + xServiceDefList.add(serviceDef); + + XXPolicy policy = policy(); + + 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); + + 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); + + 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<XXServiceConfigDef> serviceConfigDefList = new ArrayList<XXServiceConfigDef>(); + XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef(); + serviceConfigDefObj.setAddedByUserId(Id); + serviceConfigDefObj.setCreateTime(new Date()); + serviceConfigDefObj.setDefaultvalue("simple"); + serviceConfigDefObj.setDescription("service config"); + serviceConfigDefObj.setId(Id); + serviceConfigDefObj.setIsMandatory(true); + serviceConfigDefObj.setName(name); + serviceConfigDefObj.setLabel("username"); + serviceConfigDefObj.setRbkeydescription(null); + serviceConfigDefObj.setRbkeylabel(null); + serviceConfigDefObj.setRbKeyValidationMessage(null); + serviceConfigDefObj.setType("password"); + serviceConfigDefList.add(serviceConfigDefObj); + + List<XXContextEnricherDef> contextEnrichersList = new ArrayList<XXContextEnricherDef>(); + XXContextEnricherDef contextEnricherDefObj = new XXContextEnricherDef(); + contextEnricherDefObj.setAddedByUserId(Id); + contextEnricherDefObj.setCreateTime(new Date()); + contextEnricherDefObj.setDefid(Id); + contextEnricherDefObj.setEnricher("RangerCountryProvider"); + contextEnricherDefObj.setName("country-provider"); + contextEnricherDefObj.setId(Id); + contextEnricherDefObj.setOrder(0); + contextEnricherDefObj.setUpdatedByUserId(Id); + contextEnricherDefObj.setUpdateTime(new Date()); + contextEnrichersList.add(contextEnricherDefObj); + + List<XXEnumDef> xEnumList = new ArrayList<XXEnumDef>(); + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(null); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName(name); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + xEnumList.add(enumDefObj); + + List<XXEnumElementDef> xElementsList = new ArrayList<XXEnumElementDef>(); + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Authentication"); + enumElementDefObj.setName("authentication"); + enumElementDefObj.setUpdateTime(new Date()); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setRbkeylabel(null); + enumElementDefObj.setOrder(0); + xElementsList.add(enumElementDefObj); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.getAll()).thenReturn(xServiceDefList); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser); + + Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn( + xServiceConfigDefDao); + Mockito.when( + xServiceConfigDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(serviceConfigDefList); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + 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.getXXContextEnricherDef()).thenReturn( + xContextEnricherDefDao); + Mockito.when( + xContextEnricherDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(contextEnrichersList); + + Mockito.when(daoManager.getXXEnumDef()).thenReturn(xEnumDefDao); + Mockito.when(xEnumDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(xEnumList); + + Mockito.when(daoManager.getXXEnumElementDef()).thenReturn( + xEnumElementDefDao); + Mockito.when( + xEnumElementDefDao.findByEnumDefId(enumElementDefObj.getId())) + .thenReturn(xElementsList); + + List<RangerServiceDef> dbRangerServiceDef = serviceDefService + .getAllServiceDefs(); + Assert.assertNotNull(dbRangerServiceDef); + Mockito.verify(daoManager).getXXServiceConfigDef(); + Mockito.verify(daoManager).getXXResourceDef(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXContextEnricherDef(); + Mockito.verify(daoManager).getXXEnumDef(); + Mockito.verify(daoManager).getXXEnumElementDef(); + } + + @Test + public void test5getPopulatedViewObject() { + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceConfigDefDao xServiceConfigDefDao = Mockito + .mock(XXServiceConfigDefDao.class); + + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXAccessTypeDefDao xAccessTypeDefDao = Mockito + .mock(XXAccessTypeDefDao.class); + XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class); + XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito + .mock(XXPolicyConditionDefDao.class); + XXContextEnricherDefDao xContextEnricherDefDao = Mockito + .mock(XXContextEnricherDefDao.class); + XXEnumDefDao xEnumDefDao = Mockito.mock(XXEnumDefDao.class); + XXEnumElementDefDao xEnumElementDefDao = Mockito + .mock(XXEnumElementDefDao.class); + + XXServiceDef serviceDef = serviceDef(); + XXPolicy policy = policy(); + 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); + + List<XXServiceConfigDef> serviceConfigDefList = new ArrayList<XXServiceConfigDef>(); + XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef(); + serviceConfigDefObj.setAddedByUserId(Id); + serviceConfigDefObj.setCreateTime(new Date()); + serviceConfigDefObj.setDefaultvalue("simple"); + serviceConfigDefObj.setDescription("service config"); + serviceConfigDefObj.setId(Id); + serviceConfigDefObj.setIsMandatory(true); + serviceConfigDefObj.setName(name); + serviceConfigDefObj.setLabel("username"); + serviceConfigDefObj.setRbkeydescription(null); + serviceConfigDefObj.setRbkeylabel(null); + serviceConfigDefObj.setRbKeyValidationMessage(null); + serviceConfigDefObj.setType("password"); + serviceConfigDefList.add(serviceConfigDefObj); + + 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); + + 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<XXContextEnricherDef> contextEnrichersList = new ArrayList<XXContextEnricherDef>(); + XXContextEnricherDef contextEnricherDefObj = new XXContextEnricherDef(); + contextEnricherDefObj.setAddedByUserId(Id); + contextEnricherDefObj.setCreateTime(new Date()); + contextEnricherDefObj.setDefid(Id); + contextEnricherDefObj.setEnricher("RangerCountryProvider"); + contextEnricherDefObj.setName("country-provider"); + contextEnricherDefObj.setId(Id); + contextEnricherDefObj.setOrder(0); + contextEnricherDefObj.setUpdatedByUserId(Id); + contextEnricherDefObj.setUpdateTime(new Date()); + contextEnrichersList.add(contextEnricherDefObj); + + List<XXEnumDef> xEnumList = new ArrayList<XXEnumDef>(); + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(null); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName(name); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + xEnumList.add(enumDefObj); + + List<XXEnumElementDef> xElementsList = new ArrayList<XXEnumElementDef>(); + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Authentication"); + enumElementDefObj.setName("authentication"); + enumElementDefObj.setUpdateTime(new Date()); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setRbkeylabel(null); + enumElementDefObj.setOrder(0); + xElementsList.add(enumElementDefObj); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser); + + Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn( + xServiceConfigDefDao); + Mockito.when( + xServiceConfigDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(serviceConfigDefList); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.findByPolicyId(policy.getId())) + .thenReturn(resDefList); + + 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.getXXContextEnricherDef()).thenReturn( + xContextEnricherDefDao); + Mockito.when( + xContextEnricherDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(contextEnrichersList); + + Mockito.when(daoManager.getXXEnumDef()).thenReturn(xEnumDefDao); + Mockito.when(xEnumDefDao.findByServiceDefId(serviceDef.getId())) + .thenReturn(xEnumList); + + Mockito.when(daoManager.getXXEnumElementDef()).thenReturn( + xEnumElementDefDao); + Mockito.when( + xEnumElementDefDao.findByEnumDefId(enumElementDefObj.getId())) + .thenReturn(xElementsList); + + RangerServiceDef dbRangerServiceDef = serviceDefService + .getPopulatedViewObject(serviceDef); + Assert.assertNotNull(dbRangerServiceDef); + Mockito.verify(daoManager).getXXServiceConfigDef(); + Mockito.verify(daoManager).getXXResourceDef(); + Mockito.verify(daoManager).getXXAccessTypeDef(); + Mockito.verify(daoManager).getXXPolicyConditionDef(); + Mockito.verify(daoManager).getXXContextEnricherDef(); + Mockito.verify(daoManager).getXXEnumDef(); + Mockito.verify(daoManager).getXXEnumElementDef(); + } + +}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefServiceBase.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefServiceBase.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefServiceBase.java new file mode 100644 index 0000000..db3d044 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceDefServiceBase.java @@ -0,0 +1,810 @@ +/* + * 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.List; + +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.XXAccessTypeDefGrantsDao; +import org.apache.ranger.db.XXEnumElementDefDao; +import org.apache.ranger.db.XXResourceDefDao; +import org.apache.ranger.entity.XXAccessTypeDef; +import org.apache.ranger.entity.XXContextEnricherDef; +import org.apache.ranger.entity.XXDBBase; +import org.apache.ranger.entity.XXEnumDef; +import org.apache.ranger.entity.XXEnumElementDef; +import org.apache.ranger.entity.XXPolicyConditionDef; +import org.apache.ranger.entity.XXResourceDef; +import org.apache.ranger.entity.XXServiceConfigDef; +import org.apache.ranger.entity.XXServiceDef; +import org.apache.ranger.plugin.model.RangerServiceDef; +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.RangerEnumElementDef; +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.RangerServiceDefList; +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 TestRangerServiceDefServiceBase { + + private static Long Id = 8L; + + @InjectMocks + RangerServiceDefService rangerServiceDefService = new RangerServiceDefService(); + + @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 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 XXServiceDef serviceDef() { + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(Id); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("HDFS Repository"); + xServiceDef.setGuid("0d047247-bafe-4cf8-8e9b-d5d377284b2d"); + xServiceDef.setId(Id); + xServiceDef.setImplclassname("RangerServiceHdfs"); + xServiceDef.setIsEnabled(true); + xServiceDef.setLabel("HDFS Repository"); + xServiceDef.setName("hdfs"); + xServiceDef.setRbkeydescription(null); + xServiceDef.setRbkeylabel(null); + xServiceDef.setUpdatedByUserId(Id); + xServiceDef.setUpdateTime(new Date()); + xServiceDef.setVersion(Id); + + return xServiceDef; + } + + @Test + public void test1MapViewToEntityBean() { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + XXServiceDef serviceDef = serviceDef(); + int operationContext = 1; + + XXServiceDef dbServiceDef = rangerServiceDefService + .mapViewToEntityBean(rangerServiceDef, serviceDef, + operationContext); + Assert.assertNotNull(dbServiceDef); + Assert.assertEquals(dbServiceDef, serviceDef); + Assert.assertEquals(dbServiceDef.getDescription(), + serviceDef.getDescription()); + Assert.assertEquals(dbServiceDef.getGuid(), serviceDef.getGuid()); + Assert.assertEquals(dbServiceDef.getName(), serviceDef.getName()); + Assert.assertEquals(dbServiceDef.getAddedByUserId(), + serviceDef.getAddedByUserId()); + Assert.assertEquals(dbServiceDef.getId(), serviceDef.getId()); + Assert.assertEquals(dbServiceDef.getVersion(), serviceDef.getVersion()); + Assert.assertEquals(dbServiceDef.getImplclassname(), + serviceDef.getImplclassname()); + Assert.assertEquals(dbServiceDef.getUpdatedByUserId(), + serviceDef.getUpdatedByUserId()); + } + + @Test + public void test2MapEntityToViewBean() { + RangerServiceDef rangerServiceDef = rangerServiceDef(); + XXServiceDef serviceDef = serviceDef(); + + RangerServiceDef dbRangerServiceDef = rangerServiceDefService + .mapEntityToViewBean(rangerServiceDef, serviceDef); + Assert.assertNotNull(dbRangerServiceDef); + Assert.assertEquals(dbRangerServiceDef, rangerServiceDef); + Assert.assertEquals(dbRangerServiceDef.getDescription(), + rangerServiceDef.getDescription()); + Assert.assertEquals(dbRangerServiceDef.getGuid(), + rangerServiceDef.getGuid()); + Assert.assertEquals(dbRangerServiceDef.getName(), + rangerServiceDef.getName()); + Assert.assertEquals(dbRangerServiceDef.getId(), + rangerServiceDef.getId()); + Assert.assertEquals(dbRangerServiceDef.getVersion(), + rangerServiceDef.getVersion()); + + } + + @Test + public void test3populateRangerServiceConfigDefToXX() { + RangerServiceConfigDef serviceConfigDefObj = new RangerServiceConfigDef(); + XXServiceConfigDef configDefObj = new XXServiceConfigDef(); + XXServiceDef serviceDefObj = new XXServiceDef(); + + Mockito.when( + (XXServiceConfigDef) rangerAuditFields.populateAuditFields( + configDefObj, serviceDefObj)).thenReturn(configDefObj); + + XXServiceConfigDef dbServiceConfigDef = rangerServiceDefService + .populateRangerServiceConfigDefToXX(serviceConfigDefObj, + configDefObj, serviceDefObj, 1); + Assert.assertNotNull(dbServiceConfigDef); + + } + + @Test + public void test4populateXXToRangerServiceConfigDef() { + XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef(); + + RangerServiceConfigDef dbserviceConfigDefObj = rangerServiceDefService + .populateXXToRangerServiceConfigDef(serviceConfigDefObj); + Assert.assertNotNull(dbserviceConfigDefObj); + } + + @Test + public void test5populateRangerResourceDefToXX() { + RangerResourceDef rangerResourceDefObj = new RangerResourceDef(); + rangerResourceDefObj.setDescription("HDFS Repository"); + rangerResourceDefObj.setExcludesSupported(false); + rangerResourceDefObj.setLabel("HDFS Repository"); + rangerResourceDefObj.setName("HDFs"); + + XXResourceDef resourceDefObj = new XXResourceDef(); + resourceDefObj.setAddedByUserId(Id); + resourceDefObj.setCreateTime(new Date()); + resourceDefObj.setDefid(Id); + resourceDefObj.setDescription("HDFS Repository"); + resourceDefObj.setId(Id); + + XXServiceDef serviceDefObj = new XXServiceDef(); + serviceDefObj.setAddedByUserId(Id); + serviceDefObj.setCreateTime(new Date()); + serviceDefObj.setDescription("HDFS Repository"); + serviceDefObj.setGuid("1427365526516_835_0"); + serviceDefObj.setId(Id); + + Mockito.when( + (XXResourceDef) rangerAuditFields.populateAuditFields( + resourceDefObj, serviceDefObj)).thenReturn( + resourceDefObj); + + XXResourceDef dbResourceDef = rangerServiceDefService + .populateRangerResourceDefToXX(rangerResourceDefObj, + resourceDefObj, serviceDefObj, 1); + Assert.assertNotNull(dbResourceDef); + Assert.assertEquals(dbResourceDef, resourceDefObj); + Assert.assertEquals(dbResourceDef.getId(), resourceDefObj.getId()); + Assert.assertEquals(dbResourceDef.getLabel(), resourceDefObj.getLabel()); + Assert.assertEquals(dbResourceDef.getName(), resourceDefObj.getName()); + Assert.assertEquals(dbResourceDef.getDescription(), + resourceDefObj.getDescription()); + + } + + @Test + public void test6populateXXToRangerResourceDef() { + XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class); + XXResourceDef resourceDefObj = new XXResourceDef(); + resourceDefObj.setAddedByUserId(Id); + resourceDefObj.setCreateTime(new Date()); + resourceDefObj.setDefid(Id); + resourceDefObj.setDescription("HDFS Repository"); + resourceDefObj.setId(Id); + + Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao); + Mockito.when(xResourceDefDao.getById(resourceDefObj.getId())) + .thenReturn(resourceDefObj); + + RangerResourceDef dbRangerResourceDef = rangerServiceDefService + .populateXXToRangerResourceDef(resourceDefObj); + Assert.assertNotNull(dbRangerResourceDef); + Assert.assertEquals(dbRangerResourceDef.getName(), + resourceDefObj.getName()); + Assert.assertEquals(dbRangerResourceDef.getDescription(), + resourceDefObj.getDescription()); + Assert.assertEquals(dbRangerResourceDef.getType(), + resourceDefObj.getType()); + Assert.assertEquals(dbRangerResourceDef.getParent(), + resourceDefObj.getParent()); + Assert.assertEquals(dbRangerResourceDef.getRbKeyDescription(), + resourceDefObj.getRbkeydescription()); + Mockito.verify(daoManager).getXXResourceDef(); + } + + @Test + public void test7populateRangerAccessTypeDefToXX() { + RangerAccessTypeDef rangerAccessTypeDefObj = new RangerAccessTypeDef(); + rangerAccessTypeDefObj.setLabel("Read"); + rangerAccessTypeDefObj.setName("read"); + rangerAccessTypeDefObj.setRbKeyLabel(null); + XXAccessTypeDef accessTypeDefObj = new XXAccessTypeDef(); + accessTypeDefObj.setAddedByUserId(Id); + accessTypeDefObj.setCreateTime(new Date()); + accessTypeDefObj.setDefid(Id); + accessTypeDefObj.setId(Id); + accessTypeDefObj.setLabel("Read"); + accessTypeDefObj.setName("read"); + accessTypeDefObj.setOrder(null); + accessTypeDefObj.setRbkeylabel(null); + accessTypeDefObj.setUpdatedByUserId(Id); + accessTypeDefObj.setUpdateTime(new Date()); + XXServiceDef serviceDefObj = new XXServiceDef(); + serviceDefObj.setAddedByUserId(Id); + serviceDefObj.setCreateTime(new Date()); + serviceDefObj.setDescription("HDFS Repository"); + serviceDefObj.setGuid("1427365526516_835_0"); + serviceDefObj.setId(Id); + + Mockito.when( + (XXAccessTypeDef) rangerAuditFields.populateAuditFields( + accessTypeDefObj, serviceDefObj)).thenReturn( + accessTypeDefObj); + + XXAccessTypeDef dbAccessTypeDef = rangerServiceDefService + .populateRangerAccessTypeDefToXX(rangerAccessTypeDefObj, + accessTypeDefObj, serviceDefObj, 1); + Assert.assertNotNull(dbAccessTypeDef); + Assert.assertEquals(dbAccessTypeDef, accessTypeDefObj); + Assert.assertEquals(dbAccessTypeDef.getName(), + accessTypeDefObj.getName()); + Assert.assertEquals(dbAccessTypeDef.getLabel(), + accessTypeDefObj.getLabel()); + Assert.assertEquals(dbAccessTypeDef.getRbkeylabel(), + accessTypeDefObj.getRbkeylabel()); + Assert.assertEquals(dbAccessTypeDef.getDefid(), + accessTypeDefObj.getDefid()); + Assert.assertEquals(dbAccessTypeDef.getId(), accessTypeDefObj.getId()); + Assert.assertEquals(dbAccessTypeDef.getCreateTime(), + accessTypeDefObj.getCreateTime()); + Assert.assertEquals(dbAccessTypeDef.getOrder(), + accessTypeDefObj.getOrder()); + + } + + @Test + public void test8populateRangerAccessTypeDefToXXNullValue() { + RangerAccessTypeDef rangerAccessTypeDefObj = null; + XXAccessTypeDef accessTypeDefObj = null; + XXServiceDef serviceDefObj = null; + Mockito.when( + restErrorUtil.createRESTException( + "RangerServiceDef cannot be null.", + MessageEnums.DATA_NOT_FOUND)).thenThrow( + new WebApplicationException()); + + thrown.expect(WebApplicationException.class); + XXAccessTypeDef dbAccessTypeDef = rangerServiceDefService + .populateRangerAccessTypeDefToXX(rangerAccessTypeDefObj, + accessTypeDefObj, serviceDefObj, 1); + Assert.assertNull(dbAccessTypeDef); + } + + @Test + public void test9populateXXToRangerAccessTypeDef() { + + XXAccessTypeDefGrantsDao xAccessTypeDefGrantsDao = Mockito + .mock(XXAccessTypeDefGrantsDao.class); + List<String> lists = new ArrayList<String>(); + XXAccessTypeDef accessTypeDefObj = new XXAccessTypeDef(); + accessTypeDefObj.setAddedByUserId(Id); + accessTypeDefObj.setCreateTime(new Date()); + accessTypeDefObj.setDefid(Id); + accessTypeDefObj.setId(Id); + accessTypeDefObj.setLabel("Read"); + accessTypeDefObj.setName("read"); + accessTypeDefObj.setOrder(null); + accessTypeDefObj.setRbkeylabel(null); + accessTypeDefObj.setUpdatedByUserId(Id); + accessTypeDefObj.setUpdateTime(new Date()); + + Mockito.when(daoManager.getXXAccessTypeDefGrants()).thenReturn( + xAccessTypeDefGrantsDao); + Mockito.when( + xAccessTypeDefGrantsDao + .findImpliedGrantsByATDId(accessTypeDefObj.getId())) + .thenReturn(lists); + + RangerAccessTypeDef dbRangerAccessTypeDef = rangerServiceDefService + .populateXXToRangerAccessTypeDef(accessTypeDefObj); + Assert.assertNotNull(dbRangerAccessTypeDef); + Assert.assertEquals(dbRangerAccessTypeDef.getName(), + accessTypeDefObj.getName()); + Assert.assertEquals(dbRangerAccessTypeDef.getLabel(), + accessTypeDefObj.getLabel()); + Assert.assertEquals(dbRangerAccessTypeDef.getRbKeyLabel(), + accessTypeDefObj.getRbkeylabel()); + + } + + @Test + public void test10populateRangerPolicyConditionDefToXX() { + RangerPolicyConditionDef rangerConditionDefvObj = new RangerPolicyConditionDef(); + rangerConditionDefvObj.setDescription("Countries"); + rangerConditionDefvObj.setEvaluator("COUNTRY"); + rangerConditionDefvObj.setLabel("Countries"); + rangerConditionDefvObj.setName("country"); + rangerConditionDefvObj.setRbKeyDescription(null); + rangerConditionDefvObj.setRbKeyLabel(null); + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName("country"); + policyConditionDefObj.setOrder(0); + policyConditionDefObj.setUpdatedByUserId(Id); + policyConditionDefObj.setUpdateTime(new Date()); + XXServiceDef serviceDefObj = new XXServiceDef(); + serviceDefObj.setAddedByUserId(Id); + serviceDefObj.setCreateTime(new Date()); + serviceDefObj.setDescription("HDFS Repository"); + serviceDefObj.setGuid("1427365526516_835_0"); + serviceDefObj.setId(Id); + + Mockito.when( + (XXPolicyConditionDef) rangerAuditFields.populateAuditFields( + policyConditionDefObj, serviceDefObj)).thenReturn( + policyConditionDefObj); + + XXPolicyConditionDef dbPolicyConditionDef = rangerServiceDefService + .populateRangerPolicyConditionDefToXX(rangerConditionDefvObj, + policyConditionDefObj, serviceDefObj, 1); + Assert.assertNotNull(dbPolicyConditionDef); + Assert.assertEquals(dbPolicyConditionDef, policyConditionDefObj); + Assert.assertEquals(dbPolicyConditionDef.getName(), + policyConditionDefObj.getName()); + Assert.assertEquals(dbPolicyConditionDef.getDescription(), + policyConditionDefObj.getDescription()); + Assert.assertEquals(dbPolicyConditionDef.getEvaluator(), + policyConditionDefObj.getEvaluator()); + Assert.assertEquals(dbPolicyConditionDef.getLabel(), + policyConditionDefObj.getLabel()); + Assert.assertEquals(dbPolicyConditionDef.getId(), + policyConditionDefObj.getId()); + Assert.assertEquals(dbPolicyConditionDef.getRbkeydescription(), + policyConditionDefObj.getRbkeydescription()); + Assert.assertEquals(dbPolicyConditionDef.getOrder(), + policyConditionDefObj.getOrder()); + Assert.assertEquals(dbPolicyConditionDef.getUpdatedByUserId(), + policyConditionDefObj.getUpdatedByUserId()); + Assert.assertEquals(dbPolicyConditionDef.getUpdateTime(), + policyConditionDefObj.getUpdateTime()); + + } + + @Test + public void test11populateRangerPolicyConditionDefToXXnullValue() { + RangerPolicyConditionDef rangerConditionDefvObj = null; + XXPolicyConditionDef policyConditionDefObj = null; + XXServiceDef serviceDefObj = null; + + Mockito.when( + restErrorUtil.createRESTException( + "RangerServiceDef cannot be null.", + MessageEnums.DATA_NOT_FOUND)).thenThrow( + new WebApplicationException()); + + thrown.expect(WebApplicationException.class); + + XXPolicyConditionDef dbPolicyConditionDef = rangerServiceDefService + .populateRangerPolicyConditionDefToXX(rangerConditionDefvObj, + policyConditionDefObj, serviceDefObj, 1); + Assert.assertNull(dbPolicyConditionDef); + } + + @Test + public void test12populateXXToRangerPolicyConditionDef() { + XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef(); + policyConditionDefObj.setAddedByUserId(Id); + policyConditionDefObj.setCreateTime(new Date()); + policyConditionDefObj.setDefid(Id); + policyConditionDefObj.setDescription("policy"); + policyConditionDefObj.setId(Id); + policyConditionDefObj.setName("country"); + policyConditionDefObj.setOrder(0); + policyConditionDefObj.setUpdatedByUserId(Id); + policyConditionDefObj.setUpdateTime(new Date()); + + RangerPolicyConditionDef dbRangerPolicyConditionDef = rangerServiceDefService + .populateXXToRangerPolicyConditionDef(policyConditionDefObj); + Assert.assertNotNull(dbRangerPolicyConditionDef); + Assert.assertEquals(dbRangerPolicyConditionDef.getName(), + policyConditionDefObj.getName()); + Assert.assertEquals(dbRangerPolicyConditionDef.getDescription(), + policyConditionDefObj.getDescription()); + Assert.assertEquals(dbRangerPolicyConditionDef.getEvaluator(), + policyConditionDefObj.getEvaluator()); + Assert.assertEquals(dbRangerPolicyConditionDef.getLabel(), + policyConditionDefObj.getLabel()); + } + + @Test + public void test13populateRangerContextEnricherDefToXX() { + RangerContextEnricherDef rangerContextEnricherDefObj = new RangerContextEnricherDef(); + rangerContextEnricherDefObj.setName("country-provider"); + rangerContextEnricherDefObj.setEnricher("RangerCountryProvider"); + + XXContextEnricherDef contextEnricherDefObj = new XXContextEnricherDef(); + contextEnricherDefObj.setAddedByUserId(Id); + contextEnricherDefObj.setCreateTime(new Date()); + contextEnricherDefObj.setDefid(Id); + contextEnricherDefObj.setId(Id); + contextEnricherDefObj.setName("country-provider"); + contextEnricherDefObj + .setEnricherOptions("contextName=COUNTRY;dataFile=/etc/ranger/data/userCountry.properties"); + contextEnricherDefObj.setEnricher("RangerCountryProvider"); + contextEnricherDefObj.setOrder(null); + contextEnricherDefObj.setUpdatedByUserId(Id); + contextEnricherDefObj.setUpdateTime(new Date()); + XXServiceDef serviceDefObj = new XXServiceDef(); + serviceDefObj.setAddedByUserId(Id); + serviceDefObj.setCreateTime(new Date()); + serviceDefObj.setDescription("HDFS Repository"); + serviceDefObj.setGuid("1427365526516_835_0"); + serviceDefObj.setId(Id); + + Mockito.when( + (XXContextEnricherDef) rangerAuditFields.populateAuditFields( + contextEnricherDefObj, serviceDefObj)).thenReturn( + contextEnricherDefObj); + + XXContextEnricherDef dbContextEnricherDef = rangerServiceDefService + .populateRangerContextEnricherDefToXX( + rangerContextEnricherDefObj, contextEnricherDefObj, + serviceDefObj, 1); + Assert.assertNotNull(dbContextEnricherDef); + Assert.assertEquals(dbContextEnricherDef.getEnricher(), + contextEnricherDefObj.getEnricher()); + Assert.assertEquals(dbContextEnricherDef.getEnricherOptions(), + contextEnricherDefObj.getEnricherOptions()); + Assert.assertEquals(dbContextEnricherDef.getName(), + contextEnricherDefObj.getName()); + Assert.assertEquals(dbContextEnricherDef.getCreateTime(), + contextEnricherDefObj.getCreateTime()); + Assert.assertEquals(dbContextEnricherDef.getId(), + contextEnricherDefObj.getId()); + Assert.assertEquals(dbContextEnricherDef.getOrder(), + contextEnricherDefObj.getOrder()); + Assert.assertEquals(dbContextEnricherDef.getUpdatedByUserId(), + contextEnricherDefObj.getUpdatedByUserId()); + Assert.assertEquals(dbContextEnricherDef.getUpdateTime(), + contextEnricherDefObj.getUpdateTime()); + + } + + @Test + public void test14populateRangerContextEnricherDefToXXnullValue() { + RangerContextEnricherDef rangerContextEnricherDefObj = null; + XXContextEnricherDef contextEnricherDefObj = null; + XXServiceDef serviceDefObj = null; + + Mockito.when( + restErrorUtil.createRESTException( + "RangerServiceDef cannot be null.", + MessageEnums.DATA_NOT_FOUND)).thenThrow( + new WebApplicationException()); + + thrown.expect(WebApplicationException.class); + + XXContextEnricherDef dbContextEnricherDef = rangerServiceDefService + .populateRangerContextEnricherDefToXX( + rangerContextEnricherDefObj, contextEnricherDefObj, + serviceDefObj, 1); + Assert.assertNull(dbContextEnricherDef); + + } + + @Test + public void test15populateXXToRangerContextEnricherDef() { + XXContextEnricherDef contextEnricherDefObj = new XXContextEnricherDef(); + contextEnricherDefObj.setAddedByUserId(Id); + contextEnricherDefObj.setCreateTime(new Date()); + contextEnricherDefObj.setDefid(Id); + contextEnricherDefObj.setId(Id); + contextEnricherDefObj.setName("country-provider"); + contextEnricherDefObj + .setEnricherOptions("contextName=COUNTRY;dataFile=/etc/ranger/data/userCountry.properties"); + contextEnricherDefObj.setEnricher("RangerCountryProvider"); + contextEnricherDefObj.setOrder(null); + contextEnricherDefObj.setUpdatedByUserId(Id); + contextEnricherDefObj.setUpdateTime(new Date()); + + RangerContextEnricherDef dbRangerContextEnricherDef = rangerServiceDefService + .populateXXToRangerContextEnricherDef(contextEnricherDefObj); + Assert.assertNotNull(dbRangerContextEnricherDef); + Assert.assertEquals(dbRangerContextEnricherDef.getEnricher(), + contextEnricherDefObj.getEnricher()); + Assert.assertEquals(dbRangerContextEnricherDef.getName(), + contextEnricherDefObj.getName()); + + } + + @Test + public void test16populateRangerEnumDefToXX() { + RangerEnumDef rangerEnumDefObj = new RangerEnumDef(); + rangerEnumDefObj.setName("authnType"); + rangerEnumDefObj.setDefaultIndex(0); + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(0); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName("authnType"); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + XXServiceDef serviceDefObj = new XXServiceDef(); + serviceDefObj.setAddedByUserId(Id); + serviceDefObj.setCreateTime(new Date()); + serviceDefObj.setDescription("HDFS Repository"); + serviceDefObj.setGuid("1427365526516_835_0"); + serviceDefObj.setId(Id); + + Mockito.when( + (XXEnumDef) rangerAuditFields.populateAuditFields(enumDefObj, + serviceDefObj)).thenReturn(enumDefObj); + + XXEnumDef dbEnumDef = rangerServiceDefService + .populateRangerEnumDefToXX(rangerEnumDefObj, enumDefObj, + serviceDefObj,1); + Assert.assertNotNull(dbEnumDef); + Assert.assertEquals(dbEnumDef, enumDefObj); + Assert.assertEquals(dbEnumDef.getName(), enumDefObj.getName()); + Assert.assertEquals(dbEnumDef.getDefid(), enumDefObj.getDefid()); + Assert.assertEquals(dbEnumDef.getId(), enumDefObj.getId()); + Assert.assertEquals(dbEnumDef.getCreateTime(), + enumDefObj.getCreateTime()); + + } + + @Test + public void test17populateRangerEnumDefToXXnullValue() { + RangerEnumDef rangerEnumDefObj = null; + XXEnumDef enumDefObj = null; + XXServiceDef serviceDefObj = null; + + Mockito.when( + restErrorUtil.createRESTException( + "RangerServiceDef cannot be null.", + MessageEnums.DATA_NOT_FOUND)).thenThrow( + new WebApplicationException()); + + thrown.expect(WebApplicationException.class); + + XXEnumDef dbEnumDef = rangerServiceDefService + .populateRangerEnumDefToXX(rangerEnumDefObj, enumDefObj, + serviceDefObj, 1); + Assert.assertNull(dbEnumDef); + + } + + @Test + public void test18populateXXToRangerEnumDef() { + XXEnumElementDefDao xEnumElementDefDao = Mockito + .mock(XXEnumElementDefDao.class); + + List<XXEnumElementDef> enumElementDefList = new ArrayList<XXEnumElementDef>(); + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Simple"); + enumElementDefObj.setName("simple"); + enumElementDefObj.setOrder(0); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setUpdateTime(new Date()); + enumElementDefList.add(enumElementDefObj); + + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(0); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName("authnType"); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + + Mockito.when(daoManager.getXXEnumElementDef()).thenReturn( + xEnumElementDefDao); + Mockito.when(xEnumElementDefDao.findByEnumDefId(enumDefObj.getId())) + .thenReturn(enumElementDefList); + + RangerEnumDef dbRangerEnumDef = rangerServiceDefService + .populateXXToRangerEnumDef(enumDefObj); + Assert.assertNotNull(dbRangerEnumDef); + Assert.assertEquals(dbRangerEnumDef.getName(), enumDefObj.getName()); + + Mockito.verify(daoManager).getXXEnumElementDef(); + } + + @Test + public void test19populateRangerEnumElementDefToXX() { + + RangerEnumElementDef rangerEnumElementDefObj = new RangerEnumElementDef(); + rangerEnumElementDefObj.setLabel("Simple"); + rangerEnumElementDefObj.setName("simple"); + rangerEnumElementDefObj.setRbKeyLabel(null); + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Simple"); + enumElementDefObj.setName("simple"); + enumElementDefObj.setOrder(0); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setUpdateTime(new Date()); + XXEnumDef enumDefObj = new XXEnumDef(); + enumDefObj.setAddedByUserId(Id); + enumDefObj.setCreateTime(new Date()); + enumDefObj.setDefaultindex(0); + enumDefObj.setDefid(Id); + enumDefObj.setId(Id); + enumDefObj.setName("authnType"); + enumDefObj.setUpdatedByUserId(Id); + enumDefObj.setUpdateTime(new Date()); + + Mockito.when( + (XXEnumElementDef) rangerAuditFields.populateAuditFields( + enumElementDefObj, enumDefObj)).thenReturn( + enumElementDefObj); + XXEnumElementDef dbEnumElementDef = rangerServiceDefService + .populateRangerEnumElementDefToXX(rangerEnumElementDefObj, + enumElementDefObj, enumDefObj, 1); + Assert.assertNotNull(dbEnumElementDef); + Assert.assertEquals(dbEnumElementDef.getId(), enumElementDefObj.getId()); + Assert.assertEquals(dbEnumElementDef.getName(), + enumElementDefObj.getName()); + Assert.assertEquals(dbEnumElementDef.getLabel(), + enumElementDefObj.getLabel()); + Assert.assertEquals(dbEnumElementDef.getCreateTime(), + enumElementDefObj.getCreateTime()); + Assert.assertEquals(dbEnumElementDef.getAddedByUserId(), + enumElementDefObj.getAddedByUserId()); + Assert.assertEquals(dbEnumElementDef.getUpdateTime(), + enumElementDefObj.getUpdateTime()); + Assert.assertEquals(dbEnumElementDef.getUpdatedByUserId(), + enumElementDefObj.getUpdatedByUserId()); + Mockito.verify(rangerAuditFields).populateAuditFields( + enumElementDefObj, enumDefObj); + } + + @Test + public void test20populateXXToRangerEnumElementDef() { + XXEnumElementDef enumElementDefObj = new XXEnumElementDef(); + enumElementDefObj.setAddedByUserId(Id); + enumElementDefObj.setCreateTime(new Date()); + enumElementDefObj.setEnumdefid(Id); + enumElementDefObj.setId(Id); + enumElementDefObj.setLabel("Simple"); + enumElementDefObj.setName("simple"); + enumElementDefObj.setOrder(0); + enumElementDefObj.setUpdatedByUserId(Id); + enumElementDefObj.setUpdateTime(new Date()); + + RangerEnumElementDef dbRangerEnumElementDef = rangerServiceDefService + .populateXXToRangerEnumElementDef(enumElementDefObj); + Assert.assertNotNull(dbRangerEnumElementDef); + Assert.assertEquals(dbRangerEnumElementDef.getLabel(), + enumElementDefObj.getLabel()); + Assert.assertEquals(dbRangerEnumElementDef.getName(), + enumElementDefObj.getName()); + + } + + @Test + public void test21searchRangerServiceDefs() { + 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); + + RangerServiceDefList dbRangerServiceDefList = rangerServiceDefService + .searchRangerServiceDefs(searchFilter); + Assert.assertNotNull(dbRangerServiceDefList); + Mockito.verify(daoManager).getDaoForClassName(Mockito.anyString()); + } +} http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceService.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceService.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceService.java new file mode 100644 index 0000000..7d0cf61 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceService.java @@ -0,0 +1,419 @@ +/* + * 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.XXPortalUserDao; +import org.apache.ranger.db.XXServiceConfigMapDao; +import org.apache.ranger.db.XXServiceDao; +import org.apache.ranger.db.XXServiceDefDao; + +import org.apache.ranger.entity.XXPortalUser; +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.RangerService; + +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 TestRangerServiceService { + + private static Long userId = 8L; + + @InjectMocks + RangerServiceService serviceService = new RangerServiceService(); + + @Mock + RangerDaoManager daoManager; + + @Mock + RangerServiceService svcService; + + @Mock + JSONUtil jsonUtil; + + @Mock + RangerServiceDefService serviceDefService; + + @Mock + RangerPolicyService policyService; + + @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 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(userId); + rangerService.setConfigs(configs); + rangerService.setCreateTime(new Date()); + rangerService.setDescription("service"); + rangerService.setGuid("serviceguid"); + rangerService.setIsEnabled(true); + rangerService.setName("Hdfs service"); + rangerService.setPolicyUpdateTime(new Date()); + rangerService.setPolicyVersion(1L); + rangerService.setType(null); + rangerService.setUpdatedBy("Admin"); + rangerService.setUpdateTime(new Date()); + rangerService.setVersion(userId); + + return rangerService; + } + + private XXService xService() { + XXService xService = new XXService(); + xService.setAddedByUserId(userId); + xService.setCreateTime(new Date()); + xService.setDescription("Hdfs service"); + xService.setGuid("serviceguid"); + xService.setId(userId); + xService.setIsEnabled(true); + xService.setName("Hdfs"); + xService.setPolicyUpdateTime(new Date()); + xService.setPolicyVersion(1L); + xService.setType(1L); + xService.setUpdatedByUserId(userId); + xService.setUpdateTime(new Date()); + xService.setVersion(1L); + + return xService; + } + + @Test + public void test1ValidateForCreate() { + RangerService service = rangerService(); + serviceService.validateForCreate(service); + Assert.assertNotNull(service); + } + + @Test + public void test2ValidateForUpdate() { + RangerService vService = rangerService(); + XXService xService = xService(); + + serviceService.validateForUpdate(vService, xService); + Assert.assertNotNull(vService); + } + + @Test + public void test3PopulateViewBean() { + XXServiceConfigMapDao xServiceConfigMapDao = Mockito + .mock(XXServiceConfigMapDao.class); + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + 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(userId); + tUser.setCreateTime(new Date()); + tUser.setEmailAddress("[email protected]"); + tUser.setFirstName(name); + tUser.setId(userId); + tUser.setLastName(name); + + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(userId); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("test"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(userId); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(userId)).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); + + RangerService dbService = serviceService.populateViewBean(xService); + + Assert.assertNotNull(dbService); + Assert.assertEquals(userId, dbService.getId()); + Assert.assertEquals(xService.getAddedByUserId(), dbService.getId()); + Assert.assertEquals(xService.getId(), dbService.getId()); + Assert.assertEquals(xService.getDescription(), + dbService.getDescription()); + Assert.assertEquals(xService.getGuid(), dbService.getGuid()); + Assert.assertEquals(xService.getName(), dbService.getName()); + Assert.assertEquals(xService.getPolicyUpdateTime(), + dbService.getPolicyUpdateTime()); + Assert.assertEquals(xService.getPolicyVersion(), + dbService.getPolicyVersion()); + Assert.assertEquals(xService.getVersion(), dbService.getVersion()); + + Mockito.verify(daoManager).getXXServiceDef(); + Mockito.verify(daoManager).getXXServiceConfigMap(); + } + + @Test + public void test4GetPopulatedViewObject() { + XXServiceConfigMapDao xServiceConfigMapDao = Mockito + .mock(XXServiceConfigMapDao.class); + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + 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(userId); + tUser.setCreateTime(new Date()); + tUser.setEmailAddress("[email protected]"); + tUser.setFirstName(name); + tUser.setId(userId); + tUser.setLastName(name); + + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(userId); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("test"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(userId); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(userId)).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); + + RangerService dbService = serviceService + .getPopulatedViewObject(xService); + + Assert.assertNotNull(dbService); + Assert.assertEquals(userId, dbService.getId()); + Assert.assertEquals(xService.getAddedByUserId(), dbService.getId()); + Assert.assertEquals(xService.getId(), dbService.getId()); + Assert.assertEquals(xService.getDescription(), + dbService.getDescription()); + Assert.assertEquals(xService.getGuid(), dbService.getGuid()); + Assert.assertEquals(xService.getName(), dbService.getName()); + Assert.assertEquals(xService.getPolicyUpdateTime(), + dbService.getPolicyUpdateTime()); + Assert.assertEquals(xService.getPolicyVersion(), + dbService.getPolicyVersion()); + Assert.assertEquals(xService.getVersion(), dbService.getVersion()); + + Mockito.verify(daoManager).getXXServiceDef(); + Mockito.verify(daoManager).getXXServiceConfigMap(); + } + + @Test + public void test5GetAllServices() { + XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class); + XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class); + XXServiceConfigMapDao xServiceConfigMapDao = Mockito + .mock(XXServiceConfigMapDao.class); + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + + 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); + + List<XXService> xServiceList = new ArrayList<XXService>(); + XXService xService = xService(); + xServiceList.add(xService); + + XXPortalUser tUser = new XXPortalUser(); + tUser.setAddedByUserId(userId); + tUser.setCreateTime(new Date()); + tUser.setEmailAddress("[email protected]"); + tUser.setFirstName(name); + tUser.setId(userId); + tUser.setLastName(name); + + XXServiceDef xServiceDef = new XXServiceDef(); + xServiceDef.setAddedByUserId(userId); + xServiceDef.setCreateTime(new Date()); + xServiceDef.setDescription("test"); + xServiceDef.setGuid("1427365526516_835_0"); + xServiceDef.setId(userId); + + Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao); + Mockito.when(xServiceDao.getAll()).thenReturn(xServiceList); + + Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao); + Mockito.when(xPortalUserDao.getById(userId)).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); + + List<RangerService> dbServiceList = serviceService.getAllServices(); + Assert.assertNotNull(dbServiceList); + + Mockito.verify(daoManager).getXXServiceDef(); + Mockito.verify(daoManager).getXXServiceConfigMap(); + } + + @Test + public void test6GetTransactionLogCreate() { + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class); + RangerService rangerService = rangerService(); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.findByName(rangerService.getType())) + .thenReturn(xServiceDef); + + String value = null; + Map<String, String> configs = new HashMap<String, String>(); + Mockito.when(jsonUtil.readMapToString(configs)).thenReturn(value); + + List<XXTrxLog> dbXXTrxLogList = serviceService.getTransactionLog( + rangerService, 1); + Assert.assertNotNull(dbXXTrxLogList); + } + + @Test + public void test7GetTransactionLogUpdate() { + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class); + RangerService rangerService = rangerService(); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.findByName(rangerService.getType())) + .thenReturn(xServiceDef); + + String value = null; + Map<String, String> configs = new HashMap<String, String>(); + Mockito.when(jsonUtil.readMapToString(configs)).thenReturn(value); + + List<XXTrxLog> dbXXTrxLogList = serviceService.getTransactionLog( + rangerService, 2); + Assert.assertNull(dbXXTrxLogList); + } + + @Test + public void test8GetTransactionLogDelete() { + XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class); + XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class); + RangerService rangerService = rangerService(); + + Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao); + Mockito.when(xServiceDefDao.findByName(rangerService.getType())) + .thenReturn(xServiceDef); + + String value = null; + Map<String, String> configs = new HashMap<String, String>(); + Mockito.when(jsonUtil.readMapToString(configs)).thenReturn(value); + + List<XXTrxLog> dbXXTrxLogList = serviceService.getTransactionLog( + rangerService, 3); + Assert.assertNotNull(dbXXTrxLogList); + } +}
