[2/5] incubator-ranger git commit: RANGER-203 : Add unit test cases for Pluggable Service model

[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);
+	}
+}