You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ranger.apache.org by ve...@apache.org on 2015/04/09 20:49:39 UTC
[1/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
Repository: incubator-ranger
Updated Branches:
refs/heads/master d673e5940 -> 376d32497
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceServiceBase.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceServiceBase.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceServiceBase.java
new file mode 100644
index 0000000..f359118
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerServiceServiceBase.java
@@ -0,0 +1,221 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ranger.service;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.common.ContextUtil;
+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.XXServiceDefDao;
+import org.apache.ranger.entity.XXService;
+import org.apache.ranger.entity.XXServiceDef;
+import org.apache.ranger.plugin.model.RangerService;
+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.RangerServiceList;
+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 TestRangerServiceServiceBase {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ RangerServiceService rangerServiceService = new RangerServiceService();
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ RangerSearchUtil searchUtil;
+
+ @Mock
+ RangerBizUtil bizUtil;
+
+ @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(Id);
+ 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(Id);
+
+ return rangerService;
+ }
+
+ private XXService service() {
+ XXService xService = new XXService();
+ xService.setAddedByUserId(Id);
+ xService.setCreateTime(new Date());
+ xService.setDescription("Hdfs service");
+ xService.setGuid("serviceguid");
+ xService.setId(Id);
+ xService.setIsEnabled(true);
+ xService.setName("Hdfs");
+ xService.setPolicyUpdateTime(new Date());
+ xService.setPolicyVersion(1L);
+ xService.setType(1L);
+ xService.setUpdatedByUserId(Id);
+ xService.setUpdateTime(new Date());
+ xService.setVersion(1L);
+
+ return xService;
+ }
+
+ @Test
+ public void test1MapViewToEntityBean() {
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+ RangerService rangerService = rangerService();
+ XXService service = service();
+ int OPERATION_CONTEXT = 1;
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(rangerService.getType()))
+ .thenReturn(xServiceDef);
+
+ XXService dbService = rangerServiceService.mapViewToEntityBean(
+ rangerService, service, OPERATION_CONTEXT);
+ Assert.assertNotNull(dbService);
+ Assert.assertEquals(dbService, service);
+ Assert.assertEquals(dbService.getDescription(),
+ service.getDescription());
+ Assert.assertEquals(dbService.getGuid(), service.getGuid());
+ Assert.assertEquals(dbService.getName(), service.getName());
+ Assert.assertEquals(dbService.getAddedByUserId(),
+ service.getAddedByUserId());
+ Assert.assertEquals(dbService.getId(), service.getId());
+ Assert.assertEquals(dbService.getVersion(), service.getVersion());
+ Assert.assertEquals(dbService.getType(), service.getType());
+ Assert.assertEquals(dbService.getUpdatedByUserId(),
+ service.getUpdatedByUserId());
+
+ Mockito.verify(daoManager).getXXServiceDef();
+ }
+
+ @Test
+ public void test2mapEntityToViewBean() {
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+ RangerService rangerService = rangerService();
+ XXService service = service();
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(service.getType())).thenReturn(
+ xServiceDef);
+
+ RangerService dbRangerService = rangerServiceService
+ .mapEntityToViewBean(rangerService, service);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getDescription(),
+ rangerService.getDescription());
+ Assert.assertEquals(dbRangerService.getGuid(), rangerService.getGuid());
+ Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assert.assertEquals(dbRangerService.getVersion(),
+ rangerService.getVersion());
+ Assert.assertEquals(dbRangerService.getType(), rangerService.getType());
+
+ Mockito.verify(daoManager).getXXServiceDef();
+ }
+
+ @Test
+ public void test3searchRangerServices() {
+ 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);
+ Mockito.when(bizUtil.getClassType(getClass())).thenReturn(1);
+ RangerServiceList dbRangerServiceList = rangerServiceService
+ .searchRangerServices(searchFilter);
+ Assert.assertNotNull(dbRangerServiceList);
+ Mockito.verify(daoManager).getDaoForClassName(Mockito.anyString());
+
+ }
+}
[3/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
Posted by ve...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
new file mode 100644
index 0000000..b523552
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestServiceREST.java
@@ -0,0 +1,872 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ranger.rest;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+import org.apache.commons.lang.StringUtils;
+import org.apache.ranger.admin.client.datatype.RESTResponse;
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.biz.ServiceDBStore;
+import org.apache.ranger.biz.ServiceMgr;
+import org.apache.ranger.biz.XUserMgr;
+import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerSearchUtil;
+import org.apache.ranger.common.ServiceUtil;
+import org.apache.ranger.common.StringUtil;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.entity.XXDBBase;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerService;
+import org.apache.ranger.plugin.model.RangerServiceDef;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerAccessTypeDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerContextEnricherDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerEnumDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerPolicyConditionDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerResourceDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerServiceConfigDef;
+import org.apache.ranger.plugin.model.validation.RangerPolicyValidator;
+import org.apache.ranger.plugin.model.validation.RangerServiceDefValidator;
+import org.apache.ranger.plugin.model.validation.RangerServiceValidator;
+import org.apache.ranger.plugin.model.validation.RangerValidatorFactory;
+import org.apache.ranger.plugin.service.ResourceLookupContext;
+import org.apache.ranger.plugin.util.GrantRevokeRequest;
+import org.apache.ranger.plugin.util.SearchFilter;
+import org.apache.ranger.plugin.util.ServicePolicies;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.service.RangerAuditFields;
+import org.apache.ranger.service.RangerDataHistService;
+import org.apache.ranger.service.RangerPolicyService;
+import org.apache.ranger.service.RangerServiceDefService;
+import org.apache.ranger.service.RangerServiceService;
+import org.apache.ranger.service.XUserService;
+import org.apache.ranger.view.RangerPolicyList;
+import org.apache.ranger.view.RangerServiceDefList;
+import org.apache.ranger.view.RangerServiceList;
+import org.apache.ranger.view.VXResponse;
+import org.apache.ranger.view.VXString;
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestServiceREST {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ ServiceREST serviceREST = new ServiceREST();
+
+ @Mock
+ RangerValidatorFactory validatorFactory;
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ ServiceDBStore svcStore;
+
+ @Mock
+ RangerServiceService svcService;
+
+ @Mock
+ RangerDataHistService dataHistService;
+
+ @Mock
+ RangerServiceDefService serviceDefService;
+
+ @Mock
+ RangerPolicyService policyService;
+
+ @Mock
+ StringUtil stringUtil;
+
+ @Mock
+ XUserService xUserService;
+
+ @Mock
+ XUserMgr xUserMgr;
+
+ @Mock
+ RangerAuditFields<XXDBBase> rangerAuditFields;
+
+ @Mock
+ ContextUtil contextUtil;
+
+ @Mock
+ RangerBizUtil bizUtil;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ RangerServiceDefValidator serviceDefValidator;
+
+ @Mock
+ RangerServiceValidator serviceValidator;
+
+ @Mock
+ RangerPolicyValidator policyValidator;
+
+ @Mock
+ ServiceMgr serviceMgr;
+
+ @Mock
+ VXResponse vXResponse;
+
+ @Mock
+ ServiceUtil serviceUtil;
+
+ @Mock
+ RangerSearchUtil searchUtil;
+
+ @Mock
+ StringUtils stringUtils;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ public void setup() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerServiceDef rangerServiceDef() {
+ List<RangerServiceConfigDef> configs = new ArrayList<RangerServiceConfigDef>();
+ List<RangerResourceDef> resources = new ArrayList<RangerResourceDef>();
+ List<RangerAccessTypeDef> accessTypes = new ArrayList<RangerAccessTypeDef>();
+ List<RangerPolicyConditionDef> policyConditions = new ArrayList<RangerPolicyConditionDef>();
+ List<RangerContextEnricherDef> contextEnrichers = new ArrayList<RangerContextEnricherDef>();
+ List<RangerEnumDef> enums = new ArrayList<RangerEnumDef>();
+
+ RangerServiceDef rangerServiceDef = new RangerServiceDef();
+ rangerServiceDef.setId(Id);
+ rangerServiceDef.setImplClass("RangerServiceHdfs");
+ rangerServiceDef.setLabel("HDFS Repository");
+ rangerServiceDef.setDescription("HDFS Repository");
+ rangerServiceDef.setRbKeyDescription(null);
+ rangerServiceDef.setUpdatedBy("Admin");
+ rangerServiceDef.setUpdateTime(new Date());
+ rangerServiceDef.setConfigs(configs);
+ rangerServiceDef.setResources(resources);
+ rangerServiceDef.setAccessTypes(accessTypes);
+ rangerServiceDef.setPolicyConditions(policyConditions);
+ rangerServiceDef.setContextEnrichers(contextEnrichers);
+ rangerServiceDef.setEnums(enums);
+
+ return rangerServiceDef;
+ }
+
+ private RangerService rangerService() {
+ Map<String, String> configs = new HashMap<String, String>();
+ configs.put("username", "servicemgr");
+ configs.put("password", "servicemgr");
+ configs.put("namenode", "servicemgr");
+ configs.put("hadoop.security.authorization", "No");
+ configs.put("hadoop.security.authentication", "Simple");
+ configs.put("hadoop.security.auth_to_local", "");
+ configs.put("dfs.datanode.kerberos.principal", "");
+ configs.put("dfs.namenode.kerberos.principal", "");
+ configs.put("dfs.secondary.namenode.kerberos.principal", "");
+ configs.put("hadoop.rpc.protection", "Privacy");
+ configs.put("commonNameForCertificate", "");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(Id);
+ rangerService.setConfigs(configs);
+ rangerService.setCreateTime(new Date());
+ rangerService.setDescription("service policy");
+ rangerService.setGuid("1427365526516_835_0");
+ rangerService.setIsEnabled(true);
+ rangerService.setName("HDFS_1");
+ rangerService.setPolicyUpdateTime(new Date());
+ rangerService.setType("1");
+ rangerService.setUpdatedBy("Admin");
+ rangerService.setUpdateTime(new Date());
+
+ return rangerService;
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+
+ return policy;
+ }
+
+ @Test
+ public void test1createServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+
+ Mockito.when(
+ svcStore.createServiceDef((RangerServiceDef) Mockito
+ .anyObject())).thenReturn(rangerServiceDef);
+
+ RangerServiceDef dbRangerServiceDef = serviceREST
+ .createServiceDef(rangerServiceDef);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Assert.assertEquals(dbRangerServiceDef.getImplClass(),
+ rangerServiceDef.getImplClass());
+ Assert.assertEquals(dbRangerServiceDef.getLabel(),
+ rangerServiceDef.getLabel());
+ Assert.assertEquals(dbRangerServiceDef.getDescription(),
+ rangerServiceDef.getDescription());
+ Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(),
+ rangerServiceDef.getRbKeyDescription());
+ Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(),
+ rangerServiceDef.getUpdatedBy());
+ Assert.assertEquals(dbRangerServiceDef.getUpdateTime(),
+ rangerServiceDef.getUpdateTime());
+ Assert.assertEquals(dbRangerServiceDef.getVersion(),
+ rangerServiceDef.getVersion());
+ Assert.assertEquals(dbRangerServiceDef.getConfigs(),
+ rangerServiceDef.getConfigs());
+
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ Mockito.verify(svcStore).createServiceDef(rangerServiceDef);
+ }
+
+ @Test
+ public void test2updateServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+
+ Mockito.when(
+ svcStore.updateServiceDef((RangerServiceDef) Mockito
+ .anyObject())).thenReturn(rangerServiceDef);
+
+ RangerServiceDef dbRangerServiceDef = serviceREST
+ .updateServiceDef(rangerServiceDef);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Assert.assertEquals(dbRangerServiceDef.getImplClass(),
+ rangerServiceDef.getImplClass());
+ Assert.assertEquals(dbRangerServiceDef.getLabel(),
+ rangerServiceDef.getLabel());
+ Assert.assertEquals(dbRangerServiceDef.getDescription(),
+ rangerServiceDef.getDescription());
+ Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(),
+ rangerServiceDef.getRbKeyDescription());
+ Assert.assertEquals(dbRangerServiceDef.getUpdatedBy(),
+ rangerServiceDef.getUpdatedBy());
+ Assert.assertEquals(dbRangerServiceDef.getUpdateTime(),
+ rangerServiceDef.getUpdateTime());
+ Assert.assertEquals(dbRangerServiceDef.getVersion(),
+ rangerServiceDef.getVersion());
+ Assert.assertEquals(dbRangerServiceDef.getConfigs(),
+ rangerServiceDef.getConfigs());
+
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ Mockito.verify(svcStore).updateServiceDef(rangerServiceDef);
+ }
+
+ @Test
+ public void test3deleteServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+ serviceREST.deleteServiceDef(rangerServiceDef.getId());
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ }
+
+ @Test
+ public void test4getServiceDefById() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(svcStore.getServiceDef(rangerServiceDef.getId()))
+ .thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = serviceREST
+ .getServiceDef(rangerServiceDef.getId());
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Mockito.verify(svcStore).getServiceDef(rangerServiceDef.getId());
+ }
+
+ @Test
+ public void test5getServiceDefByName() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(svcStore.getServiceDefByName(rangerServiceDef.getName()))
+ .thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = serviceREST
+ .getServiceDefByName(rangerServiceDef.getName());
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(svcStore)
+ .getServiceDefByName(rangerServiceDef.getName());
+ }
+
+ @Test
+ public void test6getServiceDefs() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ RangerServiceDefList dbRangerServiceDef = serviceREST
+ .getServiceDefs(request);
+ Assert.assertNull(dbRangerServiceDef);
+ }
+
+ @Test
+ public void test7createService() throws Exception {
+
+ RangerService rangerService = rangerService();
+ Mockito.when(validatorFactory.getServiceValidator(svcStore))
+ .thenReturn(serviceValidator);
+ Mockito.when(
+ svcStore.createService((RangerService) Mockito.anyObject()))
+ .thenReturn(rangerService);
+
+ RangerService dbRangerService = serviceREST
+ .createService(rangerService);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(rangerService, dbRangerService);
+ Assert.assertEquals(rangerService.getId(), dbRangerService.getId());
+ Assert.assertEquals(rangerService.getConfigs(),
+ dbRangerService.getConfigs());
+ Assert.assertEquals(rangerService.getDescription(),
+ dbRangerService.getDescription());
+ Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
+ Assert.assertEquals(rangerService.getName(), dbRangerService.getName());
+ Assert.assertEquals(rangerService.getPolicyVersion(),
+ dbRangerService.getPolicyVersion());
+ Assert.assertEquals(rangerService.getType(), dbRangerService.getType());
+ Assert.assertEquals(rangerService.getVersion(),
+ dbRangerService.getVersion());
+ Assert.assertEquals(rangerService.getCreateTime(),
+ dbRangerService.getCreateTime());
+ Assert.assertEquals(rangerService.getUpdateTime(),
+ dbRangerService.getUpdateTime());
+ Assert.assertEquals(rangerService.getUpdatedBy(),
+ dbRangerService.getUpdatedBy());
+
+ Mockito.verify(validatorFactory).getServiceValidator(svcStore);
+ Mockito.verify(svcStore).createService(rangerService);
+ }
+
+ @Test
+ public void test8updateServiceDef() throws Exception {
+
+ RangerService rangerService = rangerService();
+ Mockito.when(validatorFactory.getServiceValidator(svcStore))
+ .thenReturn(serviceValidator);
+
+ Mockito.when(
+ svcStore.updateService((RangerService) Mockito.anyObject()))
+ .thenReturn(rangerService);
+
+ RangerService dbRangerService = serviceREST
+ .updateService(rangerService);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(rangerService, dbRangerService);
+ Assert.assertEquals(rangerService.getId(), dbRangerService.getId());
+ Assert.assertEquals(rangerService.getConfigs(),
+ dbRangerService.getConfigs());
+ Assert.assertEquals(rangerService.getDescription(),
+ dbRangerService.getDescription());
+ Assert.assertEquals(rangerService.getGuid(), dbRangerService.getGuid());
+ Assert.assertEquals(rangerService.getName(), dbRangerService.getName());
+ Assert.assertEquals(rangerService.getPolicyVersion(),
+ dbRangerService.getPolicyVersion());
+ Assert.assertEquals(rangerService.getType(), dbRangerService.getType());
+ Assert.assertEquals(rangerService.getVersion(),
+ dbRangerService.getVersion());
+ Assert.assertEquals(rangerService.getCreateTime(),
+ dbRangerService.getCreateTime());
+ Assert.assertEquals(rangerService.getUpdateTime(),
+ dbRangerService.getUpdateTime());
+ Assert.assertEquals(rangerService.getUpdatedBy(),
+ dbRangerService.getUpdatedBy());
+ Mockito.verify(validatorFactory).getServiceValidator(svcStore);
+ Mockito.verify(svcStore).updateService(rangerService);
+ }
+
+ @Test
+ public void test9deleteService() throws Exception {
+
+ RangerService rangerService = rangerService();
+ Mockito.when(validatorFactory.getServiceValidator(svcStore))
+ .thenReturn(serviceValidator);
+ serviceREST.deleteService(rangerService.getId());
+
+ Mockito.verify(validatorFactory).getServiceValidator(svcStore);
+ }
+
+ @Test
+ public void test10getServiceById() throws Exception {
+ RangerService rangerService = rangerService();
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+ serviceREST.deleteServiceDef(rangerServiceDef.getId());
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ Mockito.when(svcStore.getService(rangerService.getId())).thenReturn(
+ rangerService);
+ RangerService dbRangerService = serviceREST.getService(rangerService
+ .getId());
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService.getId(), dbRangerService.getId());
+ Mockito.verify(svcStore).getService(dbRangerService.getId());
+ }
+
+ @Test
+ public void test11getServiceByName() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(svcStore.getServiceByName(rangerService.getName()))
+ .thenReturn(rangerService);
+ RangerService dbRangerService = serviceREST
+ .getServiceByName(rangerService.getName());
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService.getName(),
+ dbRangerService.getName());
+ Mockito.verify(svcStore).getServiceByName(dbRangerService.getName());
+ }
+
+ @Test
+ public void test12deleteServiceDef() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(serviceMgr.validateConfig(rangerService, svcStore))
+ .thenReturn(vXResponse);
+ VXResponse dbVXResponse = serviceREST.validateConfig(rangerService);
+ Assert.assertNotNull(dbVXResponse);
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+ serviceREST.deleteServiceDef(rangerServiceDef.getId());
+ Mockito.verify(validatorFactory).getServiceDefValidator(svcStore);
+ Mockito.verify(serviceMgr).validateConfig(rangerService, svcStore);
+ }
+
+ @Test
+ public void test13lookupResource() throws Exception {
+ String serviceName = "HDFS_1";
+ ResourceLookupContext context = new ResourceLookupContext();
+ context.setResourceName(serviceName);
+ context.setUserInput("HDFS");
+ List<String> list = serviceREST.lookupResource(serviceName, context);
+ Assert.assertNotNull(list);
+ }
+
+ @Test
+ public void test14grantAccess() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "HDFS_1";
+ GrantRevokeRequest grantRequestObj = new GrantRevokeRequest();
+ grantRequestObj.setAccessTypes(null);
+ grantRequestObj.setDelegateAdmin(true);
+ grantRequestObj.setEnableAudit(true);
+ grantRequestObj.setGrantor("read");
+ grantRequestObj.setIsRecursive(true);
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+ Mockito.when(
+ serviceUtil.isValidateHttpsAuthentication(serviceName, request))
+ .thenReturn(false);
+ RESTResponse restResponse = serviceREST.grantAccess(serviceName,
+ grantRequestObj, request);
+ Assert.assertNotNull(restResponse);
+ Mockito.verify(serviceUtil).isValidateHttpsAuthentication(serviceName,
+ request);
+ }
+
+ @Test
+ public void test15revokeAccess() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "HDFS_1";
+ Set<String> userList = new HashSet<String>();
+ userList.add("user1");
+ userList.add("user2");
+ userList.add("user3");
+ Set<String> groupList = new HashSet<String>();
+ groupList.add("group1");
+ groupList.add("group2");
+ groupList.add("group3");
+ GrantRevokeRequest revokeRequest = new GrantRevokeRequest();
+ revokeRequest.setDelegateAdmin(true);
+ revokeRequest.setEnableAudit(true);
+ revokeRequest.setGrantor("read");
+ revokeRequest.setGroups(groupList);
+ revokeRequest.setUsers(userList);
+
+ Mockito.when(validatorFactory.getServiceDefValidator(svcStore))
+ .thenReturn(serviceDefValidator);
+
+ RESTResponse restResponse = serviceREST.revokeAccess(serviceName,
+ revokeRequest, request);
+ Assert.assertNotNull(restResponse);
+
+ }
+
+ @Test
+ public void test16createPolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(svcStore.createPolicy(rangerPolicy)).thenReturn(
+ rangerPolicy);
+
+ RangerPolicy dbRangerPolicy = serviceREST.createPolicy(rangerPolicy);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ rangerPolicy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assert.assertEquals(dbRangerPolicy.getVersion(),
+ rangerPolicy.getVersion());
+ Assert.assertEquals(dbRangerPolicy.getCreateTime(),
+ rangerPolicy.getCreateTime());
+ Assert.assertEquals(dbRangerPolicy.getUpdateTime(),
+ rangerPolicy.getUpdateTime());
+ Assert.assertEquals(dbRangerPolicy.getUpdatedBy(),
+ rangerPolicy.getUpdatedBy());
+ Assert.assertEquals(dbRangerPolicy.getService(),
+ rangerPolicy.getService());
+ Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(),
+ rangerPolicy.getIsAuditEnabled());
+ Assert.assertEquals(dbRangerPolicy.getPolicyItems(),
+ rangerPolicy.getPolicyItems());
+ Assert.assertEquals(dbRangerPolicy.getResources(),
+ rangerPolicy.getResources());
+ Mockito.verify(svcStore).createPolicy(rangerPolicy);
+ }
+
+ @Test
+ public void test17updatePolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(svcStore.updatePolicy(rangerPolicy)).thenReturn(
+ rangerPolicy);
+ RangerPolicy dbRangerPolicy = serviceREST.updatePolicy(rangerPolicy);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ rangerPolicy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assert.assertEquals(dbRangerPolicy.getVersion(),
+ rangerPolicy.getVersion());
+ Assert.assertEquals(dbRangerPolicy.getCreateTime(),
+ rangerPolicy.getCreateTime());
+ Assert.assertEquals(dbRangerPolicy.getUpdateTime(),
+ rangerPolicy.getUpdateTime());
+ Assert.assertEquals(dbRangerPolicy.getUpdatedBy(),
+ rangerPolicy.getUpdatedBy());
+ Assert.assertEquals(dbRangerPolicy.getService(),
+ rangerPolicy.getService());
+ Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(),
+ rangerPolicy.getIsAuditEnabled());
+ Assert.assertEquals(dbRangerPolicy.getPolicyItems(),
+ rangerPolicy.getPolicyItems());
+ Assert.assertEquals(dbRangerPolicy.getResources(),
+ rangerPolicy.getResources());
+ Mockito.verify(svcStore).updatePolicy(rangerPolicy);
+ }
+
+ @Test
+ public void test18deletePolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+
+ Mockito.when(validatorFactory.getPolicyValidator(svcStore)).thenReturn(
+ policyValidator);
+ serviceREST.deletePolicy(rangerPolicy.getId());
+ Mockito.verify(validatorFactory).getPolicyValidator(svcStore);
+ }
+
+ @Test
+ public void test19getPolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(svcStore.getPolicy(rangerPolicy.getId())).thenReturn(
+ rangerPolicy);
+ RangerPolicy dbRangerPolicy = serviceREST.getPolicy(rangerPolicy
+ .getId());
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Mockito.verify(svcStore).getPolicy(rangerPolicy.getId());
+ }
+
+ @Test
+ public void test20getPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ searchUtil.getSearchFilter(request, policyService.sortFields))
+ .thenReturn(filter);
+ RangerPolicyList dbRangerPolicy = serviceREST.getPolicies(request);
+ Assert.assertNull(dbRangerPolicy);
+ Mockito.verify(searchUtil).getSearchFilter(request,
+ policyService.sortFields);
+ }
+
+ @Test
+ public void test21countPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicyList ret = Mockito.mock(RangerPolicyList.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ searchUtil.getSearchFilter(request, policyService.sortFields))
+ .thenReturn(filter);
+
+ Mockito.when(
+ svcStore.getPaginatedPolicies(filter))
+ .thenReturn(ret);
+
+ Long data = serviceREST.countPolicies(request);
+ Assert.assertNotNull(data);
+ Mockito.verify(searchUtil).getSearchFilter(request,
+ policyService.sortFields);
+ Mockito.verify(svcStore).getPaginatedPolicies(filter);
+ }
+
+
+
+ @Test
+ public void test22getServicePoliciesById() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+
+ RangerPolicyList ret = Mockito.mock(RangerPolicyList.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ searchUtil.getSearchFilter(request, policyService.sortFields))
+ .thenReturn(filter);
+
+ Mockito.when(
+ svcStore.getPaginatedServicePolicies(Id,filter))
+ .thenReturn(ret);
+
+
+ RangerPolicyList dbRangerPolicy = serviceREST.getServicePolicies(
+ rangerPolicy.getId(), request);
+ Assert.assertNotNull(dbRangerPolicy);
+ Mockito.verify(searchUtil).getSearchFilter(request,
+ policyService.sortFields);
+ Mockito.verify(svcStore).getPaginatedServicePolicies(Id,filter);
+ }
+
+ @Test
+ public void test23getServicePoliciesByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ RangerPolicyList ret = Mockito.mock(RangerPolicyList.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ searchUtil.getSearchFilter(request, policyService.sortFields))
+ .thenReturn(filter);
+
+
+ Mockito.when(
+ svcStore.getPaginatedServicePolicies(rangerPolicy.getName(),filter))
+ .thenReturn(ret);
+
+ RangerPolicyList dbRangerPolicy = serviceREST.getServicePolicies(
+ rangerPolicy.getName(), request);
+ Assert.assertNotNull(dbRangerPolicy);
+ }
+
+ @Test
+ public void test24getServicePoliciesIfUpdated() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String serviceName = "HDFS_1";
+ Long lastKnownVersion = 1L;
+ String pluginId = "1";
+ ServicePolicies dbServicePolicies = serviceREST
+ .getServicePoliciesIfUpdated(serviceName, lastKnownVersion,
+ pluginId, request);
+ Assert.assertNull(dbServicePolicies);
+ }
+
+ @Test
+ public void test25getPolicies() throws Exception {
+ List<RangerPolicy> ret = new ArrayList<RangerPolicy>();
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ svcStore.getPolicies(filter))
+ .thenReturn(ret);
+
+
+ List<RangerPolicy> dbRangerPolicyList = serviceREST.getPolicies(filter);
+ Assert.assertNotNull(dbRangerPolicyList);
+ Mockito.verify(svcStore).getPolicies(filter);
+
+ }
+
+ @Test
+ public void test26getServices() throws Exception {
+ List<RangerService> ret = new ArrayList<RangerService>();
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ svcStore.getServices(filter))
+ .thenReturn(ret);
+
+ List<RangerService> dbRangerService = serviceREST.getServices(filter);
+ Assert.assertNotNull(dbRangerService);
+ Mockito.verify(svcStore).getServices(filter);
+ }
+
+ @Test
+ public void test30getPolicyFromEventTime() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ Mockito.when(request.getParameter("eventTime")).thenReturn(
+ new Date().toString());
+ Mockito.when(request.getParameter("policyId")).thenReturn("1");
+
+ RangerPolicy dbRangerPolicy = serviceREST
+ .getPolicyFromEventTime(request);
+ Assert.assertNull(dbRangerPolicy);
+ Mockito.verify(request).getParameter("eventTime");
+ Mockito.verify(request).getParameter("policyId");
+ }
+
+ @Test
+ public void test31getServices() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ RangerServiceList dbRangerService = serviceREST.getServices(request);
+ Assert.assertNull(dbRangerService);
+ }
+
+ @Test
+ public void test32getPolicyVersionList() throws Exception {
+ VXString vXString = new VXString();
+ vXString.setValue("1");
+ Mockito.when(svcStore.getPolicyVersionList(Id)).thenReturn(vXString);
+
+ VXString dbVXString = serviceREST.getPolicyVersionList(Id);
+ Assert.assertNotNull(dbVXString);
+ Mockito.verify(svcStore).getPolicyVersionList(Id);
+ }
+
+ @Test
+ public void test33getPolicyForVersionNumber() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(svcStore.getPolicyForVersionNumber(Id,1)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = serviceREST.getPolicyForVersionNumber(Id, 1);
+ Assert.assertNotNull(dbRangerPolicy);
+ Mockito.verify(svcStore).getPolicyForVersionNumber(Id,1);
+ }
+
+ @Test
+ public void test34countServices() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceList ret = Mockito.mock(RangerServiceList.class);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(
+ searchUtil.getSearchFilter(request, policyService.sortFields))
+ .thenReturn(filter);
+
+ Mockito.when(
+ svcStore.getPaginatedServices(filter))
+ .thenReturn(ret);
+ Long data = serviceREST.countServices(request);
+ Assert.assertNotNull(data);
+ Mockito.verify(searchUtil).getSearchFilter(request, policyService.sortFields);
+ Mockito.verify(svcStore).getPaginatedServices(filter);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java
new file mode 100644
index 0000000..bac5261
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyService.java
@@ -0,0 +1,1007 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ranger.service;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.JSONUtil;
+import org.apache.ranger.common.StringUtil;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXAccessTypeDefDao;
+import org.apache.ranger.db.XXGroupDao;
+import org.apache.ranger.db.XXPolicyConditionDefDao;
+import org.apache.ranger.db.XXPolicyItemAccessDao;
+import org.apache.ranger.db.XXPolicyItemConditionDao;
+import org.apache.ranger.db.XXPolicyItemDao;
+import org.apache.ranger.db.XXPolicyResourceDao;
+import org.apache.ranger.db.XXPolicyResourceMapDao;
+import org.apache.ranger.db.XXPortalUserDao;
+import org.apache.ranger.db.XXResourceDefDao;
+import org.apache.ranger.db.XXServiceConfigMapDao;
+import org.apache.ranger.db.XXServiceDao;
+import org.apache.ranger.db.XXServiceDefDao;
+import org.apache.ranger.db.XXUserDao;
+import org.apache.ranger.entity.XXAccessTypeDef;
+import org.apache.ranger.entity.XXPolicy;
+import org.apache.ranger.entity.XXPolicyConditionDef;
+import org.apache.ranger.entity.XXPolicyItem;
+import org.apache.ranger.entity.XXPolicyItemAccess;
+import org.apache.ranger.entity.XXPolicyItemCondition;
+import org.apache.ranger.entity.XXPolicyResource;
+import org.apache.ranger.entity.XXPolicyResourceMap;
+import org.apache.ranger.entity.XXPortalUser;
+import org.apache.ranger.entity.XXResourceDef;
+import org.apache.ranger.entity.XXService;
+import org.apache.ranger.entity.XXServiceConfigMap;
+import org.apache.ranger.entity.XXServiceDef;
+import org.apache.ranger.entity.XXTrxLog;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestRangerPolicyService {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ RangerPolicyService policyService = new RangerPolicyService();
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ RangerServiceService svcService;
+
+ @Mock
+ JSONUtil jsonUtil;
+
+ @Mock
+ RangerServiceDefService serviceDefService;
+
+ @Mock
+ StringUtil stringUtil;
+
+ @Mock
+ XUserService xUserService;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ public void setup() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+
+ return policy;
+ }
+
+ private XXPolicy policy() {
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(Id);
+ xxPolicy.setName("HDFS_1-1-20150316062453");
+ xxPolicy.setAddedByUserId(Id);
+ xxPolicy.setCreateTime(new Date());
+ xxPolicy.setDescription("test");
+ xxPolicy.setIsAuditEnabled(false);
+ xxPolicy.setIsEnabled(false);
+ xxPolicy.setService(1L);
+ xxPolicy.setUpdatedByUserId(Id);
+ xxPolicy.setUpdateTime(new Date());
+ return xxPolicy;
+ }
+
+ private XXService xService() {
+ XXService xService = new XXService();
+ xService.setAddedByUserId(Id);
+ xService.setCreateTime(new Date());
+ xService.setDescription("Hdfs service");
+ xService.setGuid("serviceguid");
+ xService.setId(Id);
+ xService.setIsEnabled(true);
+ xService.setName("Hdfs");
+ xService.setPolicyUpdateTime(new Date());
+ xService.setPolicyVersion(1L);
+ xService.setType(1L);
+ xService.setUpdatedByUserId(Id);
+ xService.setUpdateTime(new Date());
+ xService.setVersion(1L);
+
+ return xService;
+ }
+
+ @Test
+ public void test1ValidateForCreate() {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ policyService.validateForCreate(rangerPolicy);
+ Assert.assertNotNull(rangerPolicy);
+ }
+
+ @Test
+ public void test2ValidateForUpdate() {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ XXPolicy policy = policy();
+ policyService.validateForUpdate(rangerPolicy, policy);
+
+ Assert.assertNotNull(rangerPolicy);
+ }
+
+ @Test
+ public void test3PopulateViewBean() {
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXAccessTypeDefDao xAccessTypeDefDao = Mockito
+ .mock(XXAccessTypeDefDao.class);
+ XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class);
+ XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito
+ .mock(XXPolicyConditionDefDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class);
+
+ XXPolicy policy = policy();
+
+ XXService xService = xService();
+ String name = "fdfdfds";
+
+ List<XXServiceConfigMap> svcConfigMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ svcConfigMapList.add(xConfMap);
+
+ XXPortalUser tUser = new XXPortalUser();
+ tUser.setAddedByUserId(Id);
+ tUser.setCreateTime(new Date());
+ tUser.setEmailAddress("test@gmail.com");
+ tUser.setFirstName(name);
+ tUser.setId(Id);
+ tUser.setLastName(name);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setAddedByUserId(Id);
+ xServiceDef.setCreateTime(new Date());
+ xServiceDef.setDescription("test");
+ xServiceDef.setGuid("1427365526516_835_0");
+ xServiceDef.setId(Id);
+
+ List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>();
+ XXResourceDef resourceDef = new XXResourceDef();
+ resourceDef.setAddedByUserId(Id);
+ resourceDef.setCreateTime(new Date());
+ resourceDef.setDefid(Id);
+ resourceDef.setDescription("test");
+ resourceDef.setId(Id);
+ resDefList.add(resourceDef);
+
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem xPolicyItem = new XXPolicyItem();
+ xPolicyItem.setDelegateAdmin(false);
+ xPolicyItem.setAddedByUserId(null);
+ xPolicyItem.setCreateTime(new Date());
+ xPolicyItem.setGUID(null);
+ xPolicyItem.setId(Id);
+ xPolicyItem.setOrder(null);
+ xPolicyItem.setPolicyId(Id);
+ xPolicyItem.setUpdatedByUserId(null);
+ xPolicyItem.setUpdateTime(new Date());
+ xPolicyItemList.add(xPolicyItem);
+
+ List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>();
+ XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess();
+ policyItemAccess.setAddedByUserId(Id);
+ policyItemAccess.setCreateTime(new Date());
+ policyItemAccess.setPolicyitemid(Id);
+ policyItemAccess.setId(Id);
+ policyItemAccess.setOrder(1);
+ policyItemAccess.setUpdatedByUserId(Id);
+ policyItemAccess.setUpdateTime(new Date());
+ policyItemAccessList.add(policyItemAccess);
+
+ List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>();
+ XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef();
+ policyConditionDefObj.setAddedByUserId(Id);
+ policyConditionDefObj.setCreateTime(new Date());
+ policyConditionDefObj.setDefid(Id);
+ policyConditionDefObj.setDescription("policy conditio");
+ policyConditionDefObj.setId(Id);
+ policyConditionDefObj.setName(name);
+ policyConditionDefObj.setOrder(1);
+ policyConditionDefObj.setLabel("label");
+ xConditionDefList.add(policyConditionDefObj);
+
+ List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>();
+ XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition();
+ policyItemCondition.setAddedByUserId(Id);
+ policyItemCondition.setCreateTime(new Date());
+ policyItemCondition.setType(1L);
+ policyItemCondition.setId(Id);
+ policyItemCondition.setOrder(1);
+ policyItemCondition.setPolicyItemId(Id);
+ policyItemCondition.setUpdatedByUserId(Id);
+ policyItemCondition.setUpdateTime(new Date());
+ policyItemConditionList.add(policyItemCondition);
+
+ List<String> usersList = new ArrayList<String>();
+ List<String> groupsList = new ArrayList<String>();
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(
+ xServiceDef);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(xServiceConfigMapDao.findByServiceId(xService.getId()))
+ .thenReturn(svcConfigMapList);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(policy.getService())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao);
+ Mockito.when(xResourceDefDao.findByPolicyId(policy.getId()))
+ .thenReturn(resDefList);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(
+ xPolicyResourceDao.findByResDefIdAndPolicyId(
+ resourceDef.getId(), policy.getId())).thenReturn(
+ policyResource);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResource.getId()))
+ .thenReturn(policyResourceMapList);
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn(
+ xPolicyItemList);
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(
+ xPolicyItemAccessDao.findByPolicyItemId(policyItemAccess
+ .getId())).thenReturn(policyItemAccessList);
+
+ Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn(
+ xAccessTypeDefDao);
+ Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType()))
+ .thenReturn(xAccessTypeDef);
+
+ Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn(
+ xPolicyConditionDefDao);
+ Mockito.when(
+ xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(xConditionDefList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemAndDefId(
+ xPolicyItem.getId(), policyConditionDefObj.getId()))
+ .thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(usersList);
+
+ Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao);
+ Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(groupsList);
+
+ RangerPolicy dbRangerPolicy = policyService.populateViewBean(policy);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), policy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(), policy.getName());
+
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ policy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), policy.getGuid());
+
+ Assert.assertEquals(dbRangerPolicy.getVersion(), policy.getVersion());
+ Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(),
+ policy.getIsAuditEnabled());
+
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(daoManager).getXXResourceDef();
+ Mockito.verify(daoManager).getXXPolicyResource();
+ Mockito.verify(daoManager).getXXPolicyResourceMap();
+ Mockito.verify(daoManager).getXXPolicyItem();
+ Mockito.verify(daoManager).getXXPolicyItemAccess();
+ Mockito.verify(daoManager).getXXAccessTypeDef();
+ Mockito.verify(daoManager).getXXPolicyConditionDef();
+ Mockito.verify(daoManager).getXXPolicyItemCondition();
+ Mockito.verify(daoManager).getXXUser();
+ Mockito.verify(daoManager).getXXGroup();
+ }
+
+ @Test
+ public void test4GetPolicyItemListForXXPolicy() {
+
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class);
+ XXAccessTypeDefDao xAccessTypeDefDao = Mockito
+ .mock(XXAccessTypeDefDao.class);
+ XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class);
+ XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito
+ .mock(XXPolicyConditionDefDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+
+ XXPolicy policy = policy();
+ String name = "fdfdfds";
+
+ List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem xPolicyItem = new XXPolicyItem();
+ xPolicyItem.setDelegateAdmin(false);
+ xPolicyItem.setAddedByUserId(null);
+ xPolicyItem.setCreateTime(new Date());
+ xPolicyItem.setGUID(null);
+ xPolicyItem.setId(Id);
+ xPolicyItem.setOrder(null);
+ xPolicyItem.setPolicyId(Id);
+ xPolicyItem.setUpdatedByUserId(null);
+ xPolicyItem.setUpdateTime(new Date());
+ xPolicyItemList.add(xPolicyItem);
+
+ List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>();
+ XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess();
+ policyItemAccess.setAddedByUserId(Id);
+ policyItemAccess.setCreateTime(new Date());
+ policyItemAccess.setPolicyitemid(Id);
+ policyItemAccess.setId(Id);
+ policyItemAccess.setOrder(1);
+ policyItemAccess.setUpdatedByUserId(Id);
+ policyItemAccess.setUpdateTime(new Date());
+ policyItemAccessList.add(policyItemAccess);
+
+ List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>();
+ XXResourceDef resourceDef = new XXResourceDef();
+ resourceDef.setAddedByUserId(Id);
+ resourceDef.setCreateTime(new Date());
+ resourceDef.setDefid(Id);
+ resourceDef.setDescription("test");
+ resourceDef.setId(Id);
+ resDefList.add(resourceDef);
+
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>();
+ XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef();
+ policyConditionDefObj.setAddedByUserId(Id);
+ policyConditionDefObj.setCreateTime(new Date());
+ policyConditionDefObj.setDefid(Id);
+ policyConditionDefObj.setDescription("policy conditio");
+ policyConditionDefObj.setId(Id);
+ policyConditionDefObj.setName(name);
+ policyConditionDefObj.setOrder(1);
+ policyConditionDefObj.setLabel("label");
+ xConditionDefList.add(policyConditionDefObj);
+
+ List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>();
+ XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition();
+ policyItemCondition.setAddedByUserId(Id);
+ policyItemCondition.setCreateTime(new Date());
+ policyItemCondition.setType(1L);
+ policyItemCondition.setId(Id);
+ policyItemCondition.setOrder(1);
+ policyItemCondition.setPolicyItemId(Id);
+ policyItemCondition.setUpdatedByUserId(Id);
+ policyItemCondition.setUpdateTime(new Date());
+ policyItemConditionList.add(policyItemCondition);
+
+ List<String> usersList = new ArrayList<String>();
+ List<String> groupsList = new ArrayList<String>();
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn(
+ xPolicyItemList);
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(policy.getId()))
+ .thenReturn(policyItemAccessList);
+
+ Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn(
+ xAccessTypeDefDao);
+ Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType()))
+ .thenReturn(xAccessTypeDef);
+
+ Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn(
+ xPolicyConditionDefDao);
+ Mockito.when(
+ xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(xConditionDefList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemAndDefId(
+ xPolicyItem.getId(), policyConditionDefObj.getId()))
+ .thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(usersList);
+
+ Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao);
+ Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(groupsList);
+
+ List<RangerPolicyItem> dbRangerPolicyItem = policyService
+ .getPolicyItemListForXXPolicy(policy);
+ Assert.assertNotNull(dbRangerPolicyItem);
+
+ Mockito.verify(daoManager).getXXPolicyItemAccess();
+ Mockito.verify(daoManager).getXXAccessTypeDef();
+ Mockito.verify(daoManager).getXXPolicyConditionDef();
+ Mockito.verify(daoManager).getXXPolicyItemCondition();
+ Mockito.verify(daoManager).getXXUser();
+ Mockito.verify(daoManager).getXXGroup();
+ }
+
+ @Test
+ public void test5PopulateXXToRangerPolicyItem() {
+ String name = "fdfdfds";
+
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class);
+ XXAccessTypeDefDao xAccessTypeDefDao = Mockito
+ .mock(XXAccessTypeDefDao.class);
+ XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class);
+ XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito
+ .mock(XXPolicyConditionDefDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+
+ List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem xPolicyItem = new XXPolicyItem();
+ xPolicyItem.setDelegateAdmin(false);
+ xPolicyItem.setAddedByUserId(null);
+ xPolicyItem.setCreateTime(new Date());
+ xPolicyItem.setGUID(null);
+ xPolicyItem.setId(Id);
+ xPolicyItem.setOrder(null);
+ xPolicyItem.setPolicyId(Id);
+ xPolicyItem.setUpdatedByUserId(null);
+ xPolicyItem.setUpdateTime(new Date());
+ xPolicyItemList.add(xPolicyItem);
+
+ List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>();
+ XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess();
+ policyItemAccess.setAddedByUserId(Id);
+ policyItemAccess.setCreateTime(new Date());
+ policyItemAccess.setPolicyitemid(Id);
+ policyItemAccess.setId(Id);
+ policyItemAccess.setOrder(1);
+ policyItemAccess.setUpdatedByUserId(Id);
+ policyItemAccess.setUpdateTime(new Date());
+ policyItemAccessList.add(policyItemAccess);
+
+ List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>();
+ XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef();
+ policyConditionDefObj.setAddedByUserId(Id);
+ policyConditionDefObj.setCreateTime(new Date());
+ policyConditionDefObj.setDefid(Id);
+ policyConditionDefObj.setDescription("policy conditio");
+ policyConditionDefObj.setId(Id);
+ policyConditionDefObj.setName(name);
+ policyConditionDefObj.setOrder(1);
+ policyConditionDefObj.setLabel("label");
+ xConditionDefList.add(policyConditionDefObj);
+
+ List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>();
+ XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition();
+ policyItemCondition.setAddedByUserId(Id);
+ policyItemCondition.setCreateTime(new Date());
+ policyItemCondition.setType(1L);
+ policyItemCondition.setId(Id);
+ policyItemCondition.setOrder(1);
+ policyItemCondition.setPolicyItemId(Id);
+ policyItemCondition.setUpdatedByUserId(Id);
+ policyItemCondition.setUpdateTime(new Date());
+ policyItemConditionList.add(policyItemCondition);
+
+ List<String> usersList = new ArrayList<String>();
+ List<String> groupsList = new ArrayList<String>();
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(Id)).thenReturn(
+ policyItemAccessList);
+
+ Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn(
+ xAccessTypeDefDao);
+ Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType()))
+ .thenReturn(xAccessTypeDef);
+
+ Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn(
+ xPolicyConditionDefDao);
+ Mockito.when(
+ xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(xConditionDefList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemAndDefId(
+ xPolicyItem.getId(), policyConditionDefObj.getId()))
+ .thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(usersList);
+
+ Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao);
+ Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(groupsList);
+
+ RangerPolicyItem dbRangerPolicyItem = policyService
+ .populateXXToRangerPolicyItem(xPolicyItem);
+ Assert.assertNotNull(dbRangerPolicyItem);
+
+ Mockito.verify(daoManager).getXXPolicyItemAccess();
+ Mockito.verify(daoManager).getXXAccessTypeDef();
+ Mockito.verify(daoManager).getXXPolicyConditionDef();
+ Mockito.verify(daoManager).getXXPolicyItemCondition();
+ Mockito.verify(daoManager).getXXUser();
+ Mockito.verify(daoManager).getXXGroup();
+ }
+
+ @Test
+ public void test6GetResourcesForXXPolicy() {
+
+ XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+
+ XXPolicy policy = policy();
+
+ List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>();
+ XXResourceDef resourceDef = new XXResourceDef();
+ resourceDef.setAddedByUserId(Id);
+ resourceDef.setCreateTime(new Date());
+ resourceDef.setDefid(Id);
+ resourceDef.setDescription("test");
+ resourceDef.setId(Id);
+ resDefList.add(resourceDef);
+
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao);
+ Mockito.when(xResourceDefDao.findByPolicyId(policy.getId()))
+ .thenReturn(resDefList);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(
+ xPolicyResourceDao.findByResDefIdAndPolicyId(
+ resourceDef.getId(), policy.getId())).thenReturn(
+ policyResource);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResource.getId()))
+ .thenReturn(policyResourceMapList);
+
+ Map<String, RangerPolicyResource> dbListMap = policyService
+ .getResourcesForXXPolicy(policy);
+ Assert.assertNotNull(dbListMap);
+
+ Mockito.verify(daoManager).getXXResourceDef();
+ Mockito.verify(daoManager).getXXPolicyResource();
+ Mockito.verify(daoManager).getXXPolicyResourceMap();
+ }
+
+ @Test
+ public void test7GetPopulatedViewObject() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXAccessTypeDefDao xAccessTypeDefDao = Mockito
+ .mock(XXAccessTypeDefDao.class);
+ XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class);
+ XXPolicyConditionDefDao xPolicyConditionDefDao = Mockito
+ .mock(XXPolicyConditionDefDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXGroupDao xGroupDao = Mockito.mock(XXGroupDao.class);
+
+ XXPolicy policy = policy();
+ XXService xService = xService();
+ String name = "fdfdfds";
+
+ XXPortalUser tUser = new XXPortalUser();
+ tUser.setAddedByUserId(Id);
+ tUser.setCreateTime(new Date());
+ tUser.setEmailAddress("test@gmail.com");
+ tUser.setFirstName(name);
+ tUser.setId(Id);
+ tUser.setLastName(name);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setAddedByUserId(Id);
+ xServiceDef.setCreateTime(new Date());
+ xServiceDef.setDescription("test");
+ xServiceDef.setGuid("1427365526516_835_0");
+ xServiceDef.setId(Id);
+
+ List<XXServiceConfigMap> srcConfigMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ srcConfigMapList.add(xConfMap);
+
+ List<XXResourceDef> resDefList = new ArrayList<XXResourceDef>();
+ XXResourceDef resourceDef = new XXResourceDef();
+ resourceDef.setAddedByUserId(Id);
+ resourceDef.setCreateTime(new Date());
+ resourceDef.setDefid(Id);
+ resourceDef.setDescription("test");
+ resourceDef.setId(Id);
+ resDefList.add(resourceDef);
+
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXPolicyItem> xPolicyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem xPolicyItem = new XXPolicyItem();
+ xPolicyItem.setDelegateAdmin(false);
+ xPolicyItem.setAddedByUserId(null);
+ xPolicyItem.setCreateTime(new Date());
+ xPolicyItem.setGUID(null);
+ xPolicyItem.setId(Id);
+ xPolicyItem.setOrder(null);
+ xPolicyItem.setPolicyId(Id);
+ xPolicyItem.setUpdatedByUserId(null);
+ xPolicyItem.setUpdateTime(new Date());
+ xPolicyItemList.add(xPolicyItem);
+
+ List<XXPolicyItemAccess> policyItemAccessList = new ArrayList<XXPolicyItemAccess>();
+ XXPolicyItemAccess policyItemAccess = new XXPolicyItemAccess();
+ policyItemAccess.setAddedByUserId(Id);
+ policyItemAccess.setCreateTime(new Date());
+ policyItemAccess.setPolicyitemid(Id);
+ policyItemAccess.setId(Id);
+ policyItemAccess.setOrder(1);
+ policyItemAccess.setUpdatedByUserId(Id);
+ policyItemAccess.setUpdateTime(new Date());
+ policyItemAccessList.add(policyItemAccess);
+
+ List<XXPolicyConditionDef> xConditionDefList = new ArrayList<XXPolicyConditionDef>();
+ XXPolicyConditionDef policyConditionDefObj = new XXPolicyConditionDef();
+ policyConditionDefObj.setAddedByUserId(Id);
+ policyConditionDefObj.setCreateTime(new Date());
+ policyConditionDefObj.setDefid(Id);
+ policyConditionDefObj.setDescription("policy conditio");
+ policyConditionDefObj.setId(Id);
+ policyConditionDefObj.setName(name);
+ policyConditionDefObj.setOrder(1);
+ policyConditionDefObj.setLabel("label");
+ xConditionDefList.add(policyConditionDefObj);
+
+ List<XXPolicyItemCondition> policyItemConditionList = new ArrayList<XXPolicyItemCondition>();
+ XXPolicyItemCondition policyItemCondition = new XXPolicyItemCondition();
+ policyItemCondition.setAddedByUserId(Id);
+ policyItemCondition.setCreateTime(new Date());
+ policyItemCondition.setType(1L);
+ policyItemCondition.setId(Id);
+ policyItemCondition.setOrder(1);
+ policyItemCondition.setPolicyItemId(Id);
+ policyItemCondition.setUpdatedByUserId(Id);
+ policyItemCondition.setUpdateTime(new Date());
+ policyItemConditionList.add(policyItemCondition);
+
+ List<String> usersList = new ArrayList<String>();
+ List<String> groupsList = new ArrayList<String>();
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.getById(Id)).thenReturn(tUser);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(xService.getType())).thenReturn(
+ xServiceDef);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(xServiceConfigMapDao.findByServiceId(xService.getId()))
+ .thenReturn(srcConfigMapList);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(policy.getService())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao);
+ Mockito.when(xResourceDefDao.findByPolicyId(policy.getId()))
+ .thenReturn(resDefList);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(
+ xPolicyResourceDao.findByResDefIdAndPolicyId(
+ resourceDef.getId(), policy.getId())).thenReturn(
+ policyResource);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResource.getId()))
+ .thenReturn(policyResourceMapList);
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.findByPolicyId(policy.getId())).thenReturn(
+ xPolicyItemList);
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(xPolicyItemAccessDao.findByPolicyItemId(policy.getId()))
+ .thenReturn(policyItemAccessList);
+
+ Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn(
+ xAccessTypeDefDao);
+ Mockito.when(xAccessTypeDefDao.getById(policyItemAccess.getType()))
+ .thenReturn(xAccessTypeDef);
+
+ Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn(
+ xPolicyConditionDefDao);
+ Mockito.when(
+ xPolicyConditionDefDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(xConditionDefList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemAndDefId(
+ xPolicyItem.getId(), policyConditionDefObj.getId()))
+ .thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(usersList);
+
+ Mockito.when(daoManager.getXXGroup()).thenReturn(xGroupDao);
+ Mockito.when(xGroupDao.findByPolicyItemId(xPolicyItem.getId()))
+ .thenReturn(groupsList);
+
+ RangerPolicy dbRangerPolicy = policyService
+ .getPopulatedViewObject(policy);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), policy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(), policy.getName());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ policy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), policy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getVersion(), policy.getVersion());
+ Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(),
+ policy.getIsAuditEnabled());
+ Mockito.verify(daoManager).getXXPolicyItemAccess();
+ Mockito.verify(daoManager).getXXAccessTypeDef();
+ Mockito.verify(daoManager).getXXPolicyConditionDef();
+ Mockito.verify(daoManager).getXXPolicyItemCondition();
+ Mockito.verify(daoManager).getXXUser();
+ Mockito.verify(daoManager).getXXGroup();
+ }
+
+ @Test
+ public void test8getTransactionLog() {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ XXService xService = xService();
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(rangerPolicy.getService()))
+ .thenReturn(xService);
+
+ List<XXTrxLog> dbXXTrxLogList = policyService.getTransactionLog(
+ rangerPolicy, 1);
+ Assert.assertNotNull(dbXXTrxLogList);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java
new file mode 100644
index 0000000..75e2ebd
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerPolicyServiceBase.java
@@ -0,0 +1,275 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ranger.service;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+import javax.ws.rs.WebApplicationException;
+
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.MessageEnums;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerSearchUtil;
+import org.apache.ranger.common.SearchField;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.common.db.BaseDao;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXServiceDao;
+import org.apache.ranger.entity.XXDBBase;
+import org.apache.ranger.entity.XXPolicy;
+import org.apache.ranger.entity.XXService;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.util.SearchFilter;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.view.RangerPolicyList;
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestRangerPolicyServiceBase {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ RangerPolicyService policyService = new RangerPolicyService();
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ ContextUtil contextUtil;
+
+ @Mock
+ RangerAuditFields<XXDBBase> rangerAuditFields;
+
+ @Mock
+ RangerBizUtil rangerBizUtil;
+
+ @Mock
+ RangerSearchUtil searchUtil;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ public void setup() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+
+ return policy;
+ }
+
+ private XXPolicy policy() {
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(Id);
+ xxPolicy.setName("HDFS_1-1-20150316062453");
+ xxPolicy.setAddedByUserId(Id);
+ xxPolicy.setCreateTime(new Date());
+ xxPolicy.setDescription("test");
+ xxPolicy.setIsAuditEnabled(false);
+ xxPolicy.setIsEnabled(false);
+ xxPolicy.setService(1L);
+ xxPolicy.setUpdatedByUserId(Id);
+ xxPolicy.setUpdateTime(new Date());
+ return xxPolicy;
+ }
+
+ @Test
+ public void test1mapViewToEntityBean() {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ XXPolicy policy = policy();
+ int OPERATION_CONTEXT = 0;
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(rangerPolicy.getService()))
+ .thenReturn(xService);
+
+ XXPolicy dbPolicy = policyService.mapViewToEntityBean(rangerPolicy,
+ policy, OPERATION_CONTEXT);
+ Assert.assertNotNull(dbPolicy);
+ Assert.assertEquals(dbPolicy.getId(), policy.getId());
+ Assert.assertEquals(dbPolicy.getGuid(), policy.getGuid());
+ Assert.assertEquals(dbPolicy.getName(), policy.getName());
+ Assert.assertEquals(dbPolicy.getAddedByUserId(),
+ policy.getAddedByUserId());
+ Assert.assertEquals(dbPolicy.getIsEnabled(), policy.getIsEnabled());
+ Assert.assertEquals(dbPolicy.getVersion(), policy.getVersion());
+ Assert.assertEquals(dbPolicy.getDescription(), policy.getDescription());
+
+ Mockito.verify(daoManager).getXXService();
+ }
+
+ @Test
+ public void test2mapViewToEntityBeanNullValue() {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ XXPolicy policy = policy();
+ int OPERATION_CONTEXT = 0;
+
+ Mockito.when(
+ restErrorUtil.createRESTException(
+ "No corresponding service found for policyName: "
+ + rangerPolicy.getName()
+ + "Service Not Found : "
+ + rangerPolicy.getName(),
+ MessageEnums.INVALID_INPUT_DATA)).thenThrow(
+ new WebApplicationException());
+
+ thrown.expect(WebApplicationException.class);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(rangerPolicy.getService()))
+ .thenReturn(null);
+
+ XXPolicy dbPolicy = policyService.mapViewToEntityBean(rangerPolicy,
+ policy, OPERATION_CONTEXT);
+ Assert.assertNotNull(dbPolicy);
+ Assert.assertEquals(dbPolicy.getId(), policy.getId());
+ Assert.assertEquals(dbPolicy.getGuid(), policy.getGuid());
+ Assert.assertEquals(dbPolicy.getName(), policy.getName());
+ Assert.assertEquals(dbPolicy.getAddedByUserId(),
+ policy.getAddedByUserId());
+ Assert.assertEquals(dbPolicy.getIsEnabled(), policy.getIsEnabled());
+ Assert.assertEquals(dbPolicy.getVersion(), policy.getVersion());
+ Assert.assertEquals(dbPolicy.getDescription(), policy.getDescription());
+
+ Mockito.verify(daoManager).getXXService();
+ }
+
+ @Test
+ public void test3mapEntityToViewBean() {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ XXPolicy policy = policy();
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(policy.getService())).thenReturn(
+ xService);
+
+ RangerPolicy dbRangerPolicy = policyService.mapEntityToViewBean(
+ rangerPolicy, policy);
+
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assert.assertEquals(dbRangerPolicy.getIsEnabled(),
+ rangerPolicy.getIsEnabled());
+ Assert.assertEquals(dbRangerPolicy.getVersion(),
+ rangerPolicy.getVersion());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ rangerPolicy.getDescription());
+
+ Mockito.verify(daoManager).getXXService();
+ }
+
+ @Test
+ public void test4searchRangerPolicies() {
+ EntityManager entityManager = Mockito.mock(EntityManager.class);
+ SearchFilter searchFilter = new SearchFilter();
+ searchFilter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ searchFilter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ String searchString = "policyName";
+ String sortString = "asc";
+ List<SearchField> searchFieldList = new ArrayList<SearchField>();
+ boolean isCountQuery = false;
+
+ BaseDao baseDao = Mockito.mock(BaseDao.class);
+
+ Mockito.when(daoManager.getDaoForClassName(Mockito.anyString()))
+ .thenReturn(baseDao);
+ Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager);
+ Mockito.when(
+ searchUtil
+ .createSearchQuery(entityManager, searchString,
+ sortString, searchFilter, searchFieldList,
+ isCountQuery)).thenReturn(null);
+
+ RangerPolicyList dbRangerPolicyList = policyService
+ .searchRangerPolicies(searchFilter);
+ Assert.assertNotNull(dbRangerPolicyList);
+ Mockito.verify(daoManager).getDaoForClassName(Mockito.anyString());
+ }
+
+}
[4/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
Posted by ve...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java b/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
index c514bfb..eedacaf 100644
--- a/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
+++ b/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
@@ -18,6 +18,7 @@ package org.apache.ranger.biz;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
@@ -28,19 +29,31 @@ import org.apache.ranger.common.ContextUtil;
import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.SearchCriteria;
+import org.apache.ranger.common.SearchUtil;
import org.apache.ranger.common.StringUtil;
import org.apache.ranger.common.UserSessionBase;
import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXGroupPermissionDao;
+import org.apache.ranger.db.XXModuleDefDao;
import org.apache.ranger.db.XXPortalUserDao;
import org.apache.ranger.db.XXPortalUserRoleDao;
+import org.apache.ranger.db.XXUserPermissionDao;
+import org.apache.ranger.entity.XXGroupPermission;
+import org.apache.ranger.entity.XXModuleDef;
import org.apache.ranger.entity.XXPortalUser;
import org.apache.ranger.entity.XXPortalUserRole;
+import org.apache.ranger.entity.XXUserPermission;
import org.apache.ranger.security.context.RangerContextHolder;
import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.service.XGroupPermissionService;
+import org.apache.ranger.service.XUserPermissionService;
+import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXPasswordChange;
import org.apache.ranger.view.VXPortalUser;
import org.apache.ranger.view.VXPortalUserList;
import org.apache.ranger.view.VXResponse;
+import org.apache.ranger.view.VXString;
+import org.apache.ranger.view.VXUserPermission;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -78,8 +91,20 @@ public class TestUserMgr {
StringUtil stringUtil;
@Mock
+ SearchUtil searchUtil;
+
+ @Mock
RangerBizUtil msBizUtil;
+ @Mock
+ XUserPermissionService xUserPermissionService;
+
+ @Mock
+ XGroupPermissionService xGroupPermissionService;
+
+ @Mock
+ SessionMgr sessionMgr;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -140,20 +165,25 @@ public class TestUserMgr {
XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1,
userRoleList);
userId = dbxxPortalUser.getId();
-
+
Assert.assertNotNull(dbxxPortalUser);
Assert.assertEquals(userId, dbxxPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(), dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(), dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(), dbxxPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(), dbxxPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(), dbxxPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(), dbxxPortalUser.getPassword());
-
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbxxPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),
+ dbxxPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),
+ dbxxPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getPassword(),
+ dbxxPortalUser.getPassword());
+
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXPortalUserRole();
}
-
@Test
public void test12CreateUser() {
@@ -186,15 +216,21 @@ public class TestUserMgr {
XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1);
userId = dbxxPortalUser.getId();
-
+
Assert.assertNotNull(dbxxPortalUser);
Assert.assertEquals(userId, dbxxPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(), dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(), dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(), dbxxPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(), dbxxPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(), dbxxPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(), dbxxPortalUser.getPassword());
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbxxPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),
+ dbxxPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),
+ dbxxPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getPassword(),
+ dbxxPortalUser.getPassword());
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXPortalUserRole();
@@ -227,12 +263,14 @@ public class TestUserMgr {
Mockito.when(
stringUtil.validatePassword(Mockito.anyString(),
new String[] { Mockito.anyString() })).thenReturn(true);
-
+
VXResponse dbVXResponse = userMgr.changePassword(pwdChange);
- Assert.assertNotNull(dbVXResponse);
- Assert.assertEquals(userProfile.getStatus(), dbVXResponse.getStatusCode());
-
- Mockito.verify(stringUtil).equals(Mockito.anyString(),Mockito.anyString());
+ Assert.assertNotNull(dbVXResponse);
+ Assert.assertEquals(userProfile.getStatus(),
+ dbVXResponse.getStatusCode());
+
+ Mockito.verify(stringUtil).equals(Mockito.anyString(),
+ Mockito.anyString());
Mockito.verify(stringUtil).validatePassword(Mockito.anyString(),
new String[] { Mockito.anyString() });
}
@@ -264,17 +302,21 @@ public class TestUserMgr {
+ changeEmail)).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
- VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
+
+ VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,
+ changeEmail);
Assert.assertNotNull(dbVXPortalUser);
- Assert.assertEquals(userId, dbVXPortalUser.getId());
- Assert.assertEquals(userProfile.getLastName(), dbVXPortalUser.getLastName());
- Assert.assertEquals(changeEmail.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(changeEmail.getEmailAddress(), dbVXPortalUser.getEmailAddress());
-
- Mockito.verify(restErrorUtil).createRESTException("serverMsg.userMgrEmailChange",
- MessageEnums.OPER_NO_PERMISSION, null, null, ""
- + changeEmail);
+ Assert.assertEquals(userId, dbVXPortalUser.getId());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbVXPortalUser.getLastName());
+ Assert.assertEquals(changeEmail.getLoginId(),
+ dbVXPortalUser.getLoginId());
+ Assert.assertEquals(changeEmail.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
+
+ Mockito.verify(restErrorUtil).createRESTException(
+ "serverMsg.userMgrEmailChange",
+ MessageEnums.OPER_NO_PERMISSION, null, null, "" + changeEmail);
}
@Test
@@ -302,16 +344,20 @@ public class TestUserMgr {
"emailAddress", changeEmail.toString())).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
+
VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,
changeEmail);
Assert.assertNotNull(dbVXPortalUser);
- Assert.assertEquals(userId, dbVXPortalUser.getId());
- Assert.assertEquals(userProfile.getLastName(), dbVXPortalUser.getLastName());
- Assert.assertEquals(changeEmail.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(changeEmail.getEmailAddress(), dbVXPortalUser.getEmailAddress());
-
- Mockito.verify(restErrorUtil).createRESTException("serverMsg.userMgrInvalidEmail",
+ Assert.assertEquals(userId, dbVXPortalUser.getId());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbVXPortalUser.getLastName());
+ Assert.assertEquals(changeEmail.getLoginId(),
+ dbVXPortalUser.getLoginId());
+ Assert.assertEquals(changeEmail.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
+
+ Mockito.verify(restErrorUtil).createRESTException(
+ "serverMsg.userMgrInvalidEmail",
MessageEnums.INVALID_INPUT_DATA, changeEmail.getId(),
"emailAddress", changeEmail.toString());
}
@@ -321,6 +367,10 @@ public class TestUserMgr {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
XXPortalUser user = new XXPortalUser();
VXPortalUser userProfile = userProfile();
@@ -331,23 +381,63 @@ public class TestUserMgr {
List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
list.add(XXPortalUserRole);
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<XXGroupPermission>();
+ XXGroupPermission xGroupPermissionObj = new XXGroupPermission();
+ xGroupPermissionObj.setAddedByUserId(userId);
+ xGroupPermissionObj.setCreateTime(new Date());
+ xGroupPermissionObj.setId(userId);
+ xGroupPermissionObj.setIsAllowed(1);
+ xGroupPermissionObj.setModuleId(1L);
+ xGroupPermissionObj.setUpdatedByUserId(userId);
+ xGroupPermissionObj.setUpdateTime(new Date());
+ xGroupPermissionObj.setGroupId(userId);
+ xGroupPermissionList.add(xGroupPermissionObj);
+
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.create((XXPortalUser) Mockito.anyObject()))
.thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(Mockito.anyLong())).thenReturn(list);
-
+
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(
+ xUserPermissionDao);
+ Mockito.when(
+ xUserPermissionDao
+ .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
+ .thenReturn(xUserPermissionsList);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(
+ xGroupPermissionDao.findbyVXPoratUserId(userProfile.getId()))
+ .thenReturn(xGroupPermissionList);
+
VXPortalUser dbVXPortalUser = userMgr.createUser(userProfile);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
+ Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(user.getEmailAddress(), dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(user.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
Assert.assertEquals(user.getPassword(), dbVXPortalUser.getPassword());
-
+
Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
}
@Test
@@ -375,13 +465,14 @@ public class TestUserMgr {
.createDefaultAccountUser(userProfile);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
+ Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(user.getEmailAddress(), dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(user.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
Assert.assertEquals(user.getPassword(), dbVXPortalUser.getPassword());
-
+
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -403,7 +494,7 @@ public class TestUserMgr {
boolean isValue = userMgr.isUserInRole(userId, "ROLE_USER");
Assert.assertTrue(isValue);
-
+
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -423,18 +514,25 @@ public class TestUserMgr {
MessageEnums.INVALID_INPUT_DATA)).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
+
XXPortalUser dbXXPortalUser = userMgr.updateUserWithPass(userProfile);
Assert.assertNotNull(dbXXPortalUser);
Assert.assertEquals(userId, dbXXPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(), dbXXPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(), dbXXPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(), dbXXPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(), dbXXPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(), dbXXPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(), dbXXPortalUser.getPassword());
-
- Mockito.verify(restErrorUtil).createRESTException("Please provide valid email address.",
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),
+ dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbXXPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),
+ dbXXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),
+ dbXXPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getPassword(),
+ dbXXPortalUser.getPassword());
+
+ Mockito.verify(restErrorUtil).createRESTException(
+ "Please provide valid email address.",
MessageEnums.INVALID_INPUT_DATA);
}
@@ -450,17 +548,17 @@ public class TestUserMgr {
searchCriteria.setOwnerId(userId);
searchCriteria.setStartIndex(1);
searchCriteria.setSortBy("asc");
-
+ Long count = 1l;
Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager);
Mockito.when(entityManager.createQuery(Mockito.anyString()))
.thenReturn(query);
-
+ Mockito.when(query.getSingleResult()).thenReturn(count);
+
VXPortalUserList dbVXPortalUserList = userMgr
.searchUsers(searchCriteria);
Assert.assertNotNull(dbVXPortalUserList);
-
- Mockito.verify(daoManager).getEntityManager();
+ Mockito.verify(query).getSingleResult();
}
@Test
@@ -476,7 +574,7 @@ public class TestUserMgr {
XXPortalUser dbXXPortalUser = userMgr.findByEmailAddress(emailId);
Assert.assertNotNull(dbXXPortalUser);
Assert.assertNotEquals(emailId, dbXXPortalUser.getEmailAddress());
-
+
Mockito.verify(daoManager).getXXPortalUser();
}
@@ -503,10 +601,10 @@ public class TestUserMgr {
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
-
+
Collection<String> stringReturn = userMgr.getRolesForUser(user);
Assert.assertNotNull(stringReturn);
-
+
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -524,7 +622,7 @@ public class TestUserMgr {
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
-
+
boolean deleteValue = userMgr.deleteUserRole(userId, userRole);
Assert.assertTrue(deleteValue);
}
@@ -533,6 +631,17 @@ public class TestUserMgr {
public void test29DeactivateUser() {
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
+ VXGroupPermission vXGroupPermission = Mockito
+ .mock(VXGroupPermission.class);
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
+ VXUserPermission vXUserPermission = Mockito
+ .mock(VXUserPermission.class);
+
VXPortalUser userProfile = userProfile();
XXPortalUser user = new XXPortalUser();
@@ -545,6 +654,30 @@ public class TestUserMgr {
user.setPublicScreenName(userProfile.getPublicScreenName());
user.setId(userProfile.getId());
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<XXGroupPermission>();
+ XXGroupPermission xGroupPermissionObj = new XXGroupPermission();
+ xGroupPermissionObj.setAddedByUserId(userId);
+ xGroupPermissionObj.setCreateTime(new Date());
+ xGroupPermissionObj.setId(userId);
+ xGroupPermissionObj.setIsAllowed(1);
+ xGroupPermissionObj.setModuleId(1L);
+ xGroupPermissionObj.setUpdatedByUserId(userId);
+ xGroupPermissionObj.setUpdateTime(new Date());
+ xGroupPermissionObj.setGroupId(userId);
+ xGroupPermissionList.add(xGroupPermissionObj);
+
XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
XXPortalUserRole.setId(userId);
XXPortalUserRole.setUserRole("ROLE_USER");
@@ -558,14 +691,160 @@ public class TestUserMgr {
Mockito.when(roleDao.findByParentId(Mockito.anyLong()))
.thenReturn(list);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(
+ xUserPermissionDao);
+ Mockito.when(
+ xUserPermissionDao
+ .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
+ .thenReturn(xUserPermissionsList);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(
+ xGroupPermissionDao.findbyVXPoratUserId(userProfile.getId()))
+ .thenReturn(xGroupPermissionList);
+
+ Mockito.when(
+ xGroupPermissionService.populateViewBean(xGroupPermissionObj))
+ .thenReturn(vXGroupPermission);
+
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong()))
+ .thenReturn(xModuleDef);
+
+ Mockito.when(
+ xUserPermissionService.populateViewBean(xUserPermissionObj))
+ .thenReturn(vXUserPermission);
+
VXPortalUser dbVXPortalUser = userMgr.deactivateUser(user);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
+ Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
-
+
Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
+ Mockito.verify(xUserPermissionService).populateViewBean(
+ xUserPermissionObj);
+ Mockito.verify(xGroupPermissionService).populateViewBean(
+ xGroupPermissionObj);
+ }
+
+ @Test
+ public void test30checkAccess() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
+
+ userMgr.checkAccess(userId);
+ Mockito.verify(daoManager).getXXPortalUser();
+ }
+
+ @Test
+ public void test31getUserProfile() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
+
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito
+ .mock(XXPortalUserRoleDao.class);
+
+ List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ xPortalUserRoleList.add(XXPortalUserRole);
+
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<XXGroupPermission>();
+ XXGroupPermission xGroupPermissionObj = new XXGroupPermission();
+ xGroupPermissionObj.setAddedByUserId(userId);
+ xGroupPermissionObj.setCreateTime(new Date());
+ xGroupPermissionObj.setId(userId);
+ xGroupPermissionObj.setIsAllowed(1);
+ xGroupPermissionObj.setModuleId(1L);
+ xGroupPermissionObj.setUpdatedByUserId(userId);
+ xGroupPermissionObj.setUpdateTime(new Date());
+ xGroupPermissionObj.setGroupId(userId);
+ xGroupPermissionList.add(xGroupPermissionObj);
+ VXPortalUser userProfile = userProfile();
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
+ xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByParentId(userId)).thenReturn(
+ xPortalUserRoleList);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(
+ xUserPermissionDao);
+ Mockito.when(
+ xUserPermissionDao
+ .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
+ .thenReturn(xUserPermissionsList);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(
+ xGroupPermissionDao.findbyVXPoratUserId(userProfile.getId()))
+ .thenReturn(xGroupPermissionList);
+ VXPortalUser dbVXPortalUser = userMgr.getUserProfile(userId);
+ Assert.assertNotNull(dbVXPortalUser);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
+ }
+
+ @Test
+ public void test32getUserProfileByLoginId() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.findByLoginId("1L"))
+ .thenReturn(xPortalUser);
+
+ VXPortalUser dbVXPortalUser = userMgr.getUserProfileByLoginId();
+ Assert.assertNull(dbVXPortalUser);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ }
+
+ @Test
+ public void test33setUserRoles() {
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ List<VXString> vStringRolesList = new ArrayList<VXString>();
+ VXString vXStringObj = new VXString();
+ vXStringObj.setValue("1L");
+ vStringRolesList.add(vXStringObj);
+
+ List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ xPortalUserRoleList.add(XXPortalUserRole);
+
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByUserId(userId))
+ .thenReturn(xPortalUserRoleList);
+ userMgr.setUserRoles(userId, vStringRolesList);
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java b/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
index 4ae1d02..4fba6df 100644
--- a/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
+++ b/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
@@ -18,8 +18,10 @@ package org.apache.ranger.biz;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Date;
import java.util.HashMap;
import java.util.List;
+import java.util.Set;
import org.apache.ranger.common.ContextUtil;
import org.apache.ranger.common.RESTErrorUtil;
@@ -28,23 +30,40 @@ import org.apache.ranger.common.StringUtil;
import org.apache.ranger.common.UserSessionBase;
import org.apache.ranger.db.RangerDaoManager;
import org.apache.ranger.db.XXGroupDao;
+import org.apache.ranger.db.XXGroupPermissionDao;
import org.apache.ranger.db.XXGroupUserDao;
+import org.apache.ranger.db.XXModuleDefDao;
+import org.apache.ranger.db.XXPortalUserDao;
+import org.apache.ranger.db.XXPortalUserRoleDao;
import org.apache.ranger.db.XXUserDao;
+import org.apache.ranger.db.XXUserPermissionDao;
import org.apache.ranger.entity.XXGroup;
+import org.apache.ranger.entity.XXGroupPermission;
+import org.apache.ranger.entity.XXModuleDef;
+import org.apache.ranger.entity.XXPortalUser;
+import org.apache.ranger.entity.XXPortalUserRole;
import org.apache.ranger.entity.XXUser;
+import org.apache.ranger.entity.XXUserPermission;
import org.apache.ranger.security.context.RangerContextHolder;
import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.service.XGroupPermissionService;
import org.apache.ranger.service.XGroupService;
import org.apache.ranger.service.XGroupUserService;
+import org.apache.ranger.service.XModuleDefService;
+import org.apache.ranger.service.XPortalUserService;
+import org.apache.ranger.service.XUserPermissionService;
import org.apache.ranger.service.XUserService;
import org.apache.ranger.view.VXGroup;
import org.apache.ranger.view.VXGroupList;
+import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXGroupUser;
import org.apache.ranger.view.VXGroupUserList;
+import org.apache.ranger.view.VXModuleDef;
import org.apache.ranger.view.VXPortalUser;
import org.apache.ranger.view.VXUser;
import org.apache.ranger.view.VXUserGroupInfo;
import org.apache.ranger.view.VXUserList;
+import org.apache.ranger.view.VXUserPermission;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -61,8 +80,8 @@ import org.mockito.runners.MockitoJUnitRunner;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestXUserMgr {
- private static Long userId = 10L;
-
+ private static Long userId = 8L;
+
private static Integer emptyValue;
@InjectMocks
@@ -92,6 +111,24 @@ public class TestXUserMgr {
@Mock
XUserService xUserService;
+ @Mock
+ XModuleDefService xModuleDefService;
+
+ @Mock
+ XUserPermissionService xUserPermissionService;
+
+ @Mock
+ XGroupPermissionService xGroupPermissionService;
+
+ @Mock
+ ContextUtil contextUtil;
+
+ @Mock
+ RangerSecurityContext rangerSecurityContext;
+
+ @Mock
+ XPortalUserService xPortalUserService;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -118,17 +155,78 @@ public class TestXUserMgr {
return vxUser;
}
+ private VXModuleDef vXModuleDef() {
+ VXUserPermission userPermission = vXUserPermission();
+ List<VXUserPermission> userPermList = new ArrayList<VXUserPermission>();
+ userPermList.add(userPermission);
+
+ VXGroupPermission groupPermission = vXGroupPermission();
+ List<VXGroupPermission> groupPermList = new ArrayList<VXGroupPermission>();
+ groupPermList.add(groupPermission);
+
+ VXModuleDef vxModuleDef = new VXModuleDef();
+ vxModuleDef.setAddedById(userId);
+ vxModuleDef.setCreateDate(new Date());
+ vxModuleDef.setCreateTime(new Date());
+ vxModuleDef.setId(userId);
+ vxModuleDef.setModule("Policy manager");
+ vxModuleDef.setOwner("admin");
+ vxModuleDef.setUpdateDate(new Date());
+ vxModuleDef.setUpdatedBy("admin");
+ vxModuleDef.setUpdatedById(userId);
+ vxModuleDef.setUpdateTime(new Date());
+ vxModuleDef.setUrl("/policy manager");
+ vxModuleDef.setUserPermList(userPermList);
+ vxModuleDef.setGroupPermList(groupPermList);
+
+ return vxModuleDef;
+ }
+
+ private VXUserPermission vXUserPermission() {
+ VXUserPermission userPermission = new VXUserPermission();
+ userPermission.setId(1L);
+ userPermission.setIsAllowed(1);
+ userPermission.setModuleId(1L);
+ userPermission.setUserId(userId);
+ userPermission.setUserName("xyz");
+ userPermission.setOwner("admin");
+
+ return userPermission;
+ }
+
+ private VXGroupPermission vXGroupPermission() {
+ VXGroupPermission groupPermission = new VXGroupPermission();
+ groupPermission.setId(1L);
+ groupPermission.setIsAllowed(1);
+ groupPermission.setModuleId(1L);
+ groupPermission.setGroupId(userId);
+ groupPermission.setGroupName("xyz");
+ groupPermission.setOwner("admin");
+
+ return groupPermission;
+ }
+
@Test
public void test11CreateXUser() {
-
- setup();
VXUser vxUser = vxUser();
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("test");
+ vxUser.setUserRoleList(userRoleList);
+
+ ArrayList<String> userRoleListVXPortaUser = new ArrayList<String>();
VXPortalUser vXPortalUser = new VXPortalUser();
+ vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
- Mockito.when(userMgr.createDefaultAccountUser(vXPortalUser))
- .thenReturn(vXPortalUser);
Mockito.when(xUserService.createResource(vxUser)).thenReturn(vxUser);
+ XXModuleDefDao value = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(value);
+ List<XXModuleDef> lsvalue = new ArrayList<XXModuleDef>();
+ Mockito.when(value.findModuleNamesWithIds()).thenReturn(lsvalue);
+
+ Mockito.when(
+ userMgr.createDefaultAccountUser((VXPortalUser) Mockito
+ .anyObject())).thenReturn(vXPortalUser);
VXUser dbUser = xUserMgr.createXUser(vxUser);
Assert.assertNotNull(dbUser);
@@ -139,12 +237,17 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
Assert.assertEquals(dbUser.getGroupNameList(),
vxUser.getGroupNameList());
-
+
Mockito.verify(xUserService).createResource(vxUser);
Mockito.when(xUserService.readResourceWithOutLogin(userId)).thenReturn(
vxUser);
VXUser dbvxUser = xUserMgr.getXUser(userId);
+
+ Mockito.verify(userMgr).createDefaultAccountUser(
+ (VXPortalUser) Mockito.anyObject());
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(value).findModuleNamesWithIds();
Assert.assertNotNull(dbvxUser);
Assert.assertEquals(userId, dbvxUser.getId());
Assert.assertEquals(dbvxUser.getDescription(), vxUser.getDescription());
@@ -174,16 +277,16 @@ public class TestXUserMgr {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
+
+ Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
Integer value = 1;
visibilityMap.put(userId, value);
-
+
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
+
xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(value, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
@@ -191,45 +294,45 @@ public class TestXUserMgr {
Mockito.verify(daoManager).getXXUser();
Mockito.verify(xUserService).populateViewBean(xxUser);
}
-
+
@Test
public void test14ModifyUserVisibilitySetZero() {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
+
+ Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
Integer value = 0;
visibilityMap.put(userId, value);
-
+
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
- xUserMgr.modifyUserVisibility(visibilityMap);
+
+ xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(value, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
Mockito.verify(xUserService).updateResource(vxUser);
Mockito.verify(daoManager).getXXUser();
Mockito.verify(xUserService).populateViewBean(xxUser);
}
-
+
@Test
public void test15ModifyUserVisibilitySetEmpty() {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
+
+ Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
visibilityMap.put(userId, emptyValue);
-
+
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
- xUserMgr.modifyUserVisibility(visibilityMap);
+
+ xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(emptyValue, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
Mockito.verify(xUserService).updateResource(vxUser);
@@ -263,7 +366,7 @@ public class TestXUserMgr {
Assert.assertEquals(dbXGroup.getDescription(),
dbxGroup.getDescription());
Assert.assertEquals(dbXGroup.getName(), dbxGroup.getName());
- Mockito.verify(xGroupService).readResourceWithOutLogin(userId);
+ Mockito.verify(xGroupService).readResourceWithOutLogin(userId);
}
@Test
@@ -287,87 +390,90 @@ public class TestXUserMgr {
Assert.assertEquals(vXGroup.getDescription(),
dbvxGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbvxGroup.getName());
- Mockito.verify(daoManager).getXXGroup();
- Mockito.verify(xGroupService).updateResource(vXGroup);
+ Mockito.verify(daoManager).getXXGroup();
+ Mockito.verify(xGroupService).updateResource(vXGroup);
}
@Test
public void test18ModifyGroupsVisibilitySetOne() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
Integer value = 1;
groupVisibilityMap.put(userId, value);
-
+
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
+ vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
+
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(value, vXGroup.getIsVisible());
- Assert.assertEquals(userId, vXGroup.getId());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test19ModifyGroupsVisibilitySetZero() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
Integer value = 0;
groupVisibilityMap.put(userId, value);
-
+
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
+ vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
+
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(value, vXGroup.getIsVisible());
- Assert.assertEquals(userId, vXGroup.getId());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test20ModifyGroupsVisibilitySetEmpty() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
groupVisibilityMap.put(userId, emptyValue);
-
+
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
+ vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
+
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(emptyValue, vXGroup.getIsVisible());
- Assert.assertEquals(userId, vXGroup.getId());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test21createXGroupUser() {
VXGroupUser vxGroupUser = new VXGroupUser();
@@ -390,14 +496,15 @@ public class TestXUserMgr {
Assert.assertEquals(dbVXGroupUser.getUserId(), vxGroupUser.getUserId());
Assert.assertEquals(dbVXGroupUser.getUpdatedBy(),
vxGroupUser.getUpdatedBy());
- Mockito.verify(xGroupUserService).createXGroupUserWithOutLogin(vxGroupUser);
+ Mockito.verify(xGroupUserService).createXGroupUserWithOutLogin(
+ vxGroupUser);
Mockito.when(xGroupUserService.readResourceWithOutLogin(userId))
.thenReturn(vxGroupUser);
VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
+ vXGroup.setId(userId);
+ vXGroup.setDescription("group test");
+ vXGroup.setName("grouptest");
VXGroupUser dbvxGroupUser = xUserMgr.getXGroupUser(userId);
Assert.assertNotNull(dbvxGroupUser);
@@ -408,7 +515,7 @@ public class TestXUserMgr {
Assert.assertEquals(dbvxGroupUser.getUserId(), vxGroupUser.getUserId());
Assert.assertEquals(dbvxGroupUser.getUpdatedBy(),
vxGroupUser.getUpdatedBy());
- Mockito.verify(xGroupUserService).readResourceWithOutLogin(userId);
+ Mockito.verify(xGroupUserService).readResourceWithOutLogin(userId);
}
@Test
@@ -419,7 +526,8 @@ public class TestXUserMgr {
@Test
public void test23GetXGroupUsers() {
- VXUserList dbVXUserList = xUserMgr.getXGroupUsers(userId);VXGroup vXGroup = new VXGroup();
+ VXUserList dbVXUserList = xUserMgr.getXGroupUsers(userId);
+ VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
@@ -440,16 +548,16 @@ public class TestXUserMgr {
Assert.assertEquals(userId, dbVXUser.getId());
Assert.assertEquals(dbVXUser.getName(), vxUser.getName());
Assert.assertEquals(dbVXUser.getOwner(), vxUser.getOwner());
- Mockito.verify(xUserService).getXUserByUserName(userName);
+ Mockito.verify(xUserService).getXUserByUserName(userName);
}
@Test
- public void test25CreateXUserWithOutLogin(){
+ public void test25CreateXUserWithOutLogin() {
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.createXUserWithOutLogin(vxUser))
- .thenReturn(vxUser);
-
+
+ Mockito.when(xUserService.createXUserWithOutLogin(vxUser)).thenReturn(
+ vxUser);
+
VXUser dbUser = xUserMgr.createXUserWithOutLogin(vxUser);
Assert.assertNotNull(dbUser);
userId = dbUser.getId();
@@ -459,29 +567,30 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
Assert.assertEquals(dbUser.getGroupNameList(),
vxUser.getGroupNameList());
- Mockito.verify(xUserService).createXUserWithOutLogin(vxUser);
+ Mockito.verify(xUserService).createXUserWithOutLogin(vxUser);
}
-
+
@Test
- public void test26CreateXGroupWithoutLogin(){
+ public void test26CreateXGroupWithoutLogin() {
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
-
+
Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup))
- .thenReturn(vXGroup);
-
- VXGroup dbVXGroup = xUserMgr.createXGroupWithoutLogin(vXGroup);
- Assert.assertNotNull(dbVXGroup);
+ .thenReturn(vXGroup);
+
+ VXGroup dbVXGroup = xUserMgr.createXGroupWithoutLogin(vXGroup);
+ Assert.assertNotNull(dbVXGroup);
userId = dbVXGroup.getId();
Assert.assertEquals(userId, dbVXGroup.getId());
- Assert.assertEquals(vXGroup.getDescription(), dbVXGroup.getDescription());
+ Assert.assertEquals(vXGroup.getDescription(),
+ dbVXGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbVXGroup.getName());
- Mockito.verify(xGroupService).createXGroupWithOutLogin(vXGroup);
+ Mockito.verify(xGroupService).createXGroupWithOutLogin(vXGroup);
}
-
+
@Test
public void test27DeleteXGroup() {
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
@@ -497,7 +606,8 @@ public class TestXUserMgr {
Mockito.when(xxGroupDao.getById(userId)).thenReturn(xxGroup);
xUserMgr.deleteXGroup(userId, force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito.anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
}
@Test
@@ -515,8 +625,8 @@ public class TestXUserMgr {
Mockito.when(xxUserDao.remove(userId)).thenReturn(true);
xUserMgr.deleteXUser(userId, force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito
- .anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
Mockito.verify(daoManager).getXXGroupUser();
Mockito.verify(daoManager).getXXUser();
}
@@ -541,56 +651,479 @@ public class TestXUserMgr {
xUserMgr.deleteXGroupAndXUser(groupName, userName);
Mockito.verify(xGroupService).getGroupByGroupName(Mockito.anyString());
Mockito.verify(xUserService).getXUserByUserName(Mockito.anyString());
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito
- .anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
}
-
+
@Test
- public void test30CreateVXUserGroupInfo(){
-
+ public void test30CreateVXUserGroupInfo() {
+
VXUserGroupInfo vXUserGroupInfo = new VXUserGroupInfo();
VXUser vXUser = new VXUser();
vXUser.setName("user1");
vXUser.setDescription("testuser1 -added for unit testing");
-
+
List<VXGroupUser> vXGroupUserList = new ArrayList<VXGroupUser>();
List<VXGroup> vXGroupList = new ArrayList<VXGroup>();
-
+
final VXGroup vXGroup1 = new VXGroup();
vXGroup1.setName("users");
vXGroup1.setDescription("users -added for unit testing");
vXGroupList.add(vXGroup1);
-
+
VXGroupUser vXGroupUser1 = new VXGroupUser();
vXGroupUser1.setName("users");
vXGroupUserList.add(vXGroupUser1);
-
+
final VXGroup vXGroup2 = new VXGroup();
vXGroup2.setName("user1");
vXGroup2.setDescription("user1 -added for unit testing");
vXGroupList.add(vXGroup2);
-
+
VXGroupUser vXGroupUser2 = new VXGroupUser();
vXGroupUser2.setName("user1");
vXGroupUserList.add(vXGroupUser2);
-
+
vXUserGroupInfo.setXuserInfo(vXUser);
vXUserGroupInfo.setXgroupInfo(vXGroupList);
-
- Mockito.when(xUserService.createXUserWithOutLogin(vXUser)).thenReturn(vXUser);
- Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup1)).thenReturn(vXGroup1);
- Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup2)).thenReturn(vXGroup2);
- Mockito.when(xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser1)).thenReturn(vXGroupUser1);
- Mockito.when(xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser2)).thenReturn(vXGroupUser2);
-
- VXUserGroupInfo vxUserGroupTest = xUserMgr.createXUserGroupFromMap(vXUserGroupInfo);
- Assert.assertEquals("user1", vxUserGroupTest
- .getXuserInfo()
- .getName());
+
+ Mockito.when(xUserService.createXUserWithOutLogin(vXUser)).thenReturn(
+ vXUser);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup1))
+ .thenReturn(vXGroup1);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup2))
+ .thenReturn(vXGroup2);
+ Mockito.when(
+ xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser1))
+ .thenReturn(vXGroupUser1);
+ Mockito.when(
+ xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser2))
+ .thenReturn(vXGroupUser2);
+
+ VXUserGroupInfo vxUserGroupTest = xUserMgr
+ .createXUserGroupFromMap(vXUserGroupInfo);
+ Assert.assertEquals("user1", vxUserGroupTest.getXuserInfo().getName());
List<VXGroup> result = vxUserGroupTest.getXgroupInfo();
List<VXGroup> expected = new ArrayList<VXGroup>();
expected.add(vXGroup1);
expected.add(vXGroup2);
Assert.assertTrue(result.containsAll(expected));
- }
-}
\ No newline at end of file
+ }
+
+ // Module permission
+ @Test
+ public void test31createXModuleDefPermission() {
+ VXModuleDef vXModuleDef = vXModuleDef();
+
+ Mockito.when(xModuleDefService.createResource(vXModuleDef)).thenReturn(
+ vXModuleDef);
+
+ VXModuleDef dbMuduleDef = xUserMgr
+ .createXModuleDefPermission(vXModuleDef);
+ Assert.assertNotNull(dbMuduleDef);
+ Assert.assertEquals(dbMuduleDef, vXModuleDef);
+ Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
+ Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
+ vXModuleDef.getUpdatedBy());
+ Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
+ Assert.assertEquals(dbMuduleDef.getAddedById(),
+ vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),
+ vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),
+ vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),
+ vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),
+ vXModuleDef.getGroupPermList());
+ Mockito.verify(xModuleDefService).createResource(vXModuleDef);
+ }
+
+ @Test
+ public void test32getXModuleDefPermission() {
+ VXModuleDef vXModuleDef = vXModuleDef();
+
+ Mockito.when(xModuleDefService.readResource(1L))
+ .thenReturn(vXModuleDef);
+
+ VXModuleDef dbMuduleDef = xUserMgr.getXModuleDefPermission(1L);
+ Assert.assertNotNull(dbMuduleDef);
+ Assert.assertEquals(dbMuduleDef, vXModuleDef);
+ Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
+ Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
+ vXModuleDef.getUpdatedBy());
+ Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
+ Assert.assertEquals(dbMuduleDef.getAddedById(),
+ vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),
+ vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),
+ vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),
+ vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),
+ vXModuleDef.getGroupPermList());
+
+ Mockito.verify(xModuleDefService).readResource(1L);
+ }
+
+ @Test
+ public void test33updateXModuleDefPermission() {
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
+
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXUserPermission xUserPermission = Mockito.mock(XXUserPermission.class);
+
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
+ XXGroupPermission xGroupPermission = Mockito
+ .mock(XXGroupPermission.class);
+
+ VXUserPermission vXUserPermission = vXUserPermission();
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+ VXModuleDef vXModuleDef = vXModuleDef();
+
+ Mockito.when(xModuleDefService.updateResource(vXModuleDef)).thenReturn(
+ vXModuleDef);
+ Mockito.when(xGroupPermissionService.updateResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+ Mockito.when(xGroupPermissionService.createResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+ Mockito.when(xUserPermissionService.updateResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+ Mockito.when(xUserPermissionService.createResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
+ Mockito.when(xModuleDefDao.getById(userId)).thenReturn(xModuleDef);
+ Mockito.when(xModuleDefService.populateViewBean(xModuleDef))
+ .thenReturn(vXModuleDef);
+
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(
+ xUserPermissionDao);
+ Mockito.when(xUserPermissionDao.getById(userId)).thenReturn(
+ xUserPermission);
+ Mockito.when(xUserPermissionService.populateViewBean(xUserPermission))
+ .thenReturn(vXUserPermission);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(xGroupPermissionDao.getById(userId)).thenReturn(
+ xGroupPermission);
+ Mockito.when(xGroupPermissionService.populateViewBean(xGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ VXModuleDef dbMuduleDef = xUserMgr
+ .updateXModuleDefPermission(vXModuleDef);
+ Assert.assertEquals(dbMuduleDef, vXModuleDef);
+ Assert.assertNotNull(dbMuduleDef);
+ Assert.assertEquals(dbMuduleDef, vXModuleDef);
+ Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
+ Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
+ vXModuleDef.getUpdatedBy());
+ Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
+ Assert.assertEquals(dbMuduleDef.getAddedById(),
+ vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),
+ vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),
+ vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),
+ vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),
+ vXModuleDef.getGroupPermList());
+
+ Mockito.verify(xModuleDefService).updateResource(vXModuleDef);
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(xModuleDefService).populateViewBean(xModuleDef);
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
+ }
+
+ @Test
+ public void test34deleteXModuleDefPermission() {
+
+ Mockito.when(xModuleDefService.deleteResource(1L)).thenReturn(true);
+ xUserMgr.deleteXModuleDefPermission(1L, true);
+ Mockito.verify(xModuleDefService).deleteResource(1L);
+ }
+
+ @Test
+ public void test35createXUserPermission() {
+ VXUserPermission vXUserPermission = vXUserPermission();
+
+ Mockito.when(xUserPermissionService.createResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+
+ VXUserPermission dbUserPermission = xUserMgr
+ .createXUserPermission(vXUserPermission);
+ Assert.assertNotNull(dbUserPermission);
+ Assert.assertEquals(dbUserPermission, vXUserPermission);
+ Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
+ Assert.assertEquals(dbUserPermission.getOwner(),
+ vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),
+ vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),
+ vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),
+ vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),
+ vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),
+ vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),
+ vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),
+ vXUserPermission.getUserId());
+
+ Mockito.verify(xUserPermissionService).createResource(vXUserPermission);
+ }
+
+ @Test
+ public void test36getXUserPermission() {
+ VXUserPermission vXUserPermission = vXUserPermission();
+
+ Mockito.when(xUserPermissionService.readResource(1L)).thenReturn(
+ vXUserPermission);
+
+ VXUserPermission dbUserPermission = xUserMgr.getXUserPermission(1L);
+ Assert.assertNotNull(dbUserPermission);
+ Assert.assertEquals(dbUserPermission, vXUserPermission);
+ Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
+ Assert.assertEquals(dbUserPermission.getOwner(),
+ vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),
+ vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),
+ vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),
+ vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),
+ vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),
+ vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),
+ vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),
+ vXUserPermission.getUserId());
+
+ Mockito.verify(xUserPermissionService).readResource(1L);
+ }
+
+ @Test
+ public void test37updateXUserPermission() {
+ VXUserPermission vXUserPermission = vXUserPermission();
+
+ Mockito.when(xUserPermissionService.updateResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+
+ VXUserPermission dbUserPermission = xUserMgr
+ .updateXUserPermission(vXUserPermission);
+ Assert.assertNotNull(dbUserPermission);
+ Assert.assertEquals(dbUserPermission, vXUserPermission);
+ Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
+ Assert.assertEquals(dbUserPermission.getOwner(),
+ vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),
+ vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),
+ vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),
+ vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),
+ vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),
+ vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),
+ vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),
+ vXUserPermission.getUserId());
+
+ Mockito.verify(xUserPermissionService).updateResource(vXUserPermission);
+ }
+
+ @Test
+ public void test38deleteXUserPermission() {
+
+ Mockito.when(xUserPermissionService.deleteResource(1L))
+ .thenReturn(true);
+ xUserMgr.deleteXUserPermission(1L, true);
+ Mockito.verify(xUserPermissionService).deleteResource(1L);
+ }
+
+ @Test
+ public void test39createXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+
+ Mockito.when(xGroupPermissionService.createResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ VXGroupPermission dbGroupPermission = xUserMgr
+ .createXGroupPermission(vXGroupPermission);
+ Assert.assertNotNull(dbGroupPermission);
+ Assert.assertEquals(dbGroupPermission, vXGroupPermission);
+ Assert.assertEquals(dbGroupPermission.getId(),
+ vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),
+ vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),
+ vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
+ vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),
+ vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),
+ vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),
+ vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),
+ vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),
+ vXGroupPermission.getUpdateDate());
+
+ Mockito.verify(xGroupPermissionService).createResource(
+ vXGroupPermission);
+ }
+
+ @Test
+ public void test40getXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+
+ Mockito.when(xGroupPermissionService.readResource(1L)).thenReturn(
+ vXGroupPermission);
+
+ VXGroupPermission dbGroupPermission = xUserMgr.getXGroupPermission(1L);
+ Assert.assertNotNull(dbGroupPermission);
+ Assert.assertEquals(dbGroupPermission, vXGroupPermission);
+ Assert.assertEquals(dbGroupPermission.getId(),
+ vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),
+ vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),
+ vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
+ vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),
+ vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),
+ vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),
+ vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),
+ vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),
+ vXGroupPermission.getUpdateDate());
+
+ Mockito.verify(xGroupPermissionService).readResource(1L);
+ }
+
+ @Test
+ public void test41updateXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+
+ Mockito.when(xGroupPermissionService.updateResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ VXGroupPermission dbGroupPermission = xUserMgr
+ .updateXGroupPermission(vXGroupPermission);
+ Assert.assertNotNull(dbGroupPermission);
+ Assert.assertEquals(dbGroupPermission, vXGroupPermission);
+ Assert.assertEquals(dbGroupPermission.getId(),
+ vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),
+ vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),
+ vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
+ vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),
+ vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),
+ vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),
+ vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),
+ vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),
+ vXGroupPermission.getUpdateDate());
+
+ Mockito.verify(xGroupPermissionService).updateResource(
+ vXGroupPermission);
+ }
+
+ @Test
+ public void test42deleteXGroupPermission() {
+
+ Mockito.when(xGroupPermissionService.deleteResource(1L)).thenReturn(
+ true);
+ xUserMgr.deleteXGroupPermission(1L, true);
+ Mockito.verify(xGroupPermissionService).deleteResource(1L);
+ }
+
+ @Test
+ public void test43updateExistingUserExisting() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ VXPortalUser vXPortalUser = Mockito.mock(VXPortalUser.class);
+ XXPortalUser xXPortalUser = Mockito.mock(XXPortalUser.class);
+ List<XXPortalUser> portalUserList = new ArrayList<XXPortalUser>();
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.findAllXPortalUser()).thenReturn(
+ portalUserList);
+ Mockito.when(xPortalUserService.populateViewBean(xXPortalUser))
+ .thenReturn(vXPortalUser);
+ List<VXPortalUser> vObj = xUserMgr.updateExistingUserExisting();
+ Assert.assertNotNull(vObj);
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xPortalUserDao).findAllXPortalUser();
+ }
+
+ @Test
+ public void test44checkPermissionRoleByGivenUrls() {
+ XXModuleDefDao value = Mockito.mock(XXModuleDefDao.class);
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito
+ .mock(XXPortalUserRoleDao.class);
+
+ List<String> lsvalue = new ArrayList<String>();
+ List<XXPortalUserRole> xPortalUserRolesList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole xPortalUserRole = new XXPortalUserRole();
+ xPortalUserRole.setAddedByUserId(userId);
+ xPortalUserRole.setCreateTime(new Date());
+ xPortalUserRole.setId(userId);
+ xPortalUserRole.setStatus(0);
+ xPortalUserRole.setUpdatedByUserId(userId);
+ xPortalUserRole.setUserId(userId);
+ xPortalUserRole.setUserRole("admin");
+ xPortalUserRolesList.add(xPortalUserRole);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(value);
+ Mockito.when(value.findModuleURLOfPemittedModules(null)).thenReturn(
+ lsvalue);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
+ xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByUserId(null)).thenReturn(
+ xPortalUserRolesList);
+ String enteredURL = "";
+ String method = "";
+ xUserMgr.checkPermissionRoleByGivenUrls(enteredURL, method);
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(value).findModuleURLOfPemittedModules(null);
+ Mockito.verify(daoManager).getXXPortalUserRole();
+ Mockito.verify(xPortalUserRoleDao).findByUserId(null);
+ }
+
+ @Test
+ public void test45getGroupsForUser() {
+ VXUser vxUser = vxUser();
+ String userName = "test";
+ Mockito.when(xUserService.getXUserByUserName(userName)).thenReturn(
+ vxUser);
+ Set<String> list = xUserMgr.getGroupsForUser(userName);
+ Assert.assertNotNull(list);
+ Mockito.verify(xUserService).getXUserByUserName(userName);
+ }
+}
[2/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
Posted by ve...@apache.org.
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("test@gmail.com");
+ 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("test@gmail.com");
+ 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("test@gmail.com");
+ 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("test@gmail.com");
+ 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("test@gmail.com");
+ 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("test@gmail.com");
+ 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);
+ }
+}
[5/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
Posted by ve...@apache.org.
RANGER-203 : Add unit test cases for Pluggable Service model
Signed-off-by: Velmurugan Periasamy <ve...@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/376d3249
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ranger/tree/376d3249
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ranger/diff/376d3249
Branch: refs/heads/master
Commit: 376d32497487b38d2d0a34f31e96c28d3068a2dd
Parents: d673e59
Author: Gautam Borad <gb...@gmail.com>
Authored: Thu Apr 9 23:34:26 2015 +0530
Committer: Velmurugan Periasamy <ve...@apache.org>
Committed: Thu Apr 9 14:49:14 2015 -0400
----------------------------------------------------------------------
.../apache/ranger/biz/TestServiceDBStore.java | 1835 ++++++++++++++++++
.../java/org/apache/ranger/biz/TestUserMgr.java | 411 +++-
.../org/apache/ranger/biz/TestXUserMgr.java | 727 ++++++-
.../org/apache/ranger/rest/TestServiceREST.java | 872 +++++++++
.../ranger/service/TestRangerPolicyService.java | 1007 ++++++++++
.../service/TestRangerPolicyServiceBase.java | 275 +++
.../service/TestRangerServiceDefService.java | 792 ++++++++
.../TestRangerServiceDefServiceBase.java | 810 ++++++++
.../service/TestRangerServiceService.java | 419 ++++
.../service/TestRangerServiceServiceBase.java | 221 +++
10 files changed, 7206 insertions(+), 163 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/security-admin/src/test/java/org/apache/ranger/biz/TestServiceDBStore.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/biz/TestServiceDBStore.java b/security-admin/src/test/java/org/apache/ranger/biz/TestServiceDBStore.java
new file mode 100644
index 0000000..3ba1e17
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/biz/TestServiceDBStore.java
@@ -0,0 +1,1835 @@
+/*
+ * 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.biz;
+
+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.StringUtil;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXAccessTypeDefDao;
+import org.apache.ranger.db.XXAccessTypeDefGrantsDao;
+import org.apache.ranger.db.XXContextEnricherDefDao;
+import org.apache.ranger.db.XXDataHistDao;
+import org.apache.ranger.db.XXEnumDefDao;
+import org.apache.ranger.db.XXEnumElementDefDao;
+import org.apache.ranger.db.XXPolicyConditionDefDao;
+import org.apache.ranger.db.XXPolicyDao;
+import org.apache.ranger.db.XXPolicyItemAccessDao;
+import org.apache.ranger.db.XXPolicyItemConditionDao;
+import org.apache.ranger.db.XXPolicyItemDao;
+import org.apache.ranger.db.XXPolicyItemGroupPermDao;
+import org.apache.ranger.db.XXPolicyItemUserPermDao;
+import org.apache.ranger.db.XXPolicyResourceDao;
+import org.apache.ranger.db.XXPolicyResourceMapDao;
+import org.apache.ranger.db.XXResourceDefDao;
+import org.apache.ranger.db.XXServiceConfigDefDao;
+import org.apache.ranger.db.XXServiceConfigMapDao;
+import org.apache.ranger.db.XXServiceDao;
+import org.apache.ranger.db.XXServiceDefDao;
+import org.apache.ranger.db.XXUserDao;
+import org.apache.ranger.entity.XXAccessTypeDef;
+import org.apache.ranger.entity.XXAccessTypeDefGrants;
+import org.apache.ranger.entity.XXContextEnricherDef;
+import org.apache.ranger.entity.XXDBBase;
+import org.apache.ranger.entity.XXDataHist;
+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.XXPolicyItemGroupPerm;
+import org.apache.ranger.entity.XXPolicyItemUserPerm;
+import org.apache.ranger.entity.XXPolicyResource;
+import org.apache.ranger.entity.XXPolicyResourceMap;
+import org.apache.ranger.entity.XXResourceDef;
+import org.apache.ranger.entity.XXService;
+import org.apache.ranger.entity.XXServiceConfigDef;
+import org.apache.ranger.entity.XXServiceConfigMap;
+import org.apache.ranger.entity.XXServiceDef;
+import org.apache.ranger.entity.XXTrxLog;
+import org.apache.ranger.entity.XXUser;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.model.RangerService;
+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.plugin.util.ServicePolicies;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.service.RangerAuditFields;
+import org.apache.ranger.service.RangerDataHistService;
+import org.apache.ranger.service.RangerPolicyService;
+import org.apache.ranger.service.RangerServiceDefService;
+import org.apache.ranger.service.RangerServiceService;
+import org.apache.ranger.service.RangerServiceWithAssignedIdService;
+import org.apache.ranger.service.XUserService;
+import org.apache.ranger.view.RangerPolicyList;
+import org.apache.ranger.view.RangerServiceDefList;
+import org.apache.ranger.view.RangerServiceList;
+import org.apache.ranger.view.VXString;
+import org.apache.ranger.view.VXUser;
+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 TestServiceDBStore {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ ServiceDBStore serviceDBStore = new ServiceDBStore();
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ RangerServiceService svcService;
+
+ @Mock
+ RangerDataHistService dataHistService;
+
+ @Mock
+ RangerServiceDefService serviceDefService;
+
+ @Mock
+ RangerPolicyService policyService;
+
+ @Mock
+ StringUtil stringUtil;
+
+ @Mock
+ XUserService xUserService;
+
+ @Mock
+ XUserMgr xUserMgr;
+
+ @Mock
+ RangerAuditFields<XXDBBase> rangerAuditFields;
+
+ @Mock
+ ContextUtil contextUtil;
+
+ @Mock
+ RangerBizUtil bizUtil;
+
+ @Mock
+ RangerServiceWithAssignedIdService svcServiceWithAssignedId;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ public void setup() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerServiceDef rangerServiceDef() {
+ List<RangerServiceConfigDef> configs = new ArrayList<RangerServiceConfigDef>();
+ List<RangerResourceDef> resources = new ArrayList<RangerResourceDef>();
+ List<RangerAccessTypeDef> accessTypes = new ArrayList<RangerAccessTypeDef>();
+ List<RangerPolicyConditionDef> policyConditions = new ArrayList<RangerPolicyConditionDef>();
+ List<RangerContextEnricherDef> contextEnrichers = new ArrayList<RangerContextEnricherDef>();
+ List<RangerEnumDef> enums = new ArrayList<RangerEnumDef>();
+
+ RangerServiceDef rangerServiceDef = new RangerServiceDef();
+ rangerServiceDef.setId(Id);
+ rangerServiceDef.setImplClass("RangerServiceHdfs");
+ rangerServiceDef.setLabel("HDFS Repository");
+ rangerServiceDef.setDescription("HDFS Repository");
+ rangerServiceDef.setRbKeyDescription(null);
+ rangerServiceDef.setUpdatedBy("Admin");
+ rangerServiceDef.setUpdateTime(new Date());
+ rangerServiceDef.setConfigs(configs);
+ rangerServiceDef.setResources(resources);
+ rangerServiceDef.setAccessTypes(accessTypes);
+ rangerServiceDef.setPolicyConditions(policyConditions);
+ rangerServiceDef.setContextEnrichers(contextEnrichers);
+ rangerServiceDef.setEnums(enums);
+
+ return rangerServiceDef;
+ }
+
+ private RangerService rangerService() {
+ Map<String, String> configs = new HashMap<String, String>();
+ configs.put("username", "servicemgr");
+ configs.put("password", "servicemgr");
+ configs.put("namenode", "servicemgr");
+ configs.put("hadoop.security.authorization", "No");
+ configs.put("hadoop.security.authentication", "Simple");
+ configs.put("hadoop.security.auth_to_local", "");
+ configs.put("dfs.datanode.kerberos.principal", "");
+ configs.put("dfs.namenode.kerberos.principal", "");
+ configs.put("dfs.secondary.namenode.kerberos.principal", "");
+ configs.put("hadoop.rpc.protection", "Privacy");
+ configs.put("commonNameForCertificate", "");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(Id);
+ rangerService.setConfigs(configs);
+ rangerService.setCreateTime(new Date());
+ rangerService.setDescription("service policy");
+ rangerService.setGuid("1427365526516_835_0");
+ rangerService.setIsEnabled(true);
+ rangerService.setName("HDFS_1");
+ rangerService.setPolicyUpdateTime(new Date());
+ rangerService.setType("1");
+ rangerService.setUpdatedBy("Admin");
+ rangerService.setUpdateTime(new Date());
+
+ return rangerService;
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+
+ return policy;
+ }
+
+ @Test
+ public void test11createServiceDef() throws Exception {
+
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXResourceDefDao xResourceDefDao = Mockito.mock(XXResourceDefDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXAccessTypeDefDao xAccessTypeDefDao = Mockito
+ .mock(XXAccessTypeDefDao.class);
+ XXAccessTypeDefGrantsDao xAccessTypeDefGrantsDao = Mockito
+ .mock(XXAccessTypeDefGrantsDao.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 xServiceDef = Mockito.mock(XXServiceDef.class);
+ XXResourceDef xResourceDef = Mockito.mock(XXResourceDef.class);
+ XXServiceConfigDef xServiceConfigDef = Mockito
+ .mock(XXServiceConfigDef.class);
+ XXPolicyConditionDef xPolicyConditionDef = Mockito
+ .mock(XXPolicyConditionDef.class);
+ XXContextEnricherDef xContextEnricherDef = Mockito
+ .mock(XXContextEnricherDef.class);
+ XXEnumDef xEnumDef = Mockito.mock(XXEnumDef.class);
+ XXAccessTypeDef xAccessTypeDef = Mockito.mock(XXAccessTypeDef.class);
+ XXEnumElementDef xEnumElementDef = Mockito.mock(XXEnumElementDef.class);
+ XXAccessTypeDefGrants xAccessTypeDefGrants = Mockito
+ .mock(XXAccessTypeDefGrants.class);
+
+ RangerServiceConfigDef rangerServiceConfigDef = Mockito
+ .mock(RangerServiceConfigDef.class);
+ RangerResourceDef rangerResourceDef = Mockito
+ .mock(RangerResourceDef.class);
+ RangerAccessTypeDef rangerAccessTypeDef = Mockito
+ .mock(RangerAccessTypeDef.class);
+ RangerPolicyConditionDef rangerPolicyConditionDef = Mockito
+ .mock(RangerPolicyConditionDef.class);
+ RangerContextEnricherDef rangerContextEnricherDef = Mockito
+ .mock(RangerContextEnricherDef.class);
+ RangerEnumDef rangerEnumDef = Mockito.mock(RangerEnumDef.class);
+ RangerEnumElementDef rangerEnumElementDef = Mockito
+ .mock(RangerEnumElementDef.class);
+
+ RangerServiceDef serviceDef = new RangerServiceDef();
+ Mockito.when(serviceDefService.create(serviceDef)).thenReturn(
+ serviceDef);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName("HDFS_1")).thenReturn(
+ xServiceDef);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.getById(null)).thenReturn(xServiceDef);
+
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerServiceConfigDefToXX(
+ rangerServiceConfigDef, xServiceConfigDef, xServiceDef , 1))
+ .thenReturn(xServiceConfigDef);
+ Mockito.when(xServiceConfigDefDao.create(xServiceConfigDef))
+ .thenReturn(xServiceConfigDef);
+
+ Mockito.when(daoManager.getXXResourceDef()).thenReturn(xResourceDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerResourceDefToXX(
+ rangerResourceDef, xResourceDef, xServiceDef, 1))
+ .thenReturn(xResourceDef);
+ Mockito.when(xResourceDefDao.create(xResourceDef)).thenReturn(
+ xResourceDef);
+
+ Mockito.when(daoManager.getXXAccessTypeDef()).thenReturn(
+ xAccessTypeDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerAccessTypeDefToXX(
+ rangerAccessTypeDef, xAccessTypeDef, xServiceDef, 1))
+ .thenReturn(xAccessTypeDef);
+ Mockito.when(xAccessTypeDefDao.create(xAccessTypeDef)).thenReturn(
+ xAccessTypeDef);
+
+ Mockito.when(daoManager.getXXAccessTypeDefGrants()).thenReturn(
+ xAccessTypeDefGrantsDao);
+ Mockito.when(xAccessTypeDefGrantsDao.create(xAccessTypeDefGrants))
+ .thenReturn(xAccessTypeDefGrants);
+
+ Mockito.when(daoManager.getXXPolicyConditionDef()).thenReturn(
+ xPolicyConditionDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerPolicyConditionDefToXX(
+ rangerPolicyConditionDef, xPolicyConditionDef,
+ xServiceDef, 1)).thenReturn(xPolicyConditionDef);
+ Mockito.when(xPolicyConditionDefDao.create(xPolicyConditionDef))
+ .thenReturn(xPolicyConditionDef);
+
+ Mockito.when(daoManager.getXXContextEnricherDef()).thenReturn(
+ xContextEnricherDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerContextEnricherDefToXX(
+ rangerContextEnricherDef, xContextEnricherDef,
+ xServiceDef, 1)).thenReturn(xContextEnricherDef);
+ Mockito.when(xContextEnricherDefDao.create(xContextEnricherDef))
+ .thenReturn(xContextEnricherDef);
+
+ Mockito.when(daoManager.getXXEnumDef()).thenReturn(xEnumDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerEnumDefToXX(rangerEnumDef,
+ xEnumDef, xServiceDef ,1)).thenReturn(xEnumDef);
+ Mockito.when(xEnumDefDao.create(xEnumDef)).thenReturn(xEnumDef);
+
+ Mockito.when(daoManager.getXXEnumElementDef()).thenReturn(
+ xEnumElementDefDao);
+ Mockito.when(
+ serviceDefService.populateRangerEnumElementDefToXX(
+ rangerEnumElementDef, xEnumElementDef, xEnumDef, 1))
+ .thenReturn(xEnumElementDef);
+ Mockito.when(xEnumElementDefDao.create(xEnumElementDef)).thenReturn(
+ xEnumElementDef);
+
+ Mockito.when(serviceDefService.getPopulatedViewObject(xServiceDef))
+ .thenReturn(serviceDef);
+
+ RangerServiceDef dbServiceDef = serviceDBStore
+ .createServiceDef(serviceDef);
+ Assert.assertNotNull(dbServiceDef);
+ Assert.assertEquals(dbServiceDef, serviceDef);
+ Assert.assertEquals(dbServiceDef.getId(), serviceDef.getId());
+ Assert.assertEquals(dbServiceDef.getCreatedBy(),
+ serviceDef.getCreatedBy());
+ Assert.assertEquals(dbServiceDef.getDescription(),
+ serviceDef.getDescription());
+ Assert.assertEquals(dbServiceDef.getGuid(), serviceDef.getGuid());
+ Assert.assertEquals(dbServiceDef.getImplClass(),
+ serviceDef.getImplClass());
+ Assert.assertEquals(dbServiceDef.getLabel(), serviceDef.getLabel());
+ Assert.assertEquals(dbServiceDef.getName(), serviceDef.getName());
+ Assert.assertEquals(dbServiceDef.getRbKeyDescription(),
+ serviceDef.getRbKeyDescription());
+ Assert.assertEquals(dbServiceDef.getRbKeyLabel(), serviceDef.getLabel());
+ Assert.assertEquals(dbServiceDef.getConfigs(), serviceDef.getConfigs());
+ Assert.assertEquals(dbServiceDef.getVersion(), serviceDef.getVersion());
+ Assert.assertEquals(dbServiceDef.getResources(),
+ serviceDef.getResources());
+ Mockito.verify(serviceDefService).getPopulatedViewObject(xServiceDef);
+ Mockito.verify(serviceDefService).create(serviceDef);
+ Mockito.verify(daoManager).getXXServiceConfigDef();
+ Mockito.verify(daoManager).getXXEnumDef();
+ Mockito.verify(daoManager).getXXAccessTypeDef();
+ }
+
+ @Test
+ public void test12updateServiceDef() throws Exception {
+ RangerServiceDef serviceDef = rangerServiceDef();
+ RangerServiceDef dbServiceDef = serviceDBStore
+ .updateServiceDef(serviceDef);
+ Assert.assertNull(dbServiceDef);
+ }
+
+ @Test
+ public void test13deleteServiceDef() throws Exception {
+ serviceDBStore.deleteServiceDef(Id);
+ }
+
+ @Test
+ public void test14getServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(serviceDefService.read(Id)).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = serviceDBStore.getServiceDef(Id);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(), rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getCreatedBy(),
+ rangerServiceDef.getCreatedBy());
+ Assert.assertEquals(dbRangerServiceDef.getDescription(),
+ rangerServiceDef.getDescription());
+ Assert.assertEquals(dbRangerServiceDef.getGuid(), rangerServiceDef.getGuid());
+ Assert.assertEquals(dbRangerServiceDef.getImplClass(),
+ rangerServiceDef.getImplClass());
+ Assert.assertEquals(dbRangerServiceDef.getLabel(), rangerServiceDef.getLabel());
+ Assert.assertEquals(dbRangerServiceDef.getName(), rangerServiceDef.getName());
+ Assert.assertEquals(dbRangerServiceDef.getRbKeyDescription(),
+ rangerServiceDef.getRbKeyDescription());
+ Assert.assertEquals(dbRangerServiceDef.getConfigs(), rangerServiceDef.getConfigs());
+ Assert.assertEquals(dbRangerServiceDef.getVersion(), rangerServiceDef.getVersion());
+ Assert.assertEquals(dbRangerServiceDef.getResources(),
+ rangerServiceDef.getResources());
+ Mockito.verify(serviceDefService).read(Id);
+ }
+
+ @Test
+ public void test15getServiceDefByName() throws Exception {
+ String name = "fdfdfds";
+
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(name)).thenReturn(xServiceDef);
+
+ RangerServiceDef dbServiceDef = serviceDBStore
+ .getServiceDefByName(name);
+ Assert.assertNull(dbServiceDef);
+ Mockito.verify(daoManager).getXXServiceDef();
+ }
+
+ @Test
+ public void test16getServiceDefByNameNotNull() throws Exception {
+ String name = "fdfdfds";
+
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+
+ RangerServiceDef serviceDef = new RangerServiceDef();
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(name)).thenReturn(xServiceDef);
+ Mockito.when(serviceDefService.getPopulatedViewObject(xServiceDef))
+ .thenReturn(serviceDef);
+
+ RangerServiceDef dbServiceDef = serviceDBStore
+ .getServiceDefByName(name);
+ Assert.assertNotNull(dbServiceDef);
+ Mockito.verify(daoManager).getXXServiceDef();
+ }
+
+ @Test
+ public void test17getServiceDefs() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ List<RangerServiceDef> serviceDefsList = new ArrayList<RangerServiceDef>();
+ RangerServiceDef serviceDef = rangerServiceDef();
+ serviceDefsList.add(serviceDef);
+ RangerServiceDefList serviceDefList = new RangerServiceDefList();
+ serviceDefList.setPageSize(0);
+ serviceDefList.setResultSize(1);
+ serviceDefList.setSortBy("asc");
+ serviceDefList.setSortType("1");
+ serviceDefList.setStartIndex(0);
+ serviceDefList.setTotalCount(10);
+ serviceDefList.setServiceDefs(serviceDefsList);
+ Mockito.when(serviceDefService.searchRangerServiceDefs(filter))
+ .thenReturn(serviceDefList);
+
+ List<RangerServiceDef> dbServiceDef = serviceDBStore
+ .getServiceDefs(filter);
+ Assert.assertNotNull(dbServiceDef);
+ Assert.assertEquals(dbServiceDef, serviceDefsList);
+ Assert.assertEquals(dbServiceDef.get(0), serviceDefsList.get(0));
+ Mockito.verify(serviceDefService).searchRangerServiceDefs(filter);
+ }
+
+ @Test
+ public void test18getPaginatedServiceDefs() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ List<RangerServiceDef> serviceDefsList = new ArrayList<RangerServiceDef>();
+ RangerServiceDef serviceDef = rangerServiceDef();
+ serviceDefsList.add(serviceDef);
+ RangerServiceDefList serviceDefList = new RangerServiceDefList();
+ serviceDefList.setPageSize(0);
+ serviceDefList.setResultSize(1);
+ serviceDefList.setSortBy("asc");
+ serviceDefList.setSortType("1");
+ serviceDefList.setStartIndex(0);
+ serviceDefList.setTotalCount(10);
+ serviceDefList.setServiceDefs(serviceDefsList);
+ Mockito.when(serviceDefService.searchRangerServiceDefs(filter))
+ .thenReturn(serviceDefList);
+
+ RangerServiceDefList dbServiceDefList = serviceDBStore
+ .getPaginatedServiceDefs(filter);
+ Assert.assertNotNull(dbServiceDefList);
+ Assert.assertEquals(dbServiceDefList, serviceDefList);
+ Assert.assertEquals(dbServiceDefList.getList(),
+ serviceDefList.getList());
+ Assert.assertEquals(dbServiceDefList.getServiceDefs(),
+ serviceDefList.getServiceDefs());
+ Mockito.verify(serviceDefService).searchRangerServiceDefs(filter);
+ }
+
+ /*@Test
+ public void test19createService() throws Exception {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ RangerService rangerService = rangerService();
+ VXUser vXUser = null;
+ String userName = "admin";
+
+ List<XXServiceConfigDef> svcConfDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ serviceConfigDefObj.setType("1");
+ svcConfDefList.add(serviceConfigDefObj);
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(xServiceConfigDefDao.findByServiceDefName(userName))
+ .thenReturn(svcConfDefList);
+
+ Mockito.when(svcService.create(rangerService))
+ .thenReturn(rangerService);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(rangerService.getId())).thenReturn(
+ xService);
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+
+ Mockito.when(stringUtil.getValidUserName(userName))
+ .thenReturn(userName);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(userName)).thenReturn(xUser);
+
+ Mockito.when(xUserService.populateViewBean(xUser)).thenReturn(vXUser);
+ Mockito.when(xUserMgr.createXUser(vXUser)).thenReturn(vXUser);
+
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ Mockito.when(rangerAuditFields.populateAuditFields(xConfMap, xService))
+ .thenReturn(xService);
+
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ serviceDBStore.setPopulateExistingBaseFields(true);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+
+ RangerService dbRangerService = serviceDBStore
+ .createService(rangerService);
+ serviceDBStore.setPopulateExistingBaseFields(false);
+ Assert.assertNotNull(dbRangerService);
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(daoManager).getXXServiceConfigMap();
+ }*/
+
+ @Test
+ public void test20updateService() throws Exception {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ VXUser vXUser = null;
+ RangerService rangerService = rangerService();
+ String name = "fdfdfds";
+
+ List<XXTrxLog> trxLogList = new ArrayList<XXTrxLog>();
+ XXTrxLog xTrxLogObj = new XXTrxLog();
+ xTrxLogObj.setAction("create");
+ xTrxLogObj.setAddedByUserId(Id);
+ xTrxLogObj.setAttributeName("User Role");
+ xTrxLogObj.setCreateTime(new Date());
+ xTrxLogObj.setId(Id);
+ xTrxLogObj.setNewValue("admin");
+ xTrxLogObj.setObjectClassType(0);
+ xTrxLogObj.setObjectId(1L);
+ xTrxLogObj.setParentObjectClassType(0);
+ xTrxLogObj.setParentObjectId(Id);
+ trxLogList.add(xTrxLogObj);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+
+ List<XXServiceConfigDef> xServiceConfigDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ xServiceConfigDefList.add(serviceConfigDefObj);
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(xServiceConfigDefDao.findByServiceDefName(name))
+ .thenReturn(xServiceConfigDefList);
+
+ Mockito.when(svcService.getTransactionLog(rangerService, xService, 0))
+ .thenReturn(trxLogList);
+
+ Mockito.when(svcService.update(rangerService))
+ .thenReturn(rangerService);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ List<XXServiceConfigMap> xConfMapList = 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());
+ xConfMapList.add(xConfMap);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(xServiceConfigMapDao.findByServiceId(Id)).thenReturn(
+ xConfMapList);
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(xServiceConfigMapDao.remove(xConfMap)).thenReturn(true);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(stringUtil.getValidUserName(name)).thenReturn(name);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(name)).thenReturn(xUser);
+
+ Mockito.when(xUserService.populateViewBean(xUser)).thenReturn(vXUser);
+ Mockito.when(xUserMgr.createXUser(vXUser)).thenReturn(vXUser);
+
+ Mockito.when(
+ (XXServiceConfigMap) rangerAuditFields.populateAuditFields(
+ xConfMap, xService)).thenReturn(xConfMap);
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ RangerService dbRangerService = serviceDBStore
+ .updateService(rangerService);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assert.assertEquals(dbRangerService.getCreatedBy(),
+ rangerService.getCreatedBy());
+ Assert.assertEquals(dbRangerService.getDescription(),
+ rangerService.getDescription());
+ Assert.assertEquals(dbRangerService.getType(), rangerService.getType());
+ Assert.assertEquals(dbRangerService.getVersion(),
+ rangerService.getVersion());
+ Mockito.verify(daoManager).getXXUser();
+ }
+
+ @Test
+ public void test21deleteService() throws Exception {
+ XXPolicyDao xPolicyDao = Mockito.mock(XXPolicyDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+ XXPolicyItemGroupPermDao xPolicyItemGroupPermDao = Mockito
+ .mock(XXPolicyItemGroupPermDao.class);
+ XXPolicyItemUserPermDao xPolicyItemUserPermDao = Mockito
+ .mock(XXPolicyItemUserPermDao.class);
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ RangerService rangerService = rangerService();
+ RangerPolicy rangerPolicy = rangerPolicy();
+ String name = "HDFS_1-1-20150316062453";
+
+ List<XXPolicy> policiesList = new ArrayList<XXPolicy>();
+ XXPolicy policy = new XXPolicy();
+ policy.setAddedByUserId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("polcy test");
+ policy.setGuid("");
+ policy.setId(rangerService.getId());
+ policy.setIsAuditEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setService(rangerService.getId());
+ policiesList.add(policy);
+
+ List<XXTrxLog> trxLogList = new ArrayList<XXTrxLog>();
+ XXTrxLog xTrxLogObj = new XXTrxLog();
+ xTrxLogObj.setAction("delete");
+ xTrxLogObj.setAddedByUserId(Id);
+ xTrxLogObj.setAttributeName("User Role");
+ xTrxLogObj.setCreateTime(new Date());
+ xTrxLogObj.setId(Id);
+ xTrxLogObj.setNewValue("admin");
+ xTrxLogObj.setObjectClassType(0);
+ xTrxLogObj.setObjectId(1L);
+ xTrxLogObj.setParentObjectClassType(0);
+ xTrxLogObj.setParentObjectId(Id);
+ trxLogList.add(xTrxLogObj);
+
+ List<XXPolicyItem> policyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem policyItem = new XXPolicyItem();
+ policyItem.setAddedByUserId(Id);
+ policyItem.setCreateTime(new Date());
+ policyItem.setDelegateAdmin(false);
+ policyItem.setId(Id);
+ policyItem.setOrder(1);
+ policyItem.setPolicyId(Id);
+ policyItem.setUpdatedByUserId(Id);
+ policyItem.setUpdateTime(new Date());
+ policyItemList.add(policyItem);
+
+ 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<XXPolicyItemGroupPerm> policyItemGroupPermList = new ArrayList<XXPolicyItemGroupPerm>();
+ XXPolicyItemGroupPerm policyItemGroupPerm = new XXPolicyItemGroupPerm();
+ policyItemGroupPerm.setAddedByUserId(Id);
+ policyItemGroupPerm.setCreateTime(new Date());
+ policyItemGroupPerm.setGroupId(Id);
+
+ List<XXServiceConfigMap> xConfMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+ xConfMap.setId(Id);
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ xConfMapList.add(xConfMap);
+ policyItemGroupPerm.setId(Id);
+ policyItemGroupPerm.setOrder(1);
+ policyItemGroupPerm.setPolicyItemId(Id);
+ policyItemGroupPerm.setUpdatedByUserId(Id);
+ policyItemGroupPerm.setUpdateTime(new Date());
+ policyItemGroupPermList.add(policyItemGroupPerm);
+
+ List<XXPolicyItemUserPerm> policyItemUserPermList = new ArrayList<XXPolicyItemUserPerm>();
+ XXPolicyItemUserPerm policyItemUserPerm = new XXPolicyItemUserPerm();
+ policyItemUserPerm.setAddedByUserId(Id);
+ policyItemUserPerm.setCreateTime(new Date());
+ policyItemUserPerm.setPolicyItemId(Id);
+ policyItemUserPerm.setId(Id);
+ policyItemUserPerm.setOrder(1);
+ policyItemUserPerm.setUpdatedByUserId(Id);
+ policyItemUserPerm.setUpdateTime(new Date());
+ policyItemUserPermList.add(policyItemUserPerm);
+
+ 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<XXPolicyResource> policyResourceList = new ArrayList<XXPolicyResource>();
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+ policyResourceList.add(policyResource);
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXServiceConfigDef> xServiceConfigDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ xServiceConfigDefList.add(serviceConfigDefObj);
+
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xPolicyDao);
+ Mockito.when(xPolicyDao.findByServiceId(rangerService.getId()))
+ .thenReturn(policiesList);
+ Mockito.when(svcService.delete(rangerService)).thenReturn(true);
+
+ Mockito.when(svcService.getTransactionLog(rangerService, 3))
+ .thenReturn(trxLogList);
+
+ Mockito.when(svcService.read(Id)).thenReturn(rangerService);
+ Mockito.when(policyService.read(Id)).thenReturn(rangerPolicy);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.findByPolicyId(policyItem.getId()))
+ .thenReturn(policyItemList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemId(policyItemCondition
+ .getId())).thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXPolicyItemGroupPerm()).thenReturn(
+ xPolicyItemGroupPermDao);
+ Mockito.when(
+ xPolicyItemGroupPermDao.findByPolicyItemId(policyItem.getId()))
+ .thenReturn(policyItemGroupPermList);
+
+ Mockito.when(daoManager.getXXPolicyItemUserPerm()).thenReturn(
+ xPolicyItemUserPermDao);
+ Mockito.when(xPolicyItemUserPermDao.findByPolicyItemId(Id)).thenReturn(
+ policyItemUserPermList);
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(
+ xPolicyItemAccessDao.findByPolicyItemId(policyItemAccess
+ .getId())).thenReturn(policyItemAccessList);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(xPolicyResourceDao.findByPolicyId(policyResource.getId()))
+ .thenReturn(policyResourceList);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResourceMap
+ .getId())).thenReturn(policyResourceMapList);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(
+ xServiceConfigDefDao.findByServiceDefName(rangerService
+ .getType())).thenReturn(xServiceConfigDefList);
+
+ Mockito.when(svcService.update(rangerService))
+ .thenReturn(rangerService);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(rangerService.getId())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(
+ xServiceConfigMapDao.findByServiceId(rangerService.getId()))
+ .thenReturn(xConfMapList);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(name)).thenReturn(xUser);
+ serviceDBStore.deleteService(Id);
+ Mockito.verify(svcService).update(rangerService);
+ Mockito.verify(daoManager).getXXUser();
+ }
+
+ @Test
+ public void test22getService() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(svcService.read(Id)).thenReturn(rangerService);
+
+ RangerService dbRangerService = serviceDBStore.getService(Id);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getCreatedBy(),
+ rangerService.getCreatedBy());
+ Assert.assertEquals(dbRangerService.getDescription(),
+ rangerService.getDescription());
+ Assert.assertEquals(dbRangerService.getGuid(), rangerService.getGuid());
+ Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Assert.assertEquals(dbRangerService.getType(), rangerService.getType());
+ Assert.assertEquals(dbRangerService.getUpdatedBy(),
+ rangerService.getUpdatedBy());
+ Assert.assertEquals(dbRangerService.getConfigs(),
+ rangerService.getConfigs());
+ Assert.assertEquals(dbRangerService.getCreateTime(),
+ rangerService.getCreateTime());
+ Assert.assertEquals(dbRangerService.getId(), rangerService.getId());
+ Assert.assertEquals(dbRangerService.getPolicyVersion(),
+ rangerService.getPolicyVersion());
+ Assert.assertEquals(dbRangerService.getVersion(),
+ rangerService.getVersion());
+ Assert.assertEquals(dbRangerService.getPolicyUpdateTime(),
+ rangerService.getPolicyUpdateTime());
+
+ Mockito.verify(svcService).read(Id);
+
+ }
+
+ @Test
+ public void test23getServiceByName() throws Exception {
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+
+ RangerService rangerService = rangerService();
+ String name = rangerService.getName();
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ RangerService dbRangerService = serviceDBStore.getServiceByName(name);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getName(), rangerService.getName());
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(svcService).getPopulatedViewObject(xService);
+ }
+
+ @Test
+ public void test24getServices() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ List<RangerService> serviceList = new ArrayList<RangerService>();
+ RangerService rangerService = rangerService();
+ serviceList.add(rangerService);
+
+ RangerServiceList serviceListObj = new RangerServiceList();
+ serviceListObj.setPageSize(0);
+ serviceListObj.setResultSize(1);
+ serviceListObj.setSortBy("asc");
+ serviceListObj.setSortType("1");
+ serviceListObj.setStartIndex(0);
+ serviceListObj.setTotalCount(10);
+ serviceListObj.setServices(serviceList);
+
+ Mockito.when(svcService.searchRangerServices(filter)).thenReturn(
+ serviceListObj);
+ List<RangerService> dbRangerService = serviceDBStore
+ .getServices(filter);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, serviceList);
+ Mockito.verify(svcService).searchRangerServices(filter);
+ }
+
+ @Test
+ public void test25getPaginatedServiceDefs() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ List<RangerService> serviceList = new ArrayList<RangerService>();
+ RangerService rangerService = rangerService();
+ serviceList.add(rangerService);
+
+ RangerServiceList serviceListObj = new RangerServiceList();
+ serviceListObj.setPageSize(0);
+ serviceListObj.setResultSize(1);
+ serviceListObj.setSortBy("asc");
+ serviceListObj.setSortType("1");
+ serviceListObj.setStartIndex(0);
+ serviceListObj.setTotalCount(10);
+ serviceListObj.setServices(serviceList);
+
+ Mockito.when(svcService.searchRangerServices(filter)).thenReturn(
+ serviceListObj);
+
+ RangerServiceList dbServiceList = serviceDBStore
+ .getPaginatedServices(filter);
+ Assert.assertNotNull(dbServiceList);
+ Assert.assertEquals(dbServiceList, serviceListObj);
+ Assert.assertEquals(dbServiceList.getList(), serviceListObj.getList());
+ Assert.assertEquals(dbServiceList.getServices(),
+ serviceListObj.getServices());
+
+ Mockito.verify(svcService).searchRangerServices(filter);
+ }
+
+ @Test
+ public void tess26createPolicy() throws Exception {
+
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXPolicy xPolicy = Mockito.mock(XXPolicy.class);
+ XXPolicyDao xPolicyDao = Mockito.mock(XXPolicyDao.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ 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");
+
+ String policyName = "HDFS_1-1-20150316062345";
+ String name = "HDFS_1-1-20150316062453";
+
+ List<RangerPolicyItemAccess> accessesList = new ArrayList<RangerPolicyItemAccess>();
+ RangerPolicyItemAccess policyItemAccess = new RangerPolicyItemAccess();
+ policyItemAccess.setIsAllowed(true);
+ policyItemAccess.setType("1");
+ List<String> usersList = new ArrayList<String>();
+ List<String> groupsList = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditionsList = new ArrayList<RangerPolicyItemCondition>();
+ RangerPolicyItemCondition policyItemCondition = new RangerPolicyItemCondition();
+ policyItemCondition.setType("1");
+ policyItemCondition.setValues(usersList);
+ conditionsList.add(policyItemCondition);
+
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicy.RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setDelegateAdmin(false);
+ rangerPolicyItem.setAccesses(accessesList);
+ rangerPolicyItem.setConditions(conditionsList);
+ rangerPolicyItem.setGroups(groupsList);
+ rangerPolicyItem.setUsers(usersList);
+ policyItems.add(rangerPolicyItem);
+
+ List<RangerPolicyItem> policyItemsSet = new ArrayList<RangerPolicy.RangerPolicyItem>();
+ RangerPolicyItem paramPolicyItem = new RangerPolicyItem(accessesList,
+ usersList, groupsList, conditionsList, false);
+ paramPolicyItem.setDelegateAdmin(false);
+ paramPolicyItem.setAccesses(accessesList);
+ paramPolicyItem.setConditions(conditionsList);
+ paramPolicyItem.setGroups(groupsList);
+ rangerPolicyItem.setUsers(usersList);
+ policyItemsSet.add(paramPolicyItem);
+
+ 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());
+
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(Id);
+ xxPolicy.setName(name);
+ 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());
+
+ List<XXServiceConfigDef> xServiceConfigDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ xServiceConfigDefList.add(serviceConfigDefObj);
+
+ List<XXServiceConfigMap> xConfMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+ xConfMap.setId(Id);
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ xConfMapList.add(xConfMap);
+
+ RangerPolicy rangerPolicy = rangerPolicy();
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(rangerService.getType()))
+ .thenReturn(xServiceDef);
+
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xPolicyDao);
+ Mockito.when(
+ xPolicyDao.findByNameAndServiceId(policyName,
+ rangerService.getId())).thenReturn(xPolicy);
+
+ Mockito.when(policyService.create(rangerPolicy)).thenReturn(
+ rangerPolicy);
+
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xPolicyDao);
+ Mockito.when(xPolicyDao.getById(Id)).thenReturn(xPolicy);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXPolicyItem.class),
+ Mockito.isA(XXPolicy.class))).thenReturn(xPolicyItem);
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.create(xPolicyItem))
+ .thenReturn(xPolicyItem);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(xServiceConfigDefDao.findByServiceDefName(name))
+ .thenReturn(xServiceConfigDefList);
+
+ Mockito.when(svcService.update(rangerService))
+ .thenReturn(rangerService);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(xServiceConfigMapDao.findByServiceId(Id)).thenReturn(
+ xConfMapList);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(name)).thenReturn(xUser);
+
+ RangerPolicy dbRangerPolicy = serviceDBStore.createPolicy(rangerPolicy);
+ Assert.assertNull(dbRangerPolicy);
+ Assert.assertEquals(Id, rangerPolicy.getId());
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(policyService).create(rangerPolicy);
+ Mockito.verify(rangerAuditFields).populateAuditFields(
+ Mockito.isA(XXPolicyItem.class), Mockito.isA(XXPolicy.class));
+ Mockito.verify(daoManager).getXXPolicyItem();
+ Mockito.verify(daoManager).getXXServiceConfigDef();
+ Mockito.verify(svcService).update(rangerService);
+ Mockito.verify(daoManager).getXXUser();
+ }
+
+ @Test
+ public void tess27getPolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(policyService.read(Id)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = serviceDBStore.getPolicy(Id);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assert.assertEquals(dbRangerPolicy.getCreatedBy(),
+ rangerPolicy.getCreatedBy());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ rangerPolicy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getService(),
+ rangerPolicy.getService());
+ Assert.assertEquals(dbRangerPolicy.getUpdatedBy(),
+ rangerPolicy.getUpdatedBy());
+ Assert.assertEquals(dbRangerPolicy.getCreateTime(),
+ rangerPolicy.getCreateTime());
+ Assert.assertEquals(dbRangerPolicy.getIsAuditEnabled(),
+ rangerPolicy.getIsAuditEnabled());
+ Assert.assertEquals(dbRangerPolicy.getIsEnabled(),
+ rangerPolicy.getIsEnabled());
+ Assert.assertEquals(dbRangerPolicy.getPolicyItems(),
+ rangerPolicy.getPolicyItems());
+ Assert.assertEquals(dbRangerPolicy.getVersion(),
+ rangerPolicy.getVersion());
+ Mockito.verify(policyService).read(Id);
+
+ }
+
+ @Test
+ public void tess28updatePolicy() throws Exception {
+
+ XXPolicyDao xPolicyDao = Mockito.mock(XXPolicyDao.class);
+ XXPolicy xPolicy = Mockito.mock(XXPolicy.class);
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItem xPolicyItem = Mockito.mock(XXPolicyItem.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ RangerService rangerService = rangerService();
+
+ RangerPolicy rangerPolicy = rangerPolicy();
+ String name = "HDFS_1-1-20150316062453";
+
+ List<XXPolicyResource> policyResourceList = new ArrayList<XXPolicyResource>();
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+ policyResourceList.add(policyResource);
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXServiceConfigDef> xServiceConfigDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ xServiceConfigDefList.add(serviceConfigDefObj);
+
+ List<XXServiceConfigMap> xConfMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+ xConfMap.setId(Id);
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ xConfMapList.add(xConfMap);
+
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xPolicyDao);
+ Mockito.when(xPolicyDao.getById(Id)).thenReturn(xPolicy);
+ Mockito.when(policyService.getPopulatedViewObject(xPolicy)).thenReturn(
+ rangerPolicy);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(rangerService.getType()))
+ .thenReturn(xServiceDef);
+
+ Mockito.when(policyService.update(rangerPolicy)).thenReturn(
+ rangerPolicy);
+ Mockito.when(daoManager.getXXPolicy()).thenReturn(xPolicyDao);
+ Mockito.when(xPolicyDao.getById(rangerPolicy.getId())).thenReturn(
+ xPolicy);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(xPolicyResourceDao.findByPolicyId(rangerPolicy.getId()))
+ .thenReturn(policyResourceList);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResourceMap
+ .getId())).thenReturn(policyResourceMapList);
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXPolicyItem.class),
+ Mockito.isA(XXPolicy.class))).thenReturn(xPolicyItem);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(rangerService.getId())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(xServiceConfigDefDao.findByServiceDefName(name))
+ .thenReturn(xServiceConfigDefList);
+
+ Mockito.when(svcService.update(rangerService))
+ .thenReturn(rangerService);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(rangerService.getId())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(
+ xServiceConfigMapDao.findByServiceId(rangerService.getId()))
+ .thenReturn(xConfMapList);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(name)).thenReturn(xUser);
+
+ RangerPolicy dbRangerPolicy = serviceDBStore.updatePolicy(rangerPolicy);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(), rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getCreatedBy(),
+ rangerPolicy.getCreatedBy());
+ Assert.assertEquals(dbRangerPolicy.getDescription(),
+ rangerPolicy.getDescription());
+ Assert.assertEquals(dbRangerPolicy.getName(), rangerPolicy.getName());
+ Assert.assertEquals(dbRangerPolicy.getGuid(), rangerPolicy.getGuid());
+ Assert.assertEquals(dbRangerPolicy.getService(),
+ rangerPolicy.getService());
+ Assert.assertEquals(dbRangerPolicy.getIsEnabled(),
+ rangerPolicy.getIsEnabled());
+ Assert.assertEquals(dbRangerPolicy.getVersion(),
+ rangerPolicy.getVersion());
+
+ Mockito.verify(rangerAuditFields).populateAuditFields(
+ Mockito.isA(XXPolicyItem.class), Mockito.isA(XXPolicy.class));
+ Mockito.verify(daoManager).getXXServiceConfigDef();
+ Mockito.verify(svcService).update(rangerService);
+ Mockito.verify(daoManager).getXXUser();
+ }
+
+ @Test
+ public void tess29deletePolicy() throws Exception {
+
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXPolicyItemDao xPolicyItemDao = Mockito.mock(XXPolicyItemDao.class);
+ XXPolicyItemConditionDao xPolicyItemConditionDao = Mockito
+ .mock(XXPolicyItemConditionDao.class);
+ XXPolicyItemGroupPermDao xPolicyItemGroupPermDao = Mockito
+ .mock(XXPolicyItemGroupPermDao.class);
+ XXPolicyItemUserPermDao xPolicyItemUserPermDao = Mockito
+ .mock(XXPolicyItemUserPermDao.class);
+ XXPolicyItemAccessDao xPolicyItemAccessDao = Mockito
+ .mock(XXPolicyItemAccessDao.class);
+ XXPolicyResourceDao xPolicyResourceDao = Mockito
+ .mock(XXPolicyResourceDao.class);
+ XXPolicyResourceMapDao xPolicyResourceMapDao = Mockito
+ .mock(XXPolicyResourceMapDao.class);
+ XXServiceConfigDefDao xServiceConfigDefDao = Mockito
+ .mock(XXServiceConfigDefDao.class);
+ XXServiceConfigMapDao xServiceConfigMapDao = Mockito
+ .mock(XXServiceConfigMapDao.class);
+ XXUserDao xUserDao = Mockito.mock(XXUserDao.class);
+ XXUser xUser = Mockito.mock(XXUser.class);
+
+ RangerService rangerService = rangerService();
+ RangerPolicy rangerPolicy = rangerPolicy();
+ String name = "HDFS_1-1-20150316062453";
+
+ List<XXPolicyItem> policyItemList = new ArrayList<XXPolicyItem>();
+ XXPolicyItem policyItem = new XXPolicyItem();
+ policyItem.setAddedByUserId(Id);
+ policyItem.setCreateTime(new Date());
+ policyItem.setDelegateAdmin(false);
+ policyItem.setId(Id);
+ policyItem.setOrder(1);
+ policyItem.setPolicyId(Id);
+ policyItem.setUpdatedByUserId(Id);
+ policyItem.setUpdateTime(new Date());
+ policyItemList.add(policyItem);
+
+ 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<XXPolicyItemGroupPerm> policyItemGroupPermList = new ArrayList<XXPolicyItemGroupPerm>();
+ XXPolicyItemGroupPerm policyItemGroupPerm = new XXPolicyItemGroupPerm();
+ policyItemGroupPerm.setAddedByUserId(Id);
+ policyItemGroupPerm.setCreateTime(new Date());
+ policyItemGroupPerm.setGroupId(Id);
+
+ List<XXServiceConfigMap> xConfMapList = new ArrayList<XXServiceConfigMap>();
+ XXServiceConfigMap xConfMap = new XXServiceConfigMap();
+ xConfMap.setAddedByUserId(null);
+ xConfMap.setConfigkey(name);
+ xConfMap.setConfigvalue(name);
+ xConfMap.setCreateTime(new Date());
+ xConfMap.setServiceId(null);
+ xConfMap.setId(Id);
+ xConfMap.setUpdatedByUserId(null);
+ xConfMap.setUpdateTime(new Date());
+ xConfMapList.add(xConfMap);
+ policyItemGroupPerm.setId(Id);
+ policyItemGroupPerm.setOrder(1);
+ policyItemGroupPerm.setPolicyItemId(Id);
+ policyItemGroupPerm.setUpdatedByUserId(Id);
+ policyItemGroupPerm.setUpdateTime(new Date());
+ policyItemGroupPermList.add(policyItemGroupPerm);
+
+ List<XXPolicyItemUserPerm> policyItemUserPermList = new ArrayList<XXPolicyItemUserPerm>();
+ XXPolicyItemUserPerm policyItemUserPerm = new XXPolicyItemUserPerm();
+ policyItemUserPerm.setAddedByUserId(Id);
+ policyItemUserPerm.setCreateTime(new Date());
+ policyItemUserPerm.setPolicyItemId(Id);
+ policyItemUserPerm.setId(Id);
+ policyItemUserPerm.setOrder(1);
+ policyItemUserPerm.setUpdatedByUserId(Id);
+ policyItemUserPerm.setUpdateTime(new Date());
+ policyItemUserPermList.add(policyItemUserPerm);
+
+ 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<XXPolicyResource> policyResourceList = new ArrayList<XXPolicyResource>();
+ XXPolicyResource policyResource = new XXPolicyResource();
+ policyResource.setId(Id);
+ policyResource.setCreateTime(new Date());
+ policyResource.setAddedByUserId(Id);
+ policyResource.setIsExcludes(false);
+ policyResource.setIsRecursive(false);
+ policyResource.setPolicyId(Id);
+ policyResource.setResDefId(Id);
+ policyResource.setUpdatedByUserId(Id);
+ policyResource.setUpdateTime(new Date());
+ policyResourceList.add(policyResource);
+
+ List<XXPolicyResourceMap> policyResourceMapList = new ArrayList<XXPolicyResourceMap>();
+ XXPolicyResourceMap policyResourceMap = new XXPolicyResourceMap();
+ policyResourceMap.setAddedByUserId(Id);
+ policyResourceMap.setCreateTime(new Date());
+ policyResourceMap.setId(Id);
+ policyResourceMap.setOrder(1);
+ policyResourceMap.setResourceId(Id);
+ policyResourceMap.setUpdatedByUserId(Id);
+ policyResourceMap.setUpdateTime(new Date());
+ policyResourceMap.setValue("1L");
+ policyResourceMapList.add(policyResourceMap);
+
+ List<XXServiceConfigDef> xServiceConfigDefList = new ArrayList<XXServiceConfigDef>();
+ XXServiceConfigDef serviceConfigDefObj = new XXServiceConfigDef();
+ serviceConfigDefObj.setId(Id);
+ xServiceConfigDefList.add(serviceConfigDefObj);
+
+ Mockito.when(policyService.read(rangerPolicy.getId())).thenReturn(
+ rangerPolicy);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(name)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ Mockito.when(daoManager.getXXPolicyItem()).thenReturn(xPolicyItemDao);
+ Mockito.when(xPolicyItemDao.findByPolicyId(policyItem.getId()))
+ .thenReturn(policyItemList);
+
+ Mockito.when(daoManager.getXXPolicyItemCondition()).thenReturn(
+ xPolicyItemConditionDao);
+ Mockito.when(
+ xPolicyItemConditionDao.findByPolicyItemId(policyItemCondition
+ .getId())).thenReturn(policyItemConditionList);
+
+ Mockito.when(daoManager.getXXPolicyItemGroupPerm()).thenReturn(
+ xPolicyItemGroupPermDao);
+ Mockito.when(
+ xPolicyItemGroupPermDao.findByPolicyItemId(policyItem.getId()))
+ .thenReturn(policyItemGroupPermList);
+
+ Mockito.when(daoManager.getXXPolicyItemUserPerm()).thenReturn(
+ xPolicyItemUserPermDao);
+ Mockito.when(xPolicyItemUserPermDao.findByPolicyItemId(Id)).thenReturn(
+ policyItemUserPermList);
+
+ Mockito.when(daoManager.getXXPolicyItemAccess()).thenReturn(
+ xPolicyItemAccessDao);
+ Mockito.when(
+ xPolicyItemAccessDao.findByPolicyItemId(policyItemAccess
+ .getId())).thenReturn(policyItemAccessList);
+
+ Mockito.when(daoManager.getXXPolicyResource()).thenReturn(
+ xPolicyResourceDao);
+ Mockito.when(xPolicyResourceDao.findByPolicyId(policyResource.getId()))
+ .thenReturn(policyResourceList);
+
+ Mockito.when(daoManager.getXXPolicyResourceMap()).thenReturn(
+ xPolicyResourceMapDao);
+ Mockito.when(
+ xPolicyResourceMapDao.findByPolicyResId(policyResourceMap
+ .getId())).thenReturn(policyResourceMapList);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+
+ Mockito.when(daoManager.getXXServiceConfigDef()).thenReturn(
+ xServiceConfigDefDao);
+ Mockito.when(
+ xServiceConfigDefDao.findByServiceDefName(rangerService
+ .getType())).thenReturn(xServiceConfigDefList);
+
+ Mockito.when(svcService.update(rangerService))
+ .thenReturn(rangerService);
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(rangerService.getId())).thenReturn(
+ xService);
+
+ Mockito.when(daoManager.getXXServiceConfigMap()).thenReturn(
+ xServiceConfigMapDao);
+ Mockito.when(
+ xServiceConfigMapDao.findByServiceId(rangerService.getId()))
+ .thenReturn(xConfMapList);
+
+ Mockito.when(
+ rangerAuditFields.populateAuditFields(
+ Mockito.isA(XXServiceConfigMap.class),
+ Mockito.isA(XXService.class))).thenReturn(xConfMap);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xUserDao);
+ Mockito.when(xUserDao.findByUserName(name)).thenReturn(xUser);
+
+ serviceDBStore.deletePolicy(Id);
+ Mockito.verify(svcService).update(rangerService);
+ Mockito.verify(daoManager).getXXUser();
+ }
+
+ @Test
+ public void test30getPolicies() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ List<RangerPolicy> rangerPolicyLists = new ArrayList<RangerPolicy>();
+ RangerPolicy rangerPolicy = rangerPolicy();
+ rangerPolicyLists.add(rangerPolicy);
+
+ RangerPolicyList policyListObj = new RangerPolicyList();
+ policyListObj.setPageSize(0);
+ policyListObj.setResultSize(1);
+ policyListObj.setSortBy("asc");
+ policyListObj.setSortType("1");
+ policyListObj.setStartIndex(0);
+ policyListObj.setTotalCount(10);
+
+ Mockito.when(policyService.searchRangerPolicies(filter)).thenReturn(
+ policyListObj);
+ List<RangerPolicy> dbRangerPolicy = serviceDBStore.getPolicies(filter);
+ Assert.assertNotNull(dbRangerPolicy);
+ Mockito.verify(policyService).searchRangerPolicies(filter);
+ }
+
+ @Test
+ public void test31getPaginatedPolicies() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ RangerPolicyList policyListObj = new RangerPolicyList();
+ policyListObj.setPageSize(0);
+ policyListObj.setResultSize(1);
+ policyListObj.setSortBy("asc");
+ policyListObj.setSortType("1");
+ policyListObj.setStartIndex(0);
+ policyListObj.setTotalCount(10);
+
+ Mockito.when(policyService.searchRangerPolicies(filter)).thenReturn(
+ policyListObj);
+
+ RangerPolicyList dbRangerPolicyList = serviceDBStore
+ .getPaginatedPolicies(filter);
+ Assert.assertNotNull(dbRangerPolicyList);
+ Mockito.verify(policyService).searchRangerPolicies(filter);
+ }
+
+ @Test
+ public void test32getServicePolicies() throws Exception {
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ RangerService rangerService = rangerService();
+ Mockito.when(svcService.read(Id)).thenReturn(rangerService);
+
+ List<RangerPolicy> dbRangerPolicy = serviceDBStore.getServicePolicies(
+ Id, filter);
+ Assert.assertNotNull(dbRangerPolicy);
+ Mockito.verify(svcService).read(Id);
+ }
+
+ @Test
+ public void test33getServicePoliciesIfUpdated() throws Exception {
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ XXService xService = Mockito.mock(XXService.class);
+ XXServiceDefDao xServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+ XXServiceDef xServiceDef = Mockito.mock(XXServiceDef.class);
+ RangerServiceDef rangerServiceDef = Mockito
+ .mock(RangerServiceDef.class);
+
+ RangerService rangerService = rangerService();
+ String serviceName = "HDFS_1";
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(svcService.getPopulatedViewObject(xService)).thenReturn(
+ rangerService);
+
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xServiceDefDao);
+ Mockito.when(xServiceDefDao.findByName(rangerService.getType()))
+ .thenReturn(xServiceDef);
+ Mockito.when(serviceDefService.getPopulatedViewObject(xServiceDef))
+ .thenReturn(rangerServiceDef);
+
+ ServicePolicies dbServicePolicies = serviceDBStore
+ .getServicePoliciesIfUpdated(serviceName, Id);
+ Assert.assertNotNull(dbServicePolicies);
+ Assert.assertEquals(dbServicePolicies.getServiceName(), serviceName);
+ }
+
+ @Test
+ public void test34getPolicyFromEventTime() {
+ XXDataHistDao xDataHistDao = Mockito.mock(XXDataHistDao.class);
+ XXDataHist xDataHist = Mockito.mock(XXDataHist.class);
+
+ String eventTime = "2015-03-16 06:24:54";
+ Mockito.when(daoManager.getXXDataHist()).thenReturn(xDataHistDao);
+ Mockito.when(
+ xDataHistDao.findObjByEventTimeClassTypeAndId(eventTime, 1020, Id))
+ .thenReturn(xDataHist);
+
+ RangerPolicy dbRangerPolicy = serviceDBStore.getPolicyFromEventTime(eventTime, Id);
+ Assert.assertNull(dbRangerPolicy);
+ Mockito.verify(daoManager).getXXDataHist();
+ }
+
+ @Test
+ public void test35getPopulateExistingBaseFields() {
+ Boolean isFound = serviceDBStore.getPopulateExistingBaseFields();
+ Assert.assertFalse(isFound);
+ }
+
+ @Test
+ public void test36getPaginatedServicePolicies() throws Exception {
+ String serviceName = "HDFS_1";
+ RangerPolicyList policyList = new RangerPolicyList();
+ policyList.setPageSize(0);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+
+ Mockito.when(policyService.searchRangerPolicies(filter)).thenReturn(
+ policyList);
+
+ RangerPolicyList dbRangerPolicyList = serviceDBStore
+ .getPaginatedServicePolicies(serviceName, filter);
+ Assert.assertNotNull(dbRangerPolicyList);
+ Mockito.verify(policyService).searchRangerPolicies(filter);
+ }
+
+ @Test
+ public void test37getPaginatedServicePolicies() throws Exception {
+
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ RangerService rangerService = rangerService();
+ Mockito.when(svcService.read(rangerService.getId())).thenReturn(
+ rangerService);
+ RangerPolicyList dbRangerPolicyList = serviceDBStore
+ .getPaginatedServicePolicies(rangerService.getId(), filter);
+ Assert.assertNull(dbRangerPolicyList);
+ Mockito.verify(svcService).read(rangerService.getId());
+ }
+
+ @Test
+ public void test38getPolicyVersionList() throws Exception {
+ XXDataHistDao xDataHistDao = Mockito.mock(XXDataHistDao.class);
+ List<Integer> versionList = new ArrayList<Integer>();
+ versionList.add(1);
+ versionList.add(2);
+ Mockito.when(daoManager.getXXDataHist()).thenReturn(xDataHistDao);
+ Mockito.when(xDataHistDao.getVersionListOfObject(Id, 1020))
+ .thenReturn(versionList);
+
+ VXString dbVXString = serviceDBStore.getPolicyVersionList(Id);
+ Assert.assertNotNull(dbVXString);
+ Mockito.verify(daoManager).getXXDataHist();
+ }
+
+ @Test
+ public void test39getPolicyForVersionNumber() throws Exception {
+ XXDataHistDao xDataHistDao = Mockito.mock(XXDataHistDao.class);
+ XXDataHist xDataHist = Mockito.mock(XXDataHist.class);
+ Mockito.when(daoManager.getXXDataHist()).thenReturn(xDataHistDao);
+ Mockito.when(xDataHistDao.findObjectByVersionNumber(Id, 1020,1))
+ .thenReturn(xDataHist);
+ RangerPolicy dbRangerPolicy = serviceDBStore.getPolicyForVersionNumber(Id, 1);
+ Assert.assertNull(dbRangerPolicy);
+ Mockito.verify(daoManager).getXXDataHist();
+ }
+}