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 2016/09/28 15:25:41 UTC
[1/5] incubator-ranger git commit: RANGER-1170 : Improvement of Unit
Test coverage in Ranger
Repository: incubator-ranger
Updated Branches:
refs/heads/master eb21ea6af -> 53fb16a60
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefService.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefService.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefService.java
new file mode 100644
index 0000000..2ca0fd2
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefService.java
@@ -0,0 +1,274 @@
+/*
+ * 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.db.RangerDaoManager;
+import org.apache.ranger.db.XXServiceVersionInfoDao;
+import org.apache.ranger.db.XXTagAttributeDefDao;
+import org.apache.ranger.db.XXTagDefDao;
+import org.apache.ranger.entity.XXTagAttributeDef;
+import org.apache.ranger.entity.XXTagDef;
+import org.apache.ranger.plugin.model.RangerTagDef;
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+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 TestRangerTagDefService {
+ Long id = 1L;
+ String guid = "989898_01_1";
+ String name = "test";
+ Long serviceId = 5L;
+
+ @InjectMocks
+ RangerTagDefService rangerTagDefService = new RangerTagDefService();
+
+ @Mock
+ RangerDaoManager daoMgr;
+
+ @Test
+ public void test1ValidateForCreate() {
+ RangerTagDef rangerServiceDef = new RangerTagDef();
+
+ rangerTagDefService.validateForCreate(rangerServiceDef);
+ Assert.assertNotNull(rangerServiceDef);
+ }
+
+ @Test
+ public void test2validateForUpdate() {
+ RangerTagDef rangerServiceDef = new RangerTagDef();
+ XXTagDef xXTagDef = new XXTagDef();
+
+ rangerTagDefService.validateForUpdate(rangerServiceDef, xXTagDef);
+ Assert.assertNotNull(rangerServiceDef);
+ }
+
+ @Test
+ public void test3postUpdate(){
+ XXTagDef tagDef = new XXTagDef();
+ tagDef.setId(id);
+ tagDef.setName(name);
+ tagDef.setUpdateTime(new Date());
+
+ List<XXTagAttributeDef> tagAttrDefList = new ArrayList<XXTagAttributeDef>();
+ XXTagAttributeDef xxTagAttributeDef = new XXTagAttributeDef();
+ xxTagAttributeDef.setId(id);
+ xxTagAttributeDef.setName(name);
+ tagAttrDefList.add(xxTagAttributeDef);
+
+ XXTagAttributeDefDao xxTagAttributeDefDao = Mockito.mock(XXTagAttributeDefDao.class);
+ XXServiceVersionInfoDao xxServiceVersionInfoDao = Mockito.mock(XXServiceVersionInfoDao.class);
+
+ Mockito.when(daoMgr.getXXTagAttributeDef()).thenReturn(xxTagAttributeDefDao);
+ Mockito.when(xxTagAttributeDefDao.findByTagDefId(tagDef.getId())).thenReturn(tagAttrDefList);
+
+ Mockito.when(daoMgr.getXXServiceVersionInfo()).thenReturn(xxServiceVersionInfoDao);
+ Mockito.doNothing().when(xxServiceVersionInfoDao).updateServiceVersionInfoForTagDefUpdate(tagDef.getId(), tagDef.getUpdateTime());
+
+ RangerTagDef result = rangerTagDefService.postUpdate(tagDef);
+ Assert.assertEquals(result.getId(), tagAttrDefList.get(0).getId());
+ Assert.assertEquals(result.getName(), tagAttrDefList.get(0).getName());
+
+ Mockito.verify(daoMgr).getXXTagAttributeDef();
+ Mockito.verify(xxTagAttributeDefDao).findByTagDefId(tagDef.getId());
+ Mockito.verify(daoMgr).getXXServiceVersionInfo();
+ Mockito.verify(xxServiceVersionInfoDao).updateServiceVersionInfoForTagDefUpdate(tagDef.getId(), tagDef.getUpdateTime());
+ }
+
+ @Test
+ public void test4getTagDefByGuid(){
+ XXTagDef xxTagDef = new XXTagDef();
+ xxTagDef.setId(id);
+ xxTagDef.setName(name);
+ xxTagDef.setUpdateTime(new Date());
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByGuid(guid)).thenReturn(xxTagDef);
+
+ List<XXTagAttributeDef> tagAttrDefList = new ArrayList<XXTagAttributeDef>();
+ XXTagAttributeDef xxTagAttributeDef = new XXTagAttributeDef();
+ xxTagAttributeDef.setId(id);
+ xxTagAttributeDef.setName(name);
+ tagAttrDefList.add(xxTagAttributeDef);
+
+ XXTagAttributeDefDao xxTagAttributeDefDao = Mockito.mock(XXTagAttributeDefDao.class);
+
+ Mockito.when(daoMgr.getXXTagAttributeDef()).thenReturn(xxTagAttributeDefDao);
+ Mockito.when(xxTagAttributeDefDao.findByTagDefId(xxTagDef.getId())).thenReturn(tagAttrDefList);
+
+ RangerTagDef result = rangerTagDefService.getTagDefByGuid(guid);
+ Assert.assertEquals(result.getId(), tagAttrDefList.get(0).getId());
+ Assert.assertEquals(result.getName(), tagAttrDefList.get(0).getName());
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByGuid(guid);
+ Mockito.verify(daoMgr).getXXTagAttributeDef();
+ Mockito.verify(xxTagAttributeDefDao).findByTagDefId(xxTagDef.getId());
+ }
+
+ @Test
+ public void test5getTagDefByGuid(){
+ XXTagDef xxTagDef = null;
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByGuid(guid)).thenReturn(xxTagDef);
+
+ RangerTagDef result = rangerTagDefService.getTagDefByGuid(guid);
+ Assert.assertNull(result);
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByGuid(guid);
+ }
+
+ @Test
+ public void test6getTagDefByName(){
+ RangerTagDef oldTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ oldTagDef.setName(name);
+ XXTagDef xxTagDef = new XXTagDef();
+ xxTagDef.setId(id);
+ xxTagDef.setName(name);
+ xxTagDef.setUpdateTime(new Date());
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByName(name)).thenReturn(xxTagDef);
+
+ List<XXTagAttributeDef> tagAttrDefList = new ArrayList<XXTagAttributeDef>();
+ XXTagAttributeDef xxTagAttributeDef = new XXTagAttributeDef();
+ xxTagAttributeDef.setId(id);
+ xxTagAttributeDef.setName(name);
+ tagAttrDefList.add(xxTagAttributeDef);
+
+ XXTagAttributeDefDao xxTagAttributeDefDao = Mockito.mock(XXTagAttributeDefDao.class);
+
+ Mockito.when(daoMgr.getXXTagAttributeDef()).thenReturn(xxTagAttributeDefDao);
+ Mockito.when(xxTagAttributeDefDao.findByTagDefId(xxTagDef.getId())).thenReturn(tagAttrDefList);
+
+ RangerTagDef result = rangerTagDefService.getTagDefByName(name);
+ Assert.assertEquals(result.getId(), tagAttrDefList.get(0).getId());
+ Assert.assertEquals(result.getName(), tagAttrDefList.get(0).getName());
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByName(name);
+ Mockito.verify(daoMgr).getXXTagAttributeDef();
+ Mockito.verify(xxTagAttributeDefDao).findByTagDefId(xxTagDef.getId());
+ }
+
+ @Test
+ public void test7getTagDefByName(){
+ XXTagDef xxTagDef = null;
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByName(name)).thenReturn(xxTagDef);
+
+ RangerTagDef result = rangerTagDefService.getTagDefByName(name);
+ Assert.assertNull(result);
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByName(name);
+ }
+
+ @Test
+ public void test8getTagDefsByServiceId(){
+ List<XXTagDef> xxTagDefs = new ArrayList<XXTagDef>();
+ XXTagDef xxTagDef = new XXTagDef();
+ xxTagDef.setId(id);
+ xxTagDef.setName(name);
+ xxTagDefs.add(xxTagDef);
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByServiceId(serviceId)).thenReturn(xxTagDefs);
+
+ List<XXTagAttributeDef> tagAttrDefList = new ArrayList<XXTagAttributeDef>();
+ XXTagAttributeDef xxTagAttributeDef = new XXTagAttributeDef();
+ xxTagAttributeDef.setId(id);
+ xxTagAttributeDef.setName(name);
+ tagAttrDefList.add(xxTagAttributeDef);
+
+ XXTagAttributeDefDao xxTagAttributeDefDao = Mockito.mock(XXTagAttributeDefDao.class);
+
+ Mockito.when(daoMgr.getXXTagAttributeDef()).thenReturn(xxTagAttributeDefDao);
+ Mockito.when(xxTagAttributeDefDao.findByTagDefId(xxTagDef.getId())).thenReturn(tagAttrDefList);
+
+ List<RangerTagDef> result = rangerTagDefService.getTagDefsByServiceId(serviceId);
+ Assert.assertEquals(result.get(0).getId(), tagAttrDefList.get(0).getId());
+ Assert.assertEquals(result.get(0).getName(), tagAttrDefList.get(0).getName());
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByServiceId(serviceId);
+ Mockito.verify(daoMgr).getXXTagAttributeDef();
+ Mockito.verify(xxTagAttributeDefDao).findByTagDefId(xxTagDef.getId());
+ }
+
+
+ @Test
+ public void test9getTagDefsByServiceId(){
+ List<XXTagDef> xxTagDefs = new ArrayList<XXTagDef>();
+
+ XXTagDefDao xXTagDefDao = Mockito.mock(XXTagDefDao.class);
+ Mockito.when(daoMgr.getXXTagDef()).thenReturn(xXTagDefDao);
+ Mockito.when(xXTagDefDao.findByServiceId(serviceId)).thenReturn(xxTagDefs);
+
+ List<RangerTagDef> result = rangerTagDefService.getTagDefsByServiceId(serviceId);
+ Assert.assertNotNull(result);
+
+ Mockito.verify(daoMgr).getXXTagDef();
+ Mockito.verify(xXTagDefDao).findByServiceId(serviceId);
+ }
+
+ @Test
+ public void test10getPopulatedViewObject(){
+ XXTagDef xxTagDef = new XXTagDef();
+ xxTagDef.setId(id);
+ xxTagDef.setName(name);
+ xxTagDef.setUpdateTime(new Date());
+
+ List<XXTagAttributeDef> tagAttrDefList = new ArrayList<XXTagAttributeDef>();
+ XXTagAttributeDef xxTagAttributeDef = new XXTagAttributeDef();
+ xxTagAttributeDef.setId(id);
+ xxTagAttributeDef.setName(name);
+ tagAttrDefList.add(xxTagAttributeDef);
+
+ XXTagAttributeDefDao xxTagAttributeDefDao = Mockito.mock(XXTagAttributeDefDao.class);
+
+ Mockito.when(daoMgr.getXXTagAttributeDef()).thenReturn(xxTagAttributeDefDao);
+ Mockito.when(xxTagAttributeDefDao.findByTagDefId(xxTagDef.getId())).thenReturn(tagAttrDefList);
+
+ RangerTagDef result = rangerTagDefService.getPopulatedViewObject(xxTagDef);
+ Assert.assertEquals(result.getId(), tagAttrDefList.get(0).getId());
+ Assert.assertEquals(result.getName(), tagAttrDefList.get(0).getName());
+
+ Mockito.verify(daoMgr).getXXTagAttributeDef();
+ Mockito.verify(xxTagAttributeDefDao).findByTagDefId(xxTagDef.getId());
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefServiceBase.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefServiceBase.java b/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefServiceBase.java
new file mode 100644
index 0000000..803191c
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/service/TestRangerTagDefServiceBase.java
@@ -0,0 +1,77 @@
+/*
+ * 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 org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.entity.XXDBBase;
+import org.apache.ranger.entity.XXTagDef;
+import org.apache.ranger.plugin.model.RangerTagDef;
+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.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestRangerTagDefServiceBase {
+ Long id = 1L;
+ String guid = "989898_01_1";
+ String name = "test";
+ Long version = 5L;
+ String type = "typo";
+ Long totalCount = 50L;
+
+ @InjectMocks
+ RangerTagDefService rangerTagDefService = new RangerTagDefService();
+
+ @Mock
+ RangerDaoManager daoMgr;
+
+ @Mock
+ RangerAuditFields<XXDBBase> rangerAuditFields;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void test1mapViewToEntityBean() {
+ RangerTagDef rangerTagDef = new RangerTagDef();
+ rangerTagDef.setId(id);
+ rangerTagDef.setGuid(guid);
+
+ XXTagDef xxTagDef = new XXTagDef();
+ xxTagDef.setId(id);
+ xxTagDef.setGuid(guid);
+ xxTagDef.setName(name);
+ xxTagDef.setVersion(version);
+ int operationContext = 1;
+
+ XXTagDef result = rangerTagDefService.mapViewToEntityBean(rangerTagDef,xxTagDef,operationContext);
+ Assert.assertNotNull(result);
+ Assert.assertEquals(result, xxTagDef);
+ Assert.assertEquals(result.getGuid(), xxTagDef.getGuid());
+ Assert.assertEquals(result.getName(), xxTagDef.getName());
+ Assert.assertEquals(result.getId(), xxTagDef.getId());
+ Assert.assertEquals(result.getVersion(), xxTagDef.getVersion());
+ }
+}
[4/5] incubator-ranger git commit: RANGER-1170 : Improvement of Unit
Test coverage in Ranger
Posted by ve...@apache.org.
RANGER-1170 : Improvement of Unit Test coverage in Ranger
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/1c441f79
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ranger/tree/1c441f79
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ranger/diff/1c441f79
Branch: refs/heads/master
Commit: 1c441f798e1c5da54f6bb9faf211eadb5f10b6b5
Parents: eb21ea6
Author: Ankita Sinha <an...@freestoneinfotech.com>
Authored: Wed Sep 14 17:09:09 2016 +0530
Committer: Velmurugan Periasamy <ve...@apache.org>
Committed: Wed Sep 28 11:19:17 2016 -0400
----------------------------------------------------------------------
.../org/apache/ranger/rest/TestTagREST.java | 1816 ++++++++++++++
.../org/apache/ranger/rest/TestUserREST.java | 489 ++++
.../org/apache/ranger/rest/TestXAuditREST.java | 219 ++
.../org/apache/ranger/rest/TestXKeyREST.java | 236 ++
.../org/apache/ranger/rest/TestXUserREST.java | 2238 ++++++++++++++++++
.../ranger/service/TestRangerTagDefService.java | 274 +++
.../service/TestRangerTagDefServiceBase.java | 77 +
7 files changed, 5349 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/rest/TestTagREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestTagREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestTagREST.java
new file mode 100644
index 0000000..fabd384
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestTagREST.java
@@ -0,0 +1,1816 @@
+/*
+ * 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.List;
+
+import javax.ws.rs.WebApplicationException;
+
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.biz.ServiceDBStore;
+import org.apache.ranger.biz.TagDBStore;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXServiceDao;
+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.model.RangerServiceResource;
+import org.apache.ranger.plugin.model.RangerTag;
+import org.apache.ranger.plugin.model.RangerTagDef;
+import org.apache.ranger.plugin.model.RangerTagResourceMap;
+import org.apache.ranger.plugin.store.TagValidator;
+import org.apache.ranger.plugin.util.SearchFilter;
+import org.apache.ranger.plugin.util.ServiceTags;
+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 TestTagREST {
+ private static Long id = 1L;
+ private static String gId = "1427365526516_835_0";
+ private static String name = "test";
+ private static String serviceName = "HDFS";
+ private static String resourceSignature = "testResourceSign";
+ private static String tagGuid = "8787878787_09_1";
+ private static String resourceGuid = "9898989898_09_1";
+ private static Long lastKnownVersion = 10L;
+ private static String pluginId = "1";
+ private static String Allowed_User_List_For_Tag_Download = "tag.download.auth.users";
+
+ @InjectMocks
+ TagREST tagREST = new TagREST();
+
+ @Mock
+ TagValidator validator;
+
+ @Mock
+ TagDBStore tagStore;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ RangerBizUtil bizUtil;
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ ServiceDBStore svcStore;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void test1createTagDef() {
+ RangerTagDef oldTagDef = null;
+ RangerTagDef newTagDef = new RangerTagDef();
+ newTagDef.setId(id);
+ newTagDef.setName(name);
+
+ try {
+ Mockito.when(validator.preCreateTagDef(oldTagDef, false)).thenReturn(null);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.createTagDef(oldTagDef)).thenReturn(newTagDef);
+ } catch (Exception e) {
+ }
+ RangerTagDef rangerTagDef = tagREST.createTagDef(oldTagDef, false);
+
+ Assert.assertEquals(rangerTagDef.getId(), newTagDef.getId());
+ Assert.assertNotNull(rangerTagDef);
+ Assert.assertEquals(rangerTagDef.getName(), newTagDef.getName());
+
+ try {
+ Mockito.verify(validator).preCreateTagDef(oldTagDef, false);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).createTagDef(oldTagDef);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test2createTagDef() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ RangerTagDef newTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ newTagDef.setId(id);
+ newTagDef.setName(name);
+
+ try {
+ Mockito.when(validator.preCreateTagDef(oldTagDef, true)).thenReturn(
+ oldTagDef);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.updateTagDef(oldTagDef)).thenReturn(newTagDef);
+ } catch (Exception e) {
+ }
+
+ RangerTagDef rangerTagDef = tagREST.createTagDef(oldTagDef, true);
+ Assert.assertEquals(rangerTagDef.getName(), newTagDef.getName());
+ Assert.assertEquals(rangerTagDef.getId(), newTagDef.getId());
+ Assert.assertNotEquals(oldTagDef.getName(), rangerTagDef.getName());
+
+ try {
+ Mockito.verify(validator).preCreateTagDef(oldTagDef, true);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).updateTagDef(oldTagDef);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test3createTagDef() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ RangerTagDef newTagDef = new RangerTagDef();
+ oldTagDef.setId(null);
+ newTagDef.setId(id);
+ newTagDef.setName(name);
+
+ try {
+ Mockito.when(validator.preCreateTagDef(oldTagDef, true)).thenReturn(oldTagDef);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.updateTagDef(oldTagDef)).thenReturn(newTagDef);
+ } catch (Exception e) {
+ }
+
+ RangerTagDef rangerTagDef = tagREST.createTagDef(oldTagDef, true);
+
+ Assert.assertNotNull(rangerTagDef);
+ Assert.assertEquals(rangerTagDef.getId(), newTagDef.getId());
+ Assert.assertEquals(rangerTagDef.getName(), newTagDef.getName());
+ Assert.assertNotEquals(rangerTagDef.getName(), oldTagDef.getName());
+
+ try {
+ Mockito.verify(validator).preCreateTagDef(oldTagDef, true);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).updateTagDef(oldTagDef);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test4createTagDef() {
+ RangerTagDef oldtagDef = new RangerTagDef();
+ oldtagDef.setId(id);
+
+ try {
+ Mockito.when(validator.preCreateTagDef(oldtagDef, false)).thenReturn(
+ oldtagDef);
+ } catch (Exception e) {
+ }
+ Mockito.when(
+ restErrorUtil.createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean())).thenThrow(
+ new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.createTagDef(oldtagDef, false);
+
+ try {
+ Mockito.verify(validator).preCreateTagDef(oldtagDef, false);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test5deleteTagDef(){
+ try {
+ Mockito.doNothing().when(tagStore).deleteTagDef(id);
+ } catch (Exception e) {
+ }
+ tagREST.deleteTagDef(id);
+ try {
+ Mockito.verify(tagStore).deleteTagDef(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test6deleteTagDefByGuid() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ oldTagDef.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTagDefByGuid(oldTagDef.getGuid())).thenReturn(oldTagDef);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteTagDef(oldTagDef.getId());
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTagDefByGuid(oldTagDef.getGuid());
+ Assert.assertNotNull(oldTagDef.getId());
+ Assert.assertNotNull(oldTagDef.getGuid());
+
+ try {
+ Mockito.verify(tagStore).getTagDefByGuid(oldTagDef.getGuid());
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteTagDef(oldTagDef.getId());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test7deleteTagDefByGuid() {
+ try {
+ Mockito.when(tagStore.getTagDefByGuid(gId)).thenReturn(null);
+ } catch (Exception e) {
+ }
+ tagREST.deleteTagDefByGuid(gId);
+ try {
+ Mockito.verify(tagStore).getTagDefByGuid(gId);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test8getTagDef() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ oldTagDef.setName(name);
+
+ try {
+ Mockito.when(tagStore.getTagDef(id)).thenReturn(oldTagDef);
+ } catch (Exception e) {
+ }
+
+ RangerTagDef rangerTagDef = tagREST.getTagDef(id);
+ Assert.assertNotNull(rangerTagDef.getId());
+ Assert.assertEquals(rangerTagDef.getId(), oldTagDef.getId());
+ Assert.assertEquals(rangerTagDef.getName(), oldTagDef.getName());
+
+ try {
+ Mockito.verify(tagStore).getTagDef(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test9getTagDef() {
+ try {
+ Mockito.when(tagStore.getTagDef(id)).thenReturn(null);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.getTagDef(id);
+
+ try {
+ Mockito.verify(tagStore).getTagDef(id);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test10getTagDefByGuid() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ oldTagDef.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTagDefByGuid(gId)).thenReturn(oldTagDef);
+ } catch (Exception e) {
+ }
+
+ RangerTagDef rangerTagDef = tagREST.getTagDefByGuid(gId);
+ Assert.assertNotNull(oldTagDef.getGuid());
+ Assert.assertEquals(rangerTagDef.getGuid(), oldTagDef.getGuid());
+ Assert.assertEquals(rangerTagDef.getId(), oldTagDef.getId());
+
+ try {
+ Mockito.verify(tagStore).getTagDefByGuid(gId);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test11getTagDefByGuid() {
+ try {
+ Mockito.when(tagStore.getTagDefByGuid(gId)).thenReturn(null);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.getTagDefByGuid(gId);
+
+ try {
+ Mockito.verify(tagStore).getTagDefByGuid(gId);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test12getTagDefByName() {
+ RangerTagDef oldTagDef = new RangerTagDef();
+ oldTagDef.setId(id);
+ oldTagDef.setName(name);
+
+ try {
+ Mockito.when(tagStore.getTagDefByName(name)).thenReturn(oldTagDef);
+ } catch (Exception e) {
+ }
+
+ RangerTagDef rangerTagDef = tagREST.getTagDefByName(name);
+ Assert.assertNotNull(rangerTagDef.getName());
+ Assert.assertEquals(rangerTagDef.getName(), oldTagDef.getName());
+ Assert.assertEquals(rangerTagDef.getId(), oldTagDef.getId());
+
+ try {
+ Mockito.verify(tagStore).getTagDefByName(name);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test13getTagDefByName() {
+ try {
+ Mockito.when(tagStore.getTagDefByName(name)).thenReturn(null);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.getTagDefByName(name);
+
+ try {
+ Mockito.verify(tagStore).getTagDefByName(name);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test14getAllTagDefs() {
+ List<RangerTagDef> ret = new ArrayList<RangerTagDef>();
+ RangerTagDef rangerTagDef = new RangerTagDef();
+ rangerTagDef.setId(id);
+ rangerTagDef.setVersion(5L);
+ ret.add(rangerTagDef);
+
+ try {
+ Mockito.when(tagStore.getTagDefs((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+ List<RangerTagDef> result = tagREST.getAllTagDefs();
+
+ Assert.assertNotNull(result);
+ Assert.assertEquals(result.get(0).getId(), ret.get(0).getId());
+ Assert.assertEquals(result.get(0).getVersion(), ret.get(0).getVersion());
+
+ try {
+ Mockito.verify(tagStore).getTagDefs((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test15getAllTagDefs() {
+ try {
+ Mockito.when(tagStore.getTagDefs((SearchFilter)Mockito.anyObject())).thenReturn(null);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.getAllTagDefs();
+
+ try {
+ Mockito.verify(tagStore).getTagDefs((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),
+ Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test16getTagTypes(){
+ List<String> ret = new ArrayList<String>();
+ ret.add(name);
+
+ try {
+ Mockito.when(tagStore.getTagTypes()).thenReturn(ret);
+ } catch (Exception e) {
+ }
+ List<String> result = tagREST.getTagTypes();
+ Assert.assertNotNull(result);
+
+ try {
+ Mockito.verify(tagStore).getTagTypes();
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test17createTag() {
+ RangerTag oldTag = null;
+ RangerTag newTag = new RangerTag();
+ newTag.setId(id);
+ newTag.setGuid(gId);
+
+ try {
+ Mockito.when(validator.preCreateTag(oldTag)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.createTag(oldTag)).thenReturn(newTag);
+ } catch (Exception e) {
+ }
+ RangerTag rangerTag = tagREST.createTag(oldTag, false);
+
+ Assert.assertEquals(rangerTag.getId(),newTag.getId());
+ Assert.assertEquals(rangerTag.getGuid(), newTag.getGuid());
+
+ try {
+ Mockito.verify(validator).preCreateTag(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).createTag(oldTag);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test18createTag(){
+ RangerTag oldTag = new RangerTag();
+ RangerTag newTag = new RangerTag();
+ oldTag.setId(id);
+ newTag.setId(id);
+ newTag.setVersion(5L);
+
+ try {
+ Mockito.when(validator.preCreateTag(oldTag)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(validator).preUpdateTag(oldTag.getId(), oldTag);
+ } catch (Exception e1) {
+ }
+ try {
+ Mockito.when(tagStore.updateTag(oldTag)).thenReturn(newTag);
+ } catch (Exception e) {
+ }
+
+ RangerTag rangerTag = tagREST.createTag(oldTag,true);
+ Assert.assertEquals(rangerTag.getVersion(), newTag.getVersion());
+ Assert.assertNotNull(newTag.getVersion());
+ Assert.assertNotEquals(oldTag.getVersion(), newTag.getVersion());
+ Assert.assertEquals(oldTag.getId(), newTag.getId());
+
+ try {
+ Mockito.verify(validator).preCreateTag(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(validator).preUpdateTag(oldTag.getId(), oldTag);
+ } catch (Exception e1) {
+ }
+ try {
+ Mockito.verify(tagStore).updateTag(oldTag);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test19createTag(){
+ RangerTag oldTag = new RangerTag();
+ oldTag.setId(id);
+
+ try {
+ Mockito.when(validator.preCreateTag(oldTag)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.createTag(oldTag,false);
+
+ try {
+ Mockito.verify(validator).preCreateTag(oldTag);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test20updateTagByGuid() {
+ RangerTag oldTag = new RangerTag();
+ RangerTag newTag = new RangerTag();
+ oldTag.setGuid(gId);
+ newTag.setGuid(gId);
+ newTag.setVersion(5L);
+
+ try {
+ Mockito.doNothing().when(validator).preUpdateTagByGuid(gId, oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.updateTag(oldTag)).thenReturn(newTag);
+ } catch (Exception e) {
+ }
+
+ RangerTag rangerTag = tagREST.updateTagByGuid(gId, oldTag);
+ Assert.assertEquals(oldTag.getGuid(), newTag.getGuid());
+ Assert.assertNotEquals(rangerTag.getVersion(), oldTag.getVersion());
+ Assert.assertEquals(rangerTag.getVersion(), newTag.getVersion());
+
+ try {
+ Mockito.verify(validator).preUpdateTagByGuid(gId, oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).updateTag(oldTag);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test21deleteTag() {
+ RangerTag oldTag = new RangerTag();
+ oldTag.setId(id);
+
+ try {
+ Mockito.when(validator.preDeleteTag(id)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteTag(id);
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTag(id);
+ Assert.assertNotNull(oldTag.getId());
+
+ try {
+ Mockito.verify(validator).preDeleteTag(id);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteTag(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test22deleteTagByGuid() {
+ RangerTag oldTag = new RangerTag();
+ oldTag.setId(id);
+ oldTag.setGuid(gId);
+
+ try {
+ Mockito.when(validator.preDeleteTagByGuid(gId)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteTag(oldTag.getId());
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTagByGuid(gId);
+ Assert.assertNotNull(oldTag.getId());
+ Assert.assertNotNull(oldTag.getGuid());
+
+ try {
+ Mockito.verify(validator).preDeleteTagByGuid(gId);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteTag(oldTag.getId());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test23getTag() {
+ RangerTag oldTag = new RangerTag();
+ oldTag.setId(id);
+ oldTag.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTag(id)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ RangerTag rangerTag = tagREST.getTag(id);
+ Assert.assertNotNull(oldTag.getId());
+ Assert.assertEquals(rangerTag.getId(), oldTag.getId());
+ Assert.assertEquals(rangerTag.getGuid(), oldTag.getGuid());
+
+ try {
+ Mockito.verify(tagStore).getTag(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test24getTagByGuid() {
+ RangerTag oldTag = new RangerTag();
+ oldTag.setId(id);
+ oldTag.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTagByGuid(gId)).thenReturn(oldTag);
+ } catch (Exception e) {
+ }
+ RangerTag rangerTag = tagREST.getTagByGuid(gId);
+ Assert.assertNotNull(oldTag.getGuid());
+ Assert.assertEquals(rangerTag.getGuid(), oldTag.getGuid());
+ Assert.assertEquals(rangerTag.getId(), oldTag.getId());
+ Assert.assertNotNull(rangerTag.getId());
+
+ try {
+ Mockito.verify(tagStore).getTagByGuid(gId);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test25getTagsByType() {
+ String type = "file";
+ List<RangerTag> tag = new ArrayList<RangerTag>();
+ RangerTag rTag = new RangerTag();
+ rTag.setType(type);
+ tag.add(rTag);
+
+ try {
+ Mockito.when(tagStore.getTagsByType(type)).thenReturn(tag);
+ } catch (Exception e) {
+ }
+ List<RangerTag> rangerTag = tagREST.getTagsByType(type);
+ Assert.assertEquals(rangerTag.get(0).getType(), tag.get(0).getType());
+
+ try {
+ Mockito.verify(tagStore).getTagsByType(type);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test26getAllTags() {
+ List<RangerTag> ret = new ArrayList<RangerTag>();
+ RangerTag rangerTag = new RangerTag();
+ rangerTag.setId(id);
+ rangerTag.setGuid(gId);
+ ret.add(rangerTag);
+
+ try {
+ Mockito.when(tagStore.getTags((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+
+ List<RangerTag> result = tagREST.getAllTags();
+ Assert.assertEquals(result.get(0).getId(), ret.get(0).getId());
+ Assert.assertEquals(result.get(0).getVersion(), ret.get(0).getVersion());
+ Assert.assertNotNull(result.get(0).getId());
+
+ try {
+ Mockito.verify(tagStore).getTags((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test60getAllTags() {
+ List<RangerTag> ret = new ArrayList<RangerTag>();
+
+ try {
+ Mockito.when(tagStore.getTags((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+
+ List<RangerTag> result = tagREST.getAllTags();
+ Assert.assertNotNull(result);
+
+ try {
+ Mockito.verify(tagStore).getTags((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test27createServiceResource() {
+ RangerServiceResource oldRSR = null;
+ RangerServiceResource newRSR = new RangerServiceResource();
+ newRSR.setId(id);
+ newRSR.setGuid(gId);
+
+ try {
+ Mockito.when(validator.preCreateServiceResource(oldRSR)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.createServiceResource(oldRSR)).thenReturn(newRSR);
+ } catch (Exception e) {
+ }
+
+ RangerServiceResource rangerServiceResource = tagREST.createServiceResource(oldRSR, false);
+ Assert.assertNotNull(rangerServiceResource.getId());
+ Assert.assertEquals(rangerServiceResource.getId(), newRSR.getId());
+ Assert.assertEquals(rangerServiceResource.getGuid(), newRSR.getGuid());
+
+ try {
+ Mockito.verify(validator).preCreateServiceResource(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).createServiceResource(oldRSR);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test28createServiceResource() {
+ RangerServiceResource oldRSR = new RangerServiceResource();
+ RangerServiceResource newRSR = new RangerServiceResource();
+ oldRSR.setId(id);
+ newRSR.setId(id);
+ newRSR.setVersion(5L);
+
+ try {
+ Mockito.when(validator.preCreateServiceResource(oldRSR)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(validator).preUpdateServiceResource(oldRSR.getId(), oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.updateServiceResource(oldRSR)).thenReturn(newRSR);
+ } catch (Exception e) {
+ }
+
+ RangerServiceResource rangerServiceResource = tagREST.createServiceResource(oldRSR, true);
+ Assert.assertNotEquals(oldRSR.getVersion(), newRSR.getVersion());
+ Assert.assertEquals(rangerServiceResource.getId(), newRSR.getId());
+ Assert.assertEquals(rangerServiceResource.getId(), oldRSR.getId());
+
+ try {
+ Mockito.verify(validator).preCreateServiceResource(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(validator).preUpdateServiceResource(oldRSR.getId(), oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).updateServiceResource(oldRSR);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test29createServiceResource(){
+ RangerServiceResource oldRSR = new RangerServiceResource();
+
+ try {
+ Mockito.when(validator.preCreateServiceResource(oldRSR)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.createServiceResource(oldRSR, false);
+
+ try {
+ Mockito.verify(validator).preCreateServiceResource(oldRSR);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test30updateServiceResourceByGuid() {
+ RangerServiceResource oldSRS = new RangerServiceResource();
+ RangerServiceResource newSRS = new RangerServiceResource();
+ oldSRS.setId(id);
+ oldSRS.setGuid(gId);
+ newSRS.setId(id);
+ newSRS.setGuid(gId);
+ newSRS.setVersion(5L);
+
+ try {
+ Mockito.doNothing().when(validator).preUpdateServiceResourceByGuid(gId, oldSRS);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.updateServiceResource(oldSRS)).thenReturn(newSRS);
+ } catch (Exception e) {
+ }
+
+ RangerServiceResource rangerServiceResource = tagREST.updateServiceResourceByGuid(gId, oldSRS);
+ Assert.assertEquals(oldSRS.getId(), newSRS.getId());
+ Assert.assertEquals(oldSRS.getGuid(), newSRS.getGuid());
+ Assert.assertNotEquals(oldSRS.getVersion(), newSRS.getVersion());
+ Assert.assertEquals(rangerServiceResource.getVersion(), newSRS.getVersion());
+
+ try {
+ Mockito.verify(validator).preUpdateServiceResourceByGuid(gId, oldSRS);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).updateServiceResource(oldSRS);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test31deleteServiceResource() {
+ RangerServiceResource oldSRS = new RangerServiceResource();
+ oldSRS.setId(id);
+
+ try {
+ Mockito.when(validator.preDeleteServiceResource(id)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteServiceResource(id);
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteServiceResource(id);
+ Assert.assertNotNull(oldSRS.getId());
+
+ try {
+ Mockito.verify(validator).preDeleteServiceResource(id);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteServiceResource(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test32getServiceResource() {
+ RangerServiceResource oldSRS = new RangerServiceResource();
+ oldSRS.setId(id);
+ oldSRS.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getServiceResource(id)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+ RangerServiceResource rangerServiceResource = tagREST.getServiceResource(id);
+
+ Assert.assertNotNull(rangerServiceResource);
+ Assert.assertEquals(rangerServiceResource.getId(), oldSRS.getId());
+ Assert.assertEquals(rangerServiceResource.getGuid(), oldSRS.getGuid());
+ try {
+ Mockito.verify(tagStore).getServiceResource(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test33getServiceResourceByGuid() {
+ RangerServiceResource oldSRS = new RangerServiceResource();
+ oldSRS.setId(id);
+ oldSRS.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getServiceResourceByGuid(gId)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+ RangerServiceResource rangerServiceResource = tagREST.getServiceResourceByGuid(gId);
+
+ Assert.assertNotNull(rangerServiceResource);
+ Assert.assertEquals(rangerServiceResource.getGuid(), oldSRS.getGuid());
+ Assert.assertEquals(rangerServiceResource.getId(), oldSRS.getId());
+ try {
+ Mockito.verify(tagStore).getServiceResourceByGuid(gId);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test34getServiceResourcesByService() {
+ List<RangerServiceResource> ret = new ArrayList<RangerServiceResource>();
+ RangerServiceResource rangerServiceResource = new RangerServiceResource();
+ rangerServiceResource.setId(id);
+ rangerServiceResource.setServiceName(serviceName);
+ ret.add(rangerServiceResource);
+
+ try {
+ Mockito.when(tagStore.getServiceResourcesByService(serviceName)).thenReturn(ret);
+ } catch (Exception e) {
+ }
+
+ List<RangerServiceResource> reslut = tagREST.getServiceResourcesByService(serviceName);
+ Assert.assertNotNull(reslut.get(0).getId());
+ Assert.assertEquals(reslut.get(0).getId(), ret.get(0).getId());
+ Assert.assertEquals(reslut.get(0).getServiceName(), ret.get(0).getServiceName());
+
+ try {
+ Mockito.verify(tagStore).getServiceResourcesByService(serviceName);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test35getServiceResourcesByService() {
+ List<RangerServiceResource> oldSRS = new ArrayList<RangerServiceResource>();
+ RangerServiceResource rangerServiceResource = new RangerServiceResource();
+ rangerServiceResource.setId(id);
+ rangerServiceResource.setServiceName(serviceName);
+ oldSRS.add(rangerServiceResource);
+
+ try {
+ Mockito.when(tagStore.getServiceResourcesByService(serviceName)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+
+ List<RangerServiceResource> result = tagREST.getServiceResourcesByService(serviceName);
+ Assert.assertNotNull(result);
+ Assert.assertEquals(result.size(), 1);
+ Assert.assertEquals(result.get(0).getId(), id);
+ Assert.assertEquals(result.get(0).getServiceName(), serviceName);
+
+ try {
+ Mockito.verify(tagStore).getServiceResourcesByService(serviceName);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test59getServiceResourcesByService() {
+ List<RangerServiceResource> oldSRS = new ArrayList<RangerServiceResource>();
+
+ try {
+ Mockito.when(tagStore.getServiceResourcesByService(serviceName)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+
+ List<RangerServiceResource> result = tagREST.getServiceResourcesByService(serviceName);
+ Assert.assertNotNull(result);
+
+ try {
+ Mockito.verify(tagStore).getServiceResourcesByService(serviceName);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test36getServiceResourceByServiceAndResourceSignature() {
+ RangerServiceResource oldSRS = new RangerServiceResource();
+ oldSRS.setId(id);
+ oldSRS.setResourceSignature(resourceSignature);
+ oldSRS.setServiceName(serviceName);
+
+ try {
+ Mockito.when(tagStore.getServiceResourceByServiceAndResourceSignature(serviceName, resourceSignature)).thenReturn(oldSRS);
+ } catch (Exception e) {
+ }
+
+ RangerServiceResource rangerServiceResource = tagREST.getServiceResourceByServiceAndResourceSignature(serviceName, resourceSignature);
+ Assert.assertEquals(rangerServiceResource.getId(), oldSRS.getId());
+ Assert.assertEquals(rangerServiceResource.getServiceName(), oldSRS.getServiceName());
+ Assert.assertEquals(rangerServiceResource.getResourceSignature(), oldSRS.getResourceSignature());
+
+ try {
+ Mockito.verify(tagStore).getServiceResourceByServiceAndResourceSignature(serviceName, resourceSignature);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test37getAllServiceResources() {
+ List<RangerServiceResource> ret = new ArrayList<RangerServiceResource>();
+ RangerServiceResource rangerServiceResource = new RangerServiceResource();
+ rangerServiceResource.setId(id);
+ rangerServiceResource.setServiceName(serviceName);
+ ret.add(rangerServiceResource);
+
+ try {
+ Mockito.when(tagStore.getServiceResources((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+ List<RangerServiceResource> result = tagREST.getAllServiceResources();
+ Assert.assertNotNull(result.get(0).getId());
+ Assert.assertEquals(result.get(0).getId(), ret.get(0).getId());
+ Assert.assertEquals(result.get(0).getServiceName(), ret.get(0).getServiceName());
+
+ try {
+ Mockito.verify(tagStore).getServiceResources((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test38createTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = null;
+ RangerTagResourceMap newTagResourceMap = new RangerTagResourceMap();
+ newTagResourceMap.setTagId(id);
+ newTagResourceMap.setResourceId(id);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(validator.preCreateTagResourceMap(tagGuid, resourceGuid)).thenReturn(newTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.createTagResourceMap(newTagResourceMap)).thenReturn(newTagResourceMap);
+ } catch (Exception e) {
+ }
+
+ RangerTagResourceMap rangerTagResourceMap = tagREST.createTagResourceMap(tagGuid, resourceGuid, false);
+ Assert.assertEquals(rangerTagResourceMap.getTagId(), newTagResourceMap.getTagId());
+ Assert.assertEquals(rangerTagResourceMap.getResourceId(), newTagResourceMap.getResourceId());
+
+ try {
+ Mockito.verify(tagStore).getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(validator).preCreateTagResourceMap(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).createTagResourceMap(newTagResourceMap);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test39createTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+
+ try {
+ Mockito.when(tagStore.getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(),Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ tagREST.createTagResourceMap(tagGuid, resourceGuid, false);
+
+ try {
+ Mockito.verify(tagStore).getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test40createTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = null;
+ RangerTagResourceMap newTagResourceMap = new RangerTagResourceMap();
+ newTagResourceMap.setId(id);
+ newTagResourceMap.setGuid(gId);
+ RangerTagResourceMap finalTagResourceMap = new RangerTagResourceMap();
+ finalTagResourceMap.setId(id);
+ finalTagResourceMap.setGuid(gId);
+ finalTagResourceMap.setVersion(5L);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(validator.preCreateTagResourceMap(tagGuid, resourceGuid)).thenReturn(newTagResourceMap);
+ } catch (Exception e1) {
+ }
+ try {
+ Mockito.when(tagStore.createTagResourceMap(newTagResourceMap)).thenReturn(finalTagResourceMap);
+ } catch (Exception e1) {
+ }
+ RangerTagResourceMap result = tagREST.createTagResourceMap(tagGuid, resourceGuid, true);
+ Assert.assertNotNull(result.getId());
+ Assert.assertEquals(result.getGuid(), finalTagResourceMap.getGuid());
+ Assert.assertEquals(result.getId(), finalTagResourceMap.getId());
+ Assert.assertEquals(result.getVersion(), finalTagResourceMap.getVersion());
+
+ try {
+ Mockito.verify(tagStore).getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(validator).preCreateTagResourceMap(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).createTagResourceMap(newTagResourceMap);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test41deleteTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+ try {
+ Mockito.when(validator.preDeleteTagResourceMap(id)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteTagResourceMap(id);
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTagResourceMap(id);
+ Assert.assertNotNull(oldTagResourceMap.getId());
+ try {
+ Mockito.verify(validator).preDeleteTagResourceMap(id);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteTagResourceMap(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test42deleteTagResourceMapByGuid() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+ oldTagResourceMap.setGuid(gId);
+ try {
+ Mockito.when(validator.preDeleteTagResourceMapByGuid(gId)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteServiceResource(oldTagResourceMap.getId());
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTagResourceMapByGuid(gId);
+ Assert.assertNotNull(oldTagResourceMap.getId());
+ Assert.assertNotNull(oldTagResourceMap.getGuid());
+
+ try {
+ Mockito.verify(validator).preDeleteTagResourceMapByGuid(gId);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).deleteServiceResource(oldTagResourceMap.getId());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test43deleteTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+
+ try {
+ Mockito.when(validator.preDeleteTagResourceMap(tagGuid, resourceGuid)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteTagResourceMap(oldTagResourceMap.getId());
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteTagResourceMap(tagGuid, resourceGuid);
+ try {
+ Mockito.verify(validator).preDeleteTagResourceMap(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test44getTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+ oldTagResourceMap.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMap(id)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+
+ RangerTagResourceMap rangerTagResourceMap = tagREST.getTagResourceMap(id);
+ Assert.assertNotNull(rangerTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getId(), oldTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getGuid(), oldTagResourceMap.getGuid());
+ try {
+ Mockito.verify(tagStore).getTagResourceMap(id);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test45getTagResourceMapByGuid() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+ oldTagResourceMap.setGuid(gId);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMapByGuid(gId)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+
+ RangerTagResourceMap rangerTagResourceMap = tagREST.getTagResourceMapByGuid(gId);
+ Assert.assertNotNull(rangerTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getId(), oldTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getGuid(), oldTagResourceMap.getGuid());
+ try {
+ Mockito.verify(tagStore).getTagResourceMapByGuid(gId);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test46getTagResourceMap() {
+ RangerTagResourceMap oldTagResourceMap = new RangerTagResourceMap();
+ oldTagResourceMap.setId(id);
+ oldTagResourceMap.setTagId(id);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid)).thenReturn(oldTagResourceMap);
+ } catch (Exception e) {
+ }
+ RangerTagResourceMap rangerTagResourceMap = tagREST.getTagResourceMap(tagGuid, resourceGuid);
+ Assert.assertNotNull(rangerTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getId(), oldTagResourceMap.getId());
+ Assert.assertEquals(rangerTagResourceMap.getTagId(), oldTagResourceMap.getTagId());
+ try {
+ Mockito.verify(tagStore).getTagResourceMapForTagAndResourceGuid(tagGuid, resourceGuid);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test47getAllTagResourceMaps() {
+ List<RangerTagResourceMap> ret = new ArrayList<RangerTagResourceMap>();
+ RangerTagResourceMap rangerTagResourceMap = new RangerTagResourceMap();
+ rangerTagResourceMap.setId(id);
+ rangerTagResourceMap.setTagId(id);
+ ret.add(rangerTagResourceMap);
+
+ try {
+ Mockito.when(tagStore.getTagResourceMaps((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+
+ List<RangerTagResourceMap> result = tagREST.getAllTagResourceMaps();
+ Assert.assertNotNull(result.get(0).getId());
+ Assert.assertEquals(result.get(0).getId(), ret.get(0).getId());
+ Assert.assertEquals(result.get(0).getTagId(), ret.get(0).getTagId());
+
+ try {
+ Mockito.verify(tagStore).getTagResourceMaps((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test58getAllTagResourceMaps() {
+ List<RangerTagResourceMap> ret = new ArrayList<RangerTagResourceMap>();
+
+ try {
+ Mockito.when(tagStore.getTagResourceMaps((SearchFilter)Mockito.anyObject())).thenReturn(ret);
+ } catch (Exception e) {
+ }
+
+ List<RangerTagResourceMap> result = tagREST.getAllTagResourceMaps();
+ Assert.assertNotNull(result);
+
+ try {
+ Mockito.verify(tagStore).getTagResourceMaps((SearchFilter)Mockito.anyObject());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test48deleteServiceResourceByGuid() {
+ RangerServiceResource oldRSR = new RangerServiceResource();
+ oldRSR.setId(id);
+ oldRSR.setGuid(gId);
+ List<RangerTagResourceMap> tagResourceMaps = new ArrayList<RangerTagResourceMap>();
+ RangerTagResourceMap rangerTagResourceMap = new RangerTagResourceMap();
+ rangerTagResourceMap.setId(id);
+ rangerTagResourceMap.setTagId(id);
+ tagResourceMaps.add(rangerTagResourceMap);
+
+ try {
+ Mockito.when(validator.preDeleteServiceResourceByGuid(gId, true)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.getTagResourceMapsForResourceGuid(oldRSR.getGuid())).thenReturn(tagResourceMaps);
+ } catch (Exception e) {
+ }
+ tagREST.deleteServiceResourceByGuid(gId, true);
+
+ try {
+ Mockito.verify(validator).preDeleteServiceResourceByGuid(gId, true);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).getTagResourceMapsForResourceGuid(oldRSR.getGuid());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test49deleteServiceResourceByGuid() {
+ RangerServiceResource oldRSR = new RangerServiceResource();
+ oldRSR.setId(id);
+ oldRSR.setGuid(gId);
+
+ try {
+ Mockito.when(validator.preDeleteServiceResourceByGuid(gId, false)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.doNothing().when(tagStore).deleteServiceResource(oldRSR.getId());
+ } catch (Exception e) {
+ }
+
+ tagREST.deleteServiceResourceByGuid(gId, false);
+
+ try {
+ Mockito.verify(validator).preDeleteServiceResourceByGuid(gId, false);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test61deleteServiceResourceByGuid() {
+ RangerServiceResource oldRSR = new RangerServiceResource();
+ oldRSR.setId(id);
+ oldRSR.setGuid(gId);
+ List<RangerTagResourceMap> tagResourceMaps = new ArrayList<RangerTagResourceMap>();
+
+ try {
+ Mockito.when(validator.preDeleteServiceResourceByGuid(gId, true)).thenReturn(oldRSR);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.when(tagStore.getTagResourceMapsForResourceGuid(oldRSR.getGuid())).thenReturn(tagResourceMaps);
+ } catch (Exception e) {
+ }
+ tagREST.deleteServiceResourceByGuid(gId, true);
+
+ try {
+ Mockito.verify(validator).preDeleteServiceResourceByGuid(gId, true);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).getTagResourceMapsForResourceGuid(oldRSR.getGuid());
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test50getServiceTagsIfUpdated() {
+ ServiceTags oldServiceTag = null;
+
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(),Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ tagREST.getServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(),Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test51getServiceTagsIfUpdated() {
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+
+ ServiceTags serviceTags = tagREST.getServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+ Assert.assertEquals(serviceTags.getServiceName(), oldServiceTag.getServiceName());
+ Assert.assertEquals(serviceTags.getTagVersion(), oldServiceTag.getTagVersion());
+
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test52getSecureServiceTagsIfUpdatedIsKeyAdminTrue() {
+ boolean isAdmin = false;
+ boolean isKeyAdmin = true;
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+ xServiceDef.setImplclassname("org.apache.ranger.services.kms.RangerServiceKMS");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+
+ ServiceTags result = tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+ Assert.assertNotNull(result.getServiceName());
+ Assert.assertEquals(result.getServiceName(), oldServiceTag.getServiceName());
+ Assert.assertEquals(result.getTagVersion(), oldServiceTag.getTagVersion());
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test53getSecureServiceTagsIfUpdatedIsAdminTrue() {
+ boolean isAdmin = true;
+ boolean isKeyAdmin = false;
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+
+ ServiceTags result = tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+ Assert.assertNotNull(result.getServiceName());
+ Assert.assertEquals(result.getServiceName(), oldServiceTag.getServiceName());
+ Assert.assertEquals(result.getTagVersion(), oldServiceTag.getTagVersion());
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test54getSecureServiceTagsIfUpdatedIsKeyAdminFalse() {
+ boolean isAdmin = false;
+ boolean isKeyAdmin = false;
+ boolean isAllowed = true;
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+ xServiceDef.setImplclassname("org.apache.ranger.services.kms.RangerServiceKMS");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ Mockito.when(bizUtil.isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download)).thenReturn(isAllowed);
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+
+ ServiceTags result = tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+ Assert.assertNotNull(result.getServiceName());
+ Assert.assertEquals(result.getServiceName(), oldServiceTag.getServiceName());
+ Assert.assertEquals(result.getTagVersion(), oldServiceTag.getTagVersion());
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ Mockito.verify(bizUtil).isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download);
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test55getSecureServiceTagsIfUpdatedIsAdminFalse() {
+ boolean isAdmin = false;
+ boolean isKeyAdmin = false;
+ boolean isAllowed = true;
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ Mockito.when(bizUtil.isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download)).thenReturn(isAllowed);
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+
+ ServiceTags result = tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+ Assert.assertNotNull(result.getServiceName());
+ Assert.assertEquals(result.getServiceName(), oldServiceTag.getServiceName());
+ Assert.assertEquals(result.getTagVersion(), oldServiceTag.getTagVersion());
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ Mockito.verify(bizUtil).isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download);
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ }
+
+ @Test
+ public void test56getSecureServiceTagsIfUpdatedIsAllowedFalse() {
+ boolean isAdmin = false;
+ boolean isKeyAdmin = false;
+ boolean isAllowed = false;
+ ServiceTags oldServiceTag = new ServiceTags();
+ oldServiceTag.setServiceName(serviceName);
+ oldServiceTag.setTagVersion(5L);
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ Mockito.when(bizUtil.isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download)).thenReturn(isAllowed);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ Mockito.verify(bizUtil).isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+
+ @Test
+ public void test57getSecureServiceTagsIfUpdated() {
+ boolean isAdmin = false;
+ boolean isKeyAdmin = false;
+ boolean isAllowed = true;
+ ServiceTags oldServiceTag = null;
+
+ XXService xService = new XXService();
+ xService.setId(id);
+ xService.setName(serviceName);
+ xService.setType(5L);
+
+ XXServiceDef xServiceDef = new XXServiceDef();
+ xServiceDef.setId(id);
+ xServiceDef.setVersion(5L);
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(id);
+ rangerService.setName(serviceName);
+
+ XXServiceDao xXServiceDao = Mockito.mock(XXServiceDao.class);
+ XXServiceDefDao xXServiceDefDao = Mockito.mock(XXServiceDefDao.class);
+
+ Mockito.when(bizUtil.isAdmin()).thenReturn(isAdmin);
+ Mockito.when(bizUtil.isKeyAdmin()).thenReturn(isKeyAdmin);
+
+ Mockito.when(daoManager.getXXService()).thenReturn(xXServiceDao);
+ Mockito.when(xXServiceDao.findByName(serviceName)).thenReturn(xService);
+ Mockito.when(daoManager.getXXServiceDef()).thenReturn(xXServiceDefDao);
+ Mockito.when(xXServiceDefDao.getById(xService.getType())).thenReturn(xServiceDef);
+ try {
+ Mockito.when(svcStore.getServiceByName(serviceName)).thenReturn(rangerService);
+ } catch (Exception e) {
+ }
+
+ Mockito.when(bizUtil.isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download)).thenReturn(isAllowed);
+ try {
+ Mockito.when(tagStore.getServiceTagsIfUpdated(serviceName, lastKnownVersion)).thenReturn(oldServiceTag);
+ } catch (Exception e) {
+ }
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ tagREST.getSecureServiceTagsIfUpdated(serviceName, lastKnownVersion, pluginId);
+
+ Mockito.verify(bizUtil).isAdmin();
+ Mockito.verify(bizUtil).isKeyAdmin();
+ Mockito.verify(daoManager).getXXService();
+ Mockito.verify(xXServiceDao).findByName(serviceName);
+ Mockito.verify(daoManager).getXXServiceDef();
+ Mockito.verify(xXServiceDefDao).getById(xService.getType());
+ try {
+ Mockito.verify(svcStore).getServiceByName(serviceName);
+ } catch (Exception e) {
+ }
+ Mockito.verify(bizUtil).isUserAllowed(rangerService, Allowed_User_List_For_Tag_Download);
+ try {
+ Mockito.verify(tagStore).getServiceTagsIfUpdated(serviceName, lastKnownVersion);
+ } catch (Exception e) {
+ }
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyInt(), Mockito.anyString(), Mockito.anyBoolean());
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/rest/TestUserREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestUserREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestUserREST.java
new file mode 100644
index 0000000..a5ed33c
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestUserREST.java
@@ -0,0 +1,489 @@
+/*
+ * 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.List;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import javax.ws.rs.WebApplicationException;
+
+import org.apache.ranger.biz.UserMgr;
+import org.apache.ranger.biz.XUserMgr;
+import org.apache.ranger.common.MessageEnums;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerConfigUtil;
+import org.apache.ranger.common.RangerConstants;
+import org.apache.ranger.common.SearchCriteria;
+import org.apache.ranger.common.SearchUtil;
+import org.apache.ranger.common.StringUtil;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXPortalUserDao;
+import org.apache.ranger.entity.XXPortalUser;
+import org.apache.ranger.util.RangerRestUtil;
+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.VXStringList;
+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 TestUserREST {
+
+ @InjectMocks
+ UserREST userREST = new UserREST();
+
+ @Mock
+ HttpServletRequest request;
+
+ @Mock
+ SearchUtil searchUtil;
+
+ @Mock
+ RangerConfigUtil configUtil;
+
+ @Mock
+ UserMgr userManager;
+
+ @Mock
+ RangerDaoManager daoManager;
+
+ @Mock
+ XUserMgr xUserMgr;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ VXPortalUserList vXPUserExpList;
+
+ @Mock
+ RangerRestUtil msRestUtil;
+
+ @Mock
+ VXPortalUser vxPUserAct;
+
+ @Mock
+ VXPasswordChange changePassword;
+
+ @Mock
+ VXResponse responseExp;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ Long userId = 10l;
+ int pageSize = 100;
+ String firstName = "abc";
+ String lastName = "xyz";
+ String loginId = "xyzId";
+ String emailId = "abc@Example.com";
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void test1SearchUsers() {
+ SearchCriteria searchCriteria = new SearchCriteria();
+ vXPUserExpList = new VXPortalUserList();
+ vXPUserExpList.setPageSize(pageSize);
+ List<Integer> status = new ArrayList<Integer>();
+ String publicScreenName = "nrp";
+ List<String> roles = new ArrayList<String>();
+ String[] approvedSortByParams = new String[] { "requestDate", "approvedDate", "activationDate", "emailAddress",
+ "firstName", "lastName" };
+
+ Mockito.when(searchUtil.extractCommonCriterias(request, approvedSortByParams)).thenReturn(searchCriteria);
+ Mockito.when(searchUtil.extractLong(request, searchCriteria, "userId", "User Id")).thenReturn(userId);
+ Mockito.when(searchUtil.extractString(request, searchCriteria, "loginId", "Login Id", null))
+ .thenReturn(loginId);
+ Mockito.when(searchUtil.extractString(request, searchCriteria, "emailAddress", "Email Address", null))
+ .thenReturn(emailId);
+ Mockito.when(searchUtil.extractString(request, searchCriteria, "firstName", "First Name",
+ StringUtil.VALIDATION_NAME)).thenReturn(firstName);
+ Mockito.when(
+ searchUtil.extractString(request, searchCriteria, "lastName", "Last Name", StringUtil.VALIDATION_NAME))
+ .thenReturn(lastName);
+ Mockito.when(searchUtil.extractEnum(request, searchCriteria, "status", "Status", "statusList",
+ RangerConstants.ActivationStatus_MAX)).thenReturn(status);
+ Mockito.when(searchUtil.extractString(request, searchCriteria, "publicScreenName", "Public Screen Name",
+ StringUtil.VALIDATION_NAME)).thenReturn(publicScreenName);
+ Mockito.when(searchUtil.extractStringList(request, searchCriteria, "role", "Role", "roleList",
+ configUtil.getRoles(), StringUtil.VALIDATION_NAME)).thenReturn(roles);
+ Mockito.when(userManager.searchUsers(searchCriteria)).thenReturn(vXPUserExpList);
+
+ VXPortalUserList vXPUserListAct = userREST.searchUsers(request);
+
+ Assert.assertNotNull(vXPUserListAct);
+ Assert.assertEquals(vXPUserExpList, vXPUserListAct);
+ Assert.assertEquals(vXPUserExpList.getPageSize(), vXPUserListAct.getPageSize());
+
+ Mockito.verify(searchUtil).extractCommonCriterias(request, approvedSortByParams);
+ Mockito.verify(searchUtil).extractLong(request, searchCriteria, "userId", "User Id");
+ Mockito.verify(searchUtil).extractString(request, searchCriteria, "loginId", "Login Id", null);
+ Mockito.verify(searchUtil).extractString(request, searchCriteria, "emailAddress", "Email Address", null);
+ Mockito.verify(searchUtil).extractString(request, searchCriteria, "firstName", "First Name",
+ StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractString(request, searchCriteria, "lastName", "Last Name",
+ StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractEnum(request, searchCriteria, "status", "Status", "statusList",
+ RangerConstants.ActivationStatus_MAX);
+ Mockito.verify(searchUtil).extractString(request, searchCriteria, "publicScreenName", "Public Screen Name",
+ StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractStringList(request, searchCriteria, "role", "Role", "roleList",
+ configUtil.getRoles(), StringUtil.VALIDATION_NAME);
+ Mockito.verify(userManager).searchUsers(searchCriteria);
+ }
+
+ @Test
+ public void test2GetUserProfileForUser() {
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+
+ Mockito.when(userManager.getUserProfile(userId)).thenReturn(vxPUserExp);
+
+ VXPortalUser VXPUserAct = userREST.getUserProfileForUser(userId);
+
+ Assert.assertNotNull(VXPUserAct);
+ Assert.assertEquals(vxPUserExp, VXPUserAct);
+ Assert.assertEquals(vxPUserExp.getLoginId(), VXPUserAct.getLoginId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), VXPUserAct.getFirstName());
+ Assert.assertEquals(vxPUserExp.getEmailAddress(), VXPUserAct.getEmailAddress());
+ Assert.assertEquals(vxPUserExp.getId(), VXPUserAct.getId());
+
+ Mockito.verify(userManager).getUserProfile(userId);
+ }
+
+ @Test
+ public void test3GetUserProfileForUser() {
+ VXPortalUser vxPUserExp = new VXPortalUser();
+ vxPUserExp = null;
+
+ Mockito.when(userManager.getUserProfile(userId)).thenReturn(vxPUserExp);
+
+ VXPortalUser VXPUserAct = userREST.getUserProfileForUser(userId);
+
+ Assert.assertEquals(vxPUserExp, VXPUserAct);
+
+ Mockito.verify(userManager).getUserProfile(userId);
+ }
+
+ @Test
+ public void test6Create() {
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+
+ Mockito.when(userManager.createUser(vxPUserExp)).thenReturn(vxPUserExp);
+
+ VXPortalUser VXPUserAct = userREST.create(vxPUserExp, request);
+
+ Assert.assertNotNull(VXPUserAct);
+ Assert.assertEquals(vxPUserExp.getLoginId(), VXPUserAct.getLoginId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), VXPUserAct.getFirstName());
+ Assert.assertEquals(vxPUserExp.getLastName(), VXPUserAct.getLastName());
+ Assert.assertEquals(vxPUserExp.getEmailAddress(), VXPUserAct.getEmailAddress());
+
+ Mockito.verify(userManager).createUser(vxPUserExp);
+ }
+
+ @Test
+ public void test7CreateDefaultAccountUser() {
+ VXPortalUser vxPUserExp = new VXPortalUser();
+ vxPUserExp = null;
+ Mockito.when(userManager.createDefaultAccountUser(vxPUserExp)).thenReturn(vxPUserExp);
+
+ VXPortalUser VXPUserAct = userREST.createDefaultAccountUser(vxPUserExp, request);
+
+ Assert.assertNull(VXPUserAct);
+
+ Mockito.verify(userManager).createDefaultAccountUser(vxPUserExp);
+ }
+
+ @Test
+ public void test8CreateDefaultAccountUser() {
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+
+ Mockito.when(userManager.createDefaultAccountUser(vxPUserExp)).thenReturn(vxPUserExp);
+ Mockito.doNothing().when(xUserMgr).assignPermissionToUser(vxPUserExp, true);
+
+ VXPortalUser VXPUserAct = userREST.createDefaultAccountUser(vxPUserExp, request);
+
+ Assert.assertNotNull(VXPUserAct);
+ Assert.assertEquals(vxPUserExp, VXPUserAct);
+ Assert.assertEquals(vxPUserExp.getLoginId(), VXPUserAct.getLoginId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), VXPUserAct.getFirstName());
+ Assert.assertEquals(vxPUserExp.getLastName(), VXPUserAct.getLastName());
+ Assert.assertEquals(vxPUserExp.getEmailAddress(), VXPUserAct.getEmailAddress());
+
+ Mockito.verify(userManager).createDefaultAccountUser(vxPUserExp);
+ Mockito.verify(xUserMgr).assignPermissionToUser(vxPUserExp, true);
+ }
+
+ @Test
+ public void test8Update() {
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+ vxPUserExp.setLoginId(loginId);
+ XXPortalUser xxPUserExp = new XXPortalUser();
+ xxPUserExp.setLoginId(loginId);
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(Mockito.anyLong())).thenReturn(xxPUserExp);
+ Mockito.doNothing().when(userManager).checkAccess(xxPUserExp);
+ Mockito.doNothing().when(msRestUtil).validateVUserProfileForUpdate(xxPUserExp, vxPUserExp);
+ Mockito.when(userManager.updateUser(vxPUserExp)).thenReturn(xxPUserExp);
+ Mockito.when(userManager.mapXXPortalUserVXPortalUser(xxPUserExp)).thenReturn(vxPUserExp);
+
+ VXPortalUser vxPUserAct = userREST.update(vxPUserExp, request);
+
+ Assert.assertNotNull(vxPUserAct);
+ Assert.assertEquals(xxPUserExp.getLoginId(), vxPUserAct.getLoginId());
+ Assert.assertEquals(vxPUserExp.getId(), vxPUserAct.getId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), vxPUserAct.getFirstName());
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(Mockito.anyLong());
+ Mockito.verify(userManager).checkAccess(xxPUserExp);
+ Mockito.verify(msRestUtil).validateVUserProfileForUpdate(xxPUserExp, vxPUserExp);
+ Mockito.verify(userManager).updateUser(vxPUserExp);
+ Mockito.verify(userManager).mapXXPortalUserVXPortalUser(xxPUserExp);
+ }
+
+ @Test
+ public void test9Update() {
+ VXPortalUser vxPUserExp = new VXPortalUser();
+ XXPortalUser xxPUserExp = new XXPortalUser();
+ xxPUserExp = null;
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(Mockito.anyLong())).thenReturn(xxPUserExp);
+ Mockito.doNothing().when(userManager).checkAccess(xxPUserExp);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString())).thenReturn(new WebApplicationException());
+
+ thrown.expect(WebApplicationException.class);
+
+ userREST.update(vxPUserExp, request);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(Mockito.anyLong());
+ Mockito.verify(userManager).checkAccess(xxPUserExp);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ @Test
+ public void test10SetUserRoles() {
+ Long userId = 10L;
+ VXResponse responseExp = new VXResponse();
+ VXStringList roleList = new VXStringList();
+ Mockito.doNothing().when(userManager).checkAccess(userId);
+ Mockito.doNothing().when(userManager).setUserRoles(userId, roleList.getVXStrings());
+
+ VXResponse responseAct = userREST.setUserRoles(userId, roleList);
+
+ Assert.assertNotNull(responseAct);
+ Assert.assertEquals(responseExp.getStatusCode(), responseAct.getStatusCode());
+
+ Mockito.verify(userManager).checkAccess(userId);
+ Mockito.verify(userManager).setUserRoles(userId, roleList.getVXStrings());
+ }
+
+ @Test
+ public void test11DeactivateUser() {
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+ XXPortalUser xxPUserExp = new XXPortalUser();
+ xxPUserExp.setLoginId(loginId);
+ xxPUserExp.setStatus(1);
+ vxPUserExp.setStatus(5);
+
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUserExp);
+ Mockito.when(userManager.deactivateUser(xxPUserExp)).thenReturn(vxPUserExp);
+
+ VXPortalUser vxPUserAct = userREST.deactivateUser(userId);
+ Assert.assertNotNull(vxPUserAct);
+ Assert.assertEquals(xxPUserExp.getLoginId(), vxPUserAct.getLoginId());
+ Assert.assertEquals(vxPUserExp.getStatus(), vxPUserAct.getStatus());
+ Assert.assertEquals(vxPUserExp.getId(), vxPUserAct.getId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), vxPUserAct.getFirstName());
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(userManager).deactivateUser(xxPUserExp);
+ }
+
+ @Test
+ public void test12DeactivateUser() {
+ XXPortalUser xxPUserExp = new XXPortalUser();
+ xxPUserExp = null;
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUserExp);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString())).thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ userREST.deactivateUser(userId);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ @Test
+ public void test13GetUserProfile() {
+ HttpSession hs = Mockito.mock(HttpSession.class);
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+ Mockito.when(userManager.getUserProfileByLoginId()).thenReturn(vxPUserExp);
+ Mockito.when(request.getSession()).thenReturn(hs);
+ Mockito.when(hs.getId()).thenReturn("id");
+
+ VXPortalUser vxPUserAct = userREST.getUserProfile(request);
+
+ Assert.assertNotNull(vxPUserAct);
+ Assert.assertEquals(vxPUserExp, vxPUserAct);
+ Assert.assertEquals(vxPUserExp.getId(), vxPUserAct.getId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), vxPUserAct.getFirstName());
+
+ Mockito.verify(userManager).getUserProfileByLoginId();
+ }
+
+ @Test
+ public void test15SuggestUserFirstName() {
+ String op = userREST.suggestUserFirstName(firstName, request);
+ Assert.assertNull(op);
+ }
+
+ @Test
+ public void test16ChangePassword() {
+ XXPortalUser xxPUser = new XXPortalUser();
+ VXResponse vxResponseExp = new VXResponse();
+ vxResponseExp.setStatusCode(10);
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUser);
+ Mockito.doNothing().when(userManager).checkAccess(xxPUser);
+ Mockito.doNothing().when(changePassword).setId(userId);
+ Mockito.when(userManager.changePassword(changePassword)).thenReturn(vxResponseExp);
+ VXResponse vxResponseAct = userREST.changePassword(userId, changePassword);
+
+ Assert.assertNotNull(vxResponseAct);
+ Assert.assertEquals(vxResponseExp, vxResponseAct);
+ Assert.assertEquals(vxResponseExp.getStatusCode(), vxResponseAct.getStatusCode());
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(userManager).checkAccess(xxPUser);
+ Mockito.verify(changePassword).setId(userId);
+ Mockito.verify(userManager).changePassword(changePassword);
+ }
+
+ @Test
+ public void test17ChangePassword() {
+ XXPortalUser xxPUser = new XXPortalUser();
+ xxPUser = null;
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUser);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString())).thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ userREST.changePassword(userId, changePassword);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ @Test
+ public void test18ChangeEmailAddress() {
+ XXPortalUser xxPUser = new XXPortalUser();
+ VXPortalUser vxPUserExp = CreateVXPortalUser();
+
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUser);
+ Mockito.doNothing().when(userManager).checkAccess(xxPUser);
+ Mockito.doNothing().when(changePassword).setId(userId);
+ Mockito.when(userManager.changeEmailAddress(xxPUser, changePassword)).thenReturn(vxPUserExp);
+
+ VXPortalUser vxPortalUserAct = userREST.changeEmailAddress(userId, changePassword);
+
+ Assert.assertNotNull(vxPortalUserAct);
+ Assert.assertEquals(vxPUserExp, vxPortalUserAct);
+ Assert.assertEquals(vxPUserExp.getId(), vxPortalUserAct.getId());
+ Assert.assertEquals(vxPUserExp.getFirstName(), vxPortalUserAct.getFirstName());
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(userManager).checkAccess(xxPUser);
+ Mockito.verify(changePassword).setId(userId);
+ Mockito.verify(userManager).changeEmailAddress(xxPUser, changePassword);
+ }
+
+ @Test
+ public void test19ChangeEmailAddress() {
+ XXPortalUser xxPUser = new XXPortalUser();
+ xxPUser = null;
+ XXPortalUserDao xxPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xxPortalUserDao);
+ Mockito.when(xxPortalUserDao.getById(userId)).thenReturn(xxPUser);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString())).thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ userREST.changeEmailAddress(userId, changePassword);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xxPortalUserDao).getById(userId);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject(),
+ Mockito.anyLong(), Mockito.anyString(), Mockito.anyString());
+ }
+
+ private VXPortalUser CreateVXPortalUser() {
+
+ VXPortalUser vxPUserExp = new VXPortalUser();
+ vxPUserExp.setId(userId);
+ vxPUserExp.setFirstName(firstName);
+ vxPUserExp.setLastName(lastName);
+ vxPUserExp.setEmailAddress(emailId);
+ vxPUserExp.setLoginId(loginId);
+ return vxPUserExp;
+ }
+}
\ No newline at end of file
[3/5] incubator-ranger git commit: RANGER-1170 : Improvement of Unit
Test coverage in Ranger
Posted by ve...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/rest/TestXAuditREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestXAuditREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestXAuditREST.java
new file mode 100644
index 0000000..ef59fba
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestXAuditREST.java
@@ -0,0 +1,219 @@
+/*
+ * 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.List;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.ranger.biz.XAuditMgr;
+import org.apache.ranger.common.SearchCriteria;
+import org.apache.ranger.common.SearchUtil;
+import org.apache.ranger.common.SortField;
+import org.apache.ranger.service.XAccessAuditService;
+import org.apache.ranger.service.XTrxLogService;
+import org.apache.ranger.view.VXAccessAuditList;
+import org.apache.ranger.view.VXLong;
+import org.apache.ranger.view.VXTrxLog;
+import org.apache.ranger.view.VXTrxLogList;
+import org.junit.Assert;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+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 TestXAuditREST {
+
+ @InjectMocks
+ XAuditREST auditREST = new XAuditREST();
+
+ @Mock
+ XAuditMgr xAuditMgr;
+
+ @Mock
+ SearchUtil searchUtil;
+
+ @Mock
+ XTrxLogService xLog;
+
+ @Mock
+ XAccessAuditService xAccessAuditSrv;
+
+ @Mock
+ VXTrxLogList vxExpList;
+
+ @Mock
+ HttpServletRequest request;
+
+ @Mock
+ SearchCriteria searchCriteria;
+
+ Long id = 5L;
+ String name = "test";
+
+ @Test
+ public void Test1getXTrxLog() {
+ VXTrxLog vxExp = new VXTrxLog();
+ vxExp.setId(id);
+ vxExp.setObjectName(name);
+ Mockito.when(xAuditMgr.getXTrxLog(id)).thenReturn(vxExp);
+ VXTrxLog vxAct = auditREST.getXTrxLog(id);
+ Assert.assertNotNull(vxAct);
+ Assert.assertEquals(vxExp, vxAct);
+ Assert.assertEquals(vxExp.getId(), vxAct.getId());
+ Assert.assertEquals(vxExp.getObjectName(), vxAct.getObjectName());
+ Mockito.verify(xAuditMgr).getXTrxLog(id);
+ }
+
+ @Test
+ public void Test2createXTrxLog() {
+ VXTrxLog vxExp = new VXTrxLog();
+ vxExp.setId(id);
+ vxExp.setObjectName(name);
+ Mockito.when(xAuditMgr.createXTrxLog(vxExp)).thenReturn(vxExp);
+ VXTrxLog vxAct = auditREST.createXTrxLog(vxExp);
+ Assert.assertNotNull(vxAct);
+ Assert.assertEquals(vxExp, vxAct);
+ Assert.assertEquals(vxExp.getId(), vxAct.getId());
+ Assert.assertEquals(vxExp.getObjectName(), vxAct.getObjectName());
+ Mockito.verify(xAuditMgr).createXTrxLog(vxExp);
+ }
+
+ @Test
+ public void Test3updateXTrxLog() {
+ VXTrxLog vxPrev = new VXTrxLog();
+ vxPrev.setId(id);
+ vxPrev.setObjectName(name);
+ VXTrxLog vxExp = new VXTrxLog();
+ vxExp.setId(id);
+ vxExp.setObjectName("test1");
+
+ Mockito.when(xAuditMgr.updateXTrxLog(vxPrev)).thenReturn(vxExp);
+
+ VXTrxLog vxAct = auditREST.updateXTrxLog(vxPrev);
+
+ Assert.assertNotNull(vxAct);
+ Assert.assertEquals(vxExp, vxAct);
+ Assert.assertEquals(vxExp.getObjectName(), vxAct.getObjectName());
+
+ Mockito.verify(xAuditMgr).updateXTrxLog(vxPrev);
+ }
+
+ @Test
+ public void Test4deleteXTrxLog() {
+ Mockito.doNothing().when(xAuditMgr).deleteXTrxLog(id, false);
+
+ auditREST.deleteXTrxLog(id, request);
+
+ Mockito.verify(xAuditMgr).deleteXTrxLog(id, false);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void Test5searchXTrxLog() {
+ VXTrxLogList vxExpList = new VXTrxLogList();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ searchCriteria.addParam("name", name);
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject())).thenReturn(searchCriteria);
+ Mockito.when(xAuditMgr.searchXTrxLogs(searchCriteria)).thenReturn(vxExpList);
+
+ VXTrxLogList vxActList = auditREST.searchXTrxLogs(request);
+
+ Assert.assertNotNull(vxActList);
+ Assert.assertEquals(vxExpList, vxActList);
+
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject());
+ Mockito.verify(xAuditMgr).searchXTrxLogs(searchCriteria);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void Test6countXTrxLogs() {
+ VXLong vxLongExp = new VXLong();
+ vxLongExp.setValue(id);
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject())).thenReturn(searchCriteria);
+ Mockito.when(xAuditMgr.getXTrxLogSearchCount(searchCriteria)).thenReturn(vxLongExp);
+
+ VXLong vxLongAct = auditREST.countXTrxLogs(request);
+
+ Assert.assertNotNull(vxLongAct);
+ Assert.assertEquals(vxLongExp, vxLongAct);
+ Assert.assertEquals(vxLongExp.getValue(), vxLongAct.getValue());
+
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject());
+ Mockito.verify(xAuditMgr).getXTrxLogSearchCount(searchCriteria);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void Test7searchXAccessAudits() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ searchCriteria.addParam("name", name);
+ VXAccessAuditList vxAAListExp = new VXAccessAuditList();
+ vxAAListExp.setTotalCount(6L);
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject())).thenReturn(searchCriteria);
+ Mockito.when(xAuditMgr.searchXAccessAudits(searchCriteria)).thenReturn(vxAAListExp);
+
+ VXAccessAuditList vxAAListAct = auditREST.searchXAccessAudits(request);
+
+ Assert.assertNotNull(vxAAListAct);
+ Assert.assertEquals(vxAAListExp, vxAAListAct);
+ Assert.assertEquals(vxAAListExp.getTotalCount(), vxAAListAct.getTotalCount());
+
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject());
+ Mockito.verify(xAuditMgr).searchXAccessAudits(searchCriteria);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void Test8countXAccessAudits() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ searchCriteria.addParam("name", name);
+ VXLong vxLongExp = new VXLong();
+ vxLongExp.setValue(id);
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject())).thenReturn(searchCriteria);
+ Mockito.when(xAuditMgr.getXAccessAuditSearchCount(searchCriteria)).thenReturn(vxLongExp);
+
+ VXLong vxLongAct = auditREST.countXAccessAudits(request);
+
+ Assert.assertNotNull(vxLongAct);
+ Assert.assertEquals(vxLongExp, vxLongAct);
+ Assert.assertEquals(vxLongExp.getValue(), vxLongAct.getValue());
+
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest) Mockito.anyObject(),
+ (List<SortField>) Mockito.anyObject());
+ Mockito.verify(xAuditMgr).getXAccessAuditSearchCount(searchCriteria);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/rest/TestXKeyREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestXKeyREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestXKeyREST.java
new file mode 100644
index 0000000..a82969c
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestXKeyREST.java
@@ -0,0 +1,236 @@
+/*
+ * 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 javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.WebApplicationException;
+import org.apache.ranger.biz.KmsKeyMgr;
+import org.apache.ranger.biz.XAuditMgr;
+import org.apache.ranger.common.MessageEnums;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.SearchUtil;
+import org.apache.ranger.service.XAccessAuditService;
+import org.apache.ranger.service.XTrxLogService;
+import org.apache.ranger.view.VXKmsKey;
+import org.apache.ranger.view.VXKmsKeyList;
+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 TestXKeyREST {
+ @InjectMocks
+ XKeyREST keyREST = new XKeyREST();
+
+ @Mock
+ XAuditMgr xAuditMgr;
+
+ @Mock
+ SearchUtil searchUtil;
+
+ @Mock
+ XTrxLogService xLog;
+
+ @Mock
+ XAccessAuditService xAccessAuditSrv;
+
+ @Mock
+ KmsKeyMgr keyMgr;
+
+ @Mock
+ VXKmsKey vxKmsKey;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ HttpServletRequest request;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ String provider = "providerX";
+ String name = "xyz";
+ String nameNl = "";
+
+ @Test
+ public void Test1Searchkeys() throws Exception {
+ VXKmsKeyList vxKeyListExp = new VXKmsKeyList();
+
+ Mockito.when(keyMgr.searchKeys(request, provider)).thenReturn(vxKeyListExp);
+
+ VXKmsKeyList vxKeyListAct = keyREST.searchKeys(request, provider);
+
+ Assert.assertNotNull(vxKeyListAct);
+ Assert.assertEquals(vxKeyListExp, vxKeyListAct);
+
+ Mockito.verify(keyMgr).searchKeys(request, provider);
+ }
+
+ @Test
+ public void Test2RolloverKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+ vxKeyExp.setName(name);
+ vxKeyExp.setCipher("CipherX");
+
+ Mockito.when(keyMgr.rolloverKey(provider, vxKeyExp)).thenReturn(vxKeyExp);
+
+ VXKmsKey vxKeyAct = keyREST.rolloverKey(provider, vxKeyExp);
+
+ Assert.assertNotNull(vxKeyAct);
+ Assert.assertEquals(vxKeyExp, vxKeyAct);
+ Assert.assertEquals(vxKeyExp.getName(), vxKeyAct.getName());
+ Mockito.verify(keyMgr).rolloverKey(provider, vxKeyExp);
+ }
+
+ @Test
+ public void Test3RolloverKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+ vxKeyExp.setName(name);
+
+ Mockito.when(keyMgr.rolloverKey(provider, vxKeyExp)).thenReturn(vxKeyExp);
+
+ VXKmsKey vxKeyAct = keyREST.rolloverKey(provider, vxKeyExp);
+
+ Assert.assertNotNull(vxKeyAct);
+ Assert.assertEquals(vxKeyExp, vxKeyAct);
+ Assert.assertEquals(vxKeyExp.getName(), vxKeyAct.getName());
+ Assert.assertNull(vxKeyAct.getCipher());
+
+ Mockito.verify(keyMgr).rolloverKey(provider, vxKeyExp);
+ }
+
+ @Test
+ public void Test4RolloverKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject()))
+ .thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ keyREST.rolloverKey(provider, vxKeyExp);
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject());
+ }
+
+ @Test
+ public void Test5DeleteKey() throws Exception {
+ Mockito.doNothing().when(keyMgr).deleteKey(provider, name);
+
+ keyREST.deleteKey(name, provider, request);
+
+ Mockito.verify(keyMgr).deleteKey(provider, name);
+ }
+
+ @Test
+ public void Test6DeleteKey() throws Exception {
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject()))
+ .thenReturn(new WebApplicationException());
+
+ thrown.expect(WebApplicationException.class);
+
+ keyREST.deleteKey(nameNl, provider, request);
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject());
+ }
+
+ @Test
+ public void Test6CreateKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+ vxKeyExp.setName(name);
+ vxKeyExp.setCipher("CipherX");
+
+ Mockito.when(keyMgr.createKey(provider, vxKeyExp)).thenReturn(vxKeyExp);
+ VXKmsKey vxKeyAct = keyREST.createKey(provider, vxKeyExp);
+
+ Assert.assertNotNull(vxKeyAct);
+ Assert.assertEquals(vxKeyAct, vxKeyExp);
+ Assert.assertEquals(vxKeyExp.getName(), vxKeyAct.getName());
+ Assert.assertEquals(vxKeyExp.getCipher(), vxKeyAct.getCipher());
+
+ Mockito.verify(keyMgr).createKey(provider, vxKeyExp);
+ }
+
+ @Test
+ public void Test7CreateKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+ vxKeyExp.setName(name);
+
+ Mockito.when(keyMgr.createKey(provider, vxKeyExp)).thenReturn(vxKeyExp);
+
+ VXKmsKey vxKeyAct = keyREST.createKey(provider, vxKeyExp);
+
+ Assert.assertNotNull(vxKeyAct);
+ Assert.assertEquals(vxKeyAct, vxKeyExp);
+ Assert.assertEquals(vxKeyExp.getName(), vxKeyAct.getName());
+ Assert.assertNull(vxKeyAct.getCipher());
+
+ Mockito.verify(keyMgr).createKey(provider, vxKeyExp);
+ }
+
+ @Test
+ public void Test8CreateKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject()))
+ .thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXKmsKey vxKeyAct = keyREST.createKey(provider, vxKeyExp);
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject());
+
+ Assert.assertNull(vxKeyAct);
+ }
+
+ @Test
+ public void Test9GetKey() throws Exception {
+ VXKmsKey vxKeyExp = new VXKmsKey();
+
+ Mockito.when(keyMgr.getKey(provider, name)).thenReturn(vxKeyExp);
+
+ VXKmsKey vxKeyAct = keyREST.getKey(name, provider);
+
+ Assert.assertNotNull(vxKeyAct);
+ Assert.assertEquals(vxKeyAct, vxKeyExp);
+ Assert.assertEquals(vxKeyExp.getName(), vxKeyAct.getName());
+
+ Mockito.verify(keyMgr).getKey(provider, name);
+ }
+
+ @Test
+ public void Test10GetKey() throws Exception {
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject()))
+ .thenReturn(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXKmsKey vxKeyAct = keyREST.getKey(nameNl, provider);
+
+ Assert.assertNull(vxKeyAct);
+
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums) Mockito.anyObject());
+ }
+}
[5/5] incubator-ranger git commit: RANGER-1170: Added Unit tests for
PuclicAPIsv2 and PublicAPIs
Posted by ve...@apache.org.
RANGER-1170: Added Unit tests for PuclicAPIsv2 and PublicAPIs
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/53fb16a6
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ranger/tree/53fb16a6
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ranger/diff/53fb16a6
Branch: refs/heads/master
Commit: 53fb16a60aeb9557d56d76003831e9e442351244
Parents: 1c441f7
Author: Sailaja Polavarapu <sp...@hortonworks.com>
Authored: Tue Sep 27 14:14:42 2016 -0700
Committer: Velmurugan Periasamy <ve...@apache.org>
Committed: Wed Sep 28 11:19:33 2016 -0400
----------------------------------------------------------------------
.../org/apache/ranger/rest/TestPublicAPIs.java | 512 ++++++++++++++++++
.../apache/ranger/rest/TestPublicAPIsv2.java | 540 +++++++++++++++++++
2 files changed, 1052 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/53fb16a6/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java
new file mode 100644
index 0000000..9faae93
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIs.java
@@ -0,0 +1,512 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ranger.rest;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.JSONUtil;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerSearchUtil;
+import org.apache.ranger.common.ServiceUtil;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXPolicyDao;
+import org.apache.ranger.db.XXServiceDao;
+import org.apache.ranger.entity.XXPolicy;
+import org.apache.ranger.entity.XXService;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerService;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.util.SearchFilter;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.service.RangerPolicyService;
+import org.apache.ranger.service.XAssetService;
+import org.apache.ranger.view.VXAsset;
+import org.apache.ranger.view.VXLong;
+import org.apache.ranger.view.VXPolicy;
+import org.apache.ranger.view.VXPolicyList;
+import org.apache.ranger.view.VXRepository;
+import org.apache.ranger.view.VXRepositoryList;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestPublicAPIs {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ PublicAPIs publicAPIs = new PublicAPIs();
+
+ @Mock
+ ServiceREST serviceREST;
+
+ @Mock
+ ServiceUtil serviceUtil;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Mock
+ JSONUtil jsonUtil;
+
+ @Mock
+ RangerDaoManager daoMgr;
+
+ @Mock
+ RangerSearchUtil searchUtil;
+
+ @Mock
+ XAssetService xAssetService;
+
+ @Mock
+ RangerPolicyService policyService;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Before
+ public void setup() throws Exception {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerService rangerService() {
+ Map<String, String> configs = new HashMap<String, String>();
+ configs.put("username", "servicemgr");
+ configs.put("password", "servicemgr");
+ configs.put("namenode", "servicemgr");
+ configs.put("hadoop.security.authorization", "No");
+ configs.put("hadoop.security.authentication", "Simple");
+ configs.put("hadoop.security.auth_to_local", "");
+ configs.put("dfs.datanode.kerberos.principal", "");
+ configs.put("dfs.namenode.kerberos.principal", "");
+ configs.put("dfs.secondary.namenode.kerberos.principal", "");
+ configs.put("hadoop.rpc.protection", "Privacy");
+ configs.put("commonNameForCertificate", "");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(Id);
+ rangerService.setConfigs(configs);
+ rangerService.setCreateTime(new Date());
+ rangerService.setDescription("service policy");
+ rangerService.setGuid("1427365526516_835_0");
+ rangerService.setIsEnabled(true);
+ rangerService.setName("HDFS_1");
+ rangerService.setPolicyUpdateTime(new Date());
+ rangerService.setType("1");
+ rangerService.setUpdatedBy("Admin");
+ rangerService.setUpdateTime(new Date());
+
+ return rangerService;
+ }
+
+ private XXService xService() {
+ XXService xService = new XXService();
+ xService.setAddedByUserId(Id);
+ xService.setCreateTime(new Date());
+ xService.setDescription("Hdfs service");
+ xService.setGuid("serviceguid");
+ xService.setId(Id);
+ xService.setIsEnabled(true);
+ xService.setName("Hdfs");
+ xService.setPolicyUpdateTime(new Date());
+ xService.setPolicyVersion(1L);
+ xService.setType(1L);
+ xService.setUpdatedByUserId(Id);
+ xService.setUpdateTime(new Date());
+
+ return xService;
+ }
+
+ private VXRepository vXRepository(RangerService service) {
+ VXRepository ret = new VXRepository();
+ ret.setRepositoryType(service.getType());
+ ret.setName(service.getName());
+ ret.setDescription(service.getDescription());
+ ret.setIsActive(service.getIsEnabled());
+ ret.setConfig(jsonUtil.readMapToString(service.getConfigs()));
+ //ret.setVersion(Long.toString(service.getVersion()));
+ ret.setId(service.getId());
+ ret.setCreateDate(service.getCreateTime());
+ ret.setUpdateDate(service.getUpdateTime());
+ ret.setOwner(service.getCreatedBy());
+ ret.setUpdatedBy(service.getUpdatedBy());
+
+ return ret;
+ }
+
+ private VXPolicy vXPolicy(RangerPolicy policy, RangerService service) {
+ VXPolicy ret = new VXPolicy();
+ ret.setPolicyName(StringUtils.trim(policy.getName()));
+ ret.setDescription(policy.getDescription());
+ ret.setRepositoryName(policy.getService());
+ ret.setIsEnabled(policy.getIsEnabled() ? true : false);
+ ret.setRepositoryType(service.getType());
+ ret.setIsAuditEnabled(policy.getIsAuditEnabled());
+ return ret;
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ policyResource.put("resource", rangerPolicyResource);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+ policy.setService("HDFS_1");
+
+ return policy;
+ }
+
+ private XXPolicy policy() {
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(Id);
+ xxPolicy.setName("HDFS_1-1-20150316062453");
+ xxPolicy.setAddedByUserId(Id);
+ xxPolicy.setCreateTime(new Date());
+ xxPolicy.setDescription("test");
+ xxPolicy.setIsAuditEnabled(false);
+ xxPolicy.setIsEnabled(false);
+ xxPolicy.setService(1L);
+ xxPolicy.setUpdatedByUserId(Id);
+ xxPolicy.setUpdateTime(new Date());
+ xxPolicy.setVersion(Id);
+ return xxPolicy;
+ }
+
+ @Test
+ public void test1getRepository() throws Exception {
+ RangerService rangerService = rangerService();
+ VXRepository vXRepository = vXRepository(rangerService);
+ Mockito.when(serviceREST.getService(rangerService.getId())).thenReturn(rangerService);
+ Mockito.when(serviceUtil.toVXRepository(rangerService)).thenReturn(vXRepository);
+ VXRepository dbVXRepository = publicAPIs.getRepository(Id);
+
+ Assert.assertNotNull(dbVXRepository);
+ Assert.assertEquals(dbVXRepository, vXRepository);
+ Assert.assertEquals(dbVXRepository.getId(),
+ vXRepository.getId());
+ Assert.assertEquals(dbVXRepository.getName(),
+ vXRepository.getName());
+ Mockito.verify(serviceREST).getService(Id);
+ Mockito.verify(serviceUtil).toVXRepository(rangerService);
+
+ }
+
+ @Test
+ public void test2createRepository() throws Exception {
+ VXAsset vXAsset = new VXAsset();
+ RangerService rangerService = rangerService();
+ VXRepository vXRepository = vXRepository(rangerService);
+ Mockito.when(serviceUtil.publicObjecttoVXAsset(vXRepository)).thenReturn(vXAsset);
+ Mockito.when(serviceUtil.toRangerService(vXAsset)).thenReturn(rangerService);
+ Mockito.when(serviceREST.createService(rangerService)).thenReturn(rangerService);
+ Mockito.when(serviceUtil.toVXAsset(rangerService)).thenReturn(vXAsset);
+ Mockito.when(serviceUtil.vXAssetToPublicObject(vXAsset)).thenReturn(vXRepository);
+ VXRepository dbVXRepository = publicAPIs.createRepository(vXRepository);
+
+ Assert.assertNotNull(dbVXRepository);
+ Assert.assertEquals(dbVXRepository, vXRepository);
+ Assert.assertEquals(dbVXRepository.getId(),
+ vXRepository.getId());
+ Assert.assertEquals(dbVXRepository.getName(),
+ vXRepository.getName());
+ Mockito.verify(serviceREST).createService(rangerService);
+ Mockito.verify(serviceUtil).publicObjecttoVXAsset(vXRepository);
+ Mockito.verify(serviceUtil).toRangerService(vXAsset);
+ Mockito.verify(serviceUtil).toVXAsset(rangerService);
+ Mockito.verify(serviceUtil).vXAssetToPublicObject(vXAsset);
+ }
+
+ @Test
+ public void test3updateRepository() throws Exception {
+ VXAsset vXAsset = new VXAsset();
+ RangerService rangerService = rangerService();
+ VXRepository vXRepository = vXRepository(rangerService);
+ XXService xService = xService();
+ XXServiceDao xServiceDao = Mockito.mock(XXServiceDao.class);
+ Mockito.when(daoMgr.getXXService()).thenReturn(xServiceDao);
+ Mockito.when(xServiceDao.getById(Id)).thenReturn(xService);
+ Mockito.when(serviceUtil.publicObjecttoVXAsset(vXRepository)).thenReturn(vXAsset);
+ Mockito.when(serviceUtil.toRangerService(vXAsset)).thenReturn(rangerService);
+ Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService);
+ Mockito.when(serviceUtil.toVXAsset(rangerService)).thenReturn(vXAsset);
+ Mockito.when(serviceUtil.vXAssetToPublicObject(vXAsset)).thenReturn(vXRepository);
+ VXRepository dbVXRepository = publicAPIs.updateRepository(vXRepository, Id);
+
+ Assert.assertNotNull(dbVXRepository);
+ Assert.assertEquals(dbVXRepository, vXRepository);
+ Assert.assertEquals(dbVXRepository.getId(),
+ vXRepository.getId());
+ Assert.assertEquals(dbVXRepository.getName(),
+ vXRepository.getName());
+ Mockito.verify(serviceREST).updateService(rangerService);
+ Mockito.verify(serviceUtil).publicObjecttoVXAsset(vXRepository);
+ Mockito.verify(serviceUtil).toRangerService(vXAsset);
+ Mockito.verify(serviceUtil).toVXAsset(rangerService);
+ Mockito.verify(serviceUtil).vXAssetToPublicObject(vXAsset);
+ Mockito.verify(daoMgr).getXXService();
+ }
+
+ @Test
+ public void test4deleteRepository() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.doNothing().when(serviceREST).deleteService(Id);
+ publicAPIs.deleteRepository(Id, request);
+ Mockito.verify(serviceREST).deleteService(Id);
+ }
+
+ @Test
+ public void test5searchRepositories() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerService> ret = new ArrayList<RangerService>();
+ RangerService rangerService = rangerService();
+ VXRepository vXRepository = vXRepository(rangerService);
+ List<VXRepository> repoList = new ArrayList<VXRepository>();
+ repoList.add(vXRepository);
+ VXRepositoryList vXRepositoryList = new VXRepositoryList(repoList);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(searchUtil.getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields)).thenReturn(filter);
+ Mockito.when(serviceREST.getServices(filter)).thenReturn(ret);
+ Mockito.when(serviceUtil.rangerServiceListToPublicObjectList(ret)).thenReturn(vXRepositoryList);
+ VXRepositoryList dbVXRepositoryList = publicAPIs.searchRepositories(request);
+ Assert.assertNotNull(dbVXRepositoryList);
+ Assert.assertEquals(dbVXRepositoryList.getResultSize(), vXRepositoryList.getResultSize());
+ }
+
+ @Test
+ public void test6countRepositories() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ VXLong vXLong = new VXLong();
+ List<RangerService> ret = new ArrayList<RangerService>();
+ RangerService rangerService = rangerService();
+ VXRepository vXRepository = vXRepository(rangerService);
+ List<VXRepository> repoList = new ArrayList<VXRepository>();
+ repoList.add(vXRepository);
+ VXRepositoryList vXRepositoryList = new VXRepositoryList(repoList);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ Mockito.when(searchUtil.getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields)).thenReturn(filter);
+ Mockito.when(serviceREST.getServices(filter)).thenReturn(ret);
+ Mockito.when(serviceUtil.rangerServiceListToPublicObjectList(ret)).thenReturn(vXRepositoryList);
+ VXRepositoryList dbVXRepositoryList = publicAPIs.searchRepositories(request);
+ vXLong.setValue(dbVXRepositoryList.getResultSize());
+ Assert.assertNotNull(vXLong);
+ Assert.assertEquals(vXLong.getValue(), 1);
+ Mockito.verify(searchUtil).getSearchFilterFromLegacyRequestForRepositorySearch(request, xAssetService.sortFields);
+ Mockito.verify(serviceREST).getServices(filter);
+ Mockito.verify(serviceUtil).rangerServiceListToPublicObjectList(ret);
+ }
+
+ @Test
+ public void test7getPolicy() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+ RangerService service = rangerService();
+ VXPolicy vXPolicy = vXPolicy(policy, service);
+ Mockito.when(serviceREST.getPolicy(policy.getId())).thenReturn(policy);
+ Mockito.when(serviceREST.getServiceByName(policy.getService())).thenReturn(service);
+ Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy);
+ VXPolicy dbVXPolicy = publicAPIs.getPolicy(Id);
+ Assert.assertNotNull(dbVXPolicy);
+ Assert.assertEquals(dbVXPolicy, vXPolicy);
+ Assert.assertEquals(dbVXPolicy.getPolicyName(), vXPolicy.getPolicyName());
+ Assert.assertEquals(dbVXPolicy.getRepositoryType(), vXPolicy.getRepositoryType());
+ Mockito.verify(serviceREST).getPolicy(Id);
+ Mockito.verify(serviceREST).getServiceByName(policy.getService());
+ Mockito.verify(serviceUtil).toVXPolicy(policy, service);
+ }
+
+ @Test
+ public void test8createPolicy() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+ RangerService service = rangerService();
+ VXPolicy vXPolicy = vXPolicy(policy, service);
+ Mockito.when(serviceREST.getServiceByName(vXPolicy.getRepositoryName())).thenReturn(service);
+ Mockito.when(serviceUtil.toRangerPolicy(vXPolicy,service)).thenReturn(policy);
+ Mockito.when(serviceREST.createPolicy(policy, null)).thenReturn(policy);
+ Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy);
+ VXPolicy dbVXPolicy = publicAPIs.createPolicy(vXPolicy);
+ Assert.assertNotNull(dbVXPolicy);
+ Assert.assertEquals(dbVXPolicy, vXPolicy);
+ Assert.assertEquals(dbVXPolicy.getId(),
+ vXPolicy.getId());
+ Assert.assertEquals(dbVXPolicy.getRepositoryName(),
+ vXPolicy.getRepositoryName());
+ Mockito.verify(serviceREST).createPolicy(policy, null);
+ Mockito.verify(serviceREST).getServiceByName(vXPolicy.getRepositoryName());
+ Mockito.verify(serviceUtil).toVXPolicy(policy, service);
+ Mockito.verify(serviceUtil).toRangerPolicy(vXPolicy,service);
+
+ }
+
+ @Test
+ public void test9updatePolicy() throws Exception {
+ RangerPolicy policy = rangerPolicy();
+ RangerService service = rangerService();
+ VXPolicy vXPolicy = vXPolicy(policy, service);
+ XXPolicyDao xXPolicyDao = Mockito.mock(XXPolicyDao.class);
+ XXPolicy xXPolicy = policy();
+ Mockito.when(daoMgr.getXXPolicy()).thenReturn(xXPolicyDao);
+ Mockito.when(xXPolicyDao.getById(Id)).thenReturn(xXPolicy);
+ Mockito.when(serviceREST.getServiceByName(vXPolicy.getRepositoryName())).thenReturn(service);
+ Mockito.when(serviceUtil.toRangerPolicy(vXPolicy,service)).thenReturn(policy);
+ Mockito.when(serviceREST.updatePolicy(policy)).thenReturn(policy);
+ Mockito.when(serviceUtil.toVXPolicy(policy, service)).thenReturn(vXPolicy);
+ VXPolicy dbVXPolicy = publicAPIs.updatePolicy(vXPolicy, Id);
+
+ Assert.assertNotNull(dbVXPolicy);
+ Assert.assertEquals(dbVXPolicy, vXPolicy);
+ Assert.assertEquals(dbVXPolicy.getId(),
+ vXPolicy.getId());
+ Assert.assertEquals(dbVXPolicy.getRepositoryName(),
+ vXPolicy.getRepositoryName());
+ Mockito.verify(serviceREST).updatePolicy(policy);
+ Mockito.verify(serviceREST).getServiceByName(vXPolicy.getRepositoryName());
+ Mockito.verify(serviceUtil).toVXPolicy(policy, service);
+ Mockito.verify(serviceUtil).toRangerPolicy(vXPolicy,service);
+ Mockito.verify(daoMgr).getXXPolicy();
+ Mockito.verify(xXPolicyDao).getById(Id);
+ }
+
+ @Test
+ public void test10deletePolicy() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.doNothing().when(serviceREST).deletePolicy(Id);
+ publicAPIs.deletePolicy(Id, request);
+ Mockito.verify(serviceREST).deletePolicy(Id);
+ }
+
+ @Test
+ public void test11searchPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerService service = rangerService();
+ RangerPolicy policy = rangerPolicy();
+ List<RangerPolicy> policyList = new ArrayList<RangerPolicy>();
+ policyList.add(policy);
+ VXPolicy vXPolicy = vXPolicy(policy, service);
+ List<VXPolicy> vXPolicies = new ArrayList<VXPolicy>();
+ vXPolicies.add(vXPolicy);
+ VXPolicyList vXPolicyList = new VXPolicyList(vXPolicies);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ filter.setStartIndex(0);
+ filter.setMaxRows(10);
+ Mockito.when(searchUtil.getSearchFilterFromLegacyRequest(request, policyService.sortFields)).thenReturn(filter);
+ Mockito.when(serviceREST.getPolicies(filter)).thenReturn(policyList);
+ Mockito.when(serviceUtil.rangerPolicyListToPublic(policyList,filter)).thenReturn(vXPolicyList);
+ VXPolicyList dbVXPolicyList = publicAPIs.searchPolicies(request);
+ Assert.assertNotNull(dbVXPolicyList);
+ Assert.assertEquals(dbVXPolicyList.getResultSize(), vXPolicyList.getResultSize());
+ Mockito.verify(searchUtil).getSearchFilterFromLegacyRequest(request, policyService.sortFields);
+ Mockito.verify(serviceREST).getPolicies(filter);
+ Mockito.verify(serviceUtil).rangerPolicyListToPublic(policyList,filter);
+
+ }
+
+ @Test
+ public void test12countPolicies() throws Exception {
+ VXLong vXLong = new VXLong();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerService service = rangerService();
+ RangerPolicy policy = rangerPolicy();
+ List<RangerPolicy> policyList = new ArrayList<RangerPolicy>();
+ policyList.add(policy);
+ VXPolicy vXPolicy = vXPolicy(policy, service);
+ List<VXPolicy> vXPolicies = new ArrayList<VXPolicy>();
+ vXPolicies.add(vXPolicy);
+ VXPolicyList vXPolicyList = new VXPolicyList(vXPolicies);
+ SearchFilter filter = new SearchFilter();
+ filter.setParam(SearchFilter.POLICY_NAME, "policyName");
+ filter.setParam(SearchFilter.SERVICE_NAME, "serviceName");
+ filter.setStartIndex(0);
+ filter.setMaxRows(10);
+ Mockito.when(searchUtil.getSearchFilterFromLegacyRequest(request, policyService.sortFields)).thenReturn(filter);
+ Mockito.when(serviceREST.getPolicies(filter)).thenReturn(policyList);
+ Mockito.when(serviceUtil.rangerPolicyListToPublic(policyList,filter)).thenReturn(vXPolicyList);
+ VXPolicyList dbVXPolicyList = publicAPIs.searchPolicies(request);
+ vXLong.setValue(dbVXPolicyList.getResultSize());
+ Assert.assertNotNull(vXLong);
+ Assert.assertEquals(vXLong.getValue(), 1);
+ Mockito.verify(searchUtil).getSearchFilterFromLegacyRequest(request, policyService.sortFields);
+ Mockito.verify(serviceREST).getPolicies(filter);
+ Mockito.verify(serviceUtil).rangerPolicyListToPublic(policyList,filter);
+
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/53fb16a6/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
new file mode 100644
index 0000000..1404637
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestPublicAPIsv2.java
@@ -0,0 +1,540 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ranger.rest;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.UserSessionBase;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerService;
+import org.apache.ranger.plugin.model.RangerServiceDef;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerAccessTypeDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerContextEnricherDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerEnumDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerPolicyConditionDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerResourceDef;
+import org.apache.ranger.plugin.model.RangerServiceDef.RangerServiceConfigDef;
+import org.apache.ranger.plugin.util.SearchFilter;
+import org.apache.ranger.security.context.RangerContextHolder;
+import org.apache.ranger.security.context.RangerSecurityContext;
+import org.apache.ranger.view.RangerPolicyList;
+import org.apache.ranger.view.RangerServiceDefList;
+import org.apache.ranger.view.RangerServiceList;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestPublicAPIsv2 {
+
+ private static Long Id = 8L;
+
+ @InjectMocks
+ PublicAPIsv2 publicAPIsv2 = new PublicAPIsv2();
+
+ @Mock
+ ServiceREST serviceREST;
+
+ @Mock
+ RESTErrorUtil restErrorUtil;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Before
+ public void setup() throws Exception {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil
+ .getCurrentUserSession();
+ currentUserSession.setUserAdmin(true);
+ }
+
+ private RangerServiceDef rangerServiceDef() {
+ List<RangerServiceConfigDef> configs = new ArrayList<RangerServiceConfigDef>();
+ List<RangerResourceDef> resources = new ArrayList<RangerResourceDef>();
+ List<RangerAccessTypeDef> accessTypes = new ArrayList<RangerAccessTypeDef>();
+ List<RangerPolicyConditionDef> policyConditions = new ArrayList<RangerPolicyConditionDef>();
+ List<RangerContextEnricherDef> contextEnrichers = new ArrayList<RangerContextEnricherDef>();
+ List<RangerEnumDef> enums = new ArrayList<RangerEnumDef>();
+
+ RangerServiceDef rangerServiceDef = new RangerServiceDef();
+ rangerServiceDef.setId(Id);
+ rangerServiceDef.setName("RangerServiceHdfs");
+ rangerServiceDef.setImplClass("RangerServiceHdfs");
+ rangerServiceDef.setLabel("HDFS Repository");
+ rangerServiceDef.setDescription("HDFS Repository");
+ rangerServiceDef.setRbKeyDescription(null);
+ rangerServiceDef.setUpdatedBy("Admin");
+ rangerServiceDef.setUpdateTime(new Date());
+ rangerServiceDef.setConfigs(configs);
+ rangerServiceDef.setResources(resources);
+ rangerServiceDef.setAccessTypes(accessTypes);
+ rangerServiceDef.setPolicyConditions(policyConditions);
+ rangerServiceDef.setContextEnrichers(contextEnrichers);
+ rangerServiceDef.setEnums(enums);
+
+ return rangerServiceDef;
+ }
+
+ private RangerService rangerService() {
+ Map<String, String> configs = new HashMap<String, String>();
+ configs.put("username", "servicemgr");
+ configs.put("password", "servicemgr");
+ configs.put("namenode", "servicemgr");
+ configs.put("hadoop.security.authorization", "No");
+ configs.put("hadoop.security.authentication", "Simple");
+ configs.put("hadoop.security.auth_to_local", "");
+ configs.put("dfs.datanode.kerberos.principal", "");
+ configs.put("dfs.namenode.kerberos.principal", "");
+ configs.put("dfs.secondary.namenode.kerberos.principal", "");
+ configs.put("hadoop.rpc.protection", "Privacy");
+ configs.put("commonNameForCertificate", "");
+
+ RangerService rangerService = new RangerService();
+ rangerService.setId(Id);
+ rangerService.setConfigs(configs);
+ rangerService.setCreateTime(new Date());
+ rangerService.setDescription("service policy");
+ rangerService.setGuid("1427365526516_835_0");
+ rangerService.setIsEnabled(true);
+ rangerService.setName("HDFS_1");
+ rangerService.setPolicyUpdateTime(new Date());
+ rangerService.setType("1");
+ rangerService.setUpdatedBy("Admin");
+ rangerService.setUpdateTime(new Date());
+
+ return rangerService;
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ policyResource.put("resource", rangerPolicyResource);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(Id);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+ policy.setService("HDFS_1");
+
+ return policy;
+ }
+
+ @Test
+ public void test1getServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(serviceREST.getServiceDef(rangerServiceDef.getId())).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDef(Id);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(serviceREST).getServiceDef(Id);
+ }
+
+ @Test
+ public void test2getServiceDefByName() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ String name = rangerServiceDef.getName();
+ Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = publicAPIsv2.getServiceDefByName(name);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(serviceREST).getServiceDefByName(name);
+ }
+
+ @Test
+ public void test3searchServiceDefs() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerServiceDef> serviceDefsList = new ArrayList<RangerServiceDef>();
+ RangerServiceDef serviceDef = rangerServiceDef();
+ serviceDefsList.add(serviceDef);
+ RangerServiceDefList serviceDefList = new RangerServiceDefList(serviceDefsList);
+ Mockito.when(serviceREST.getServiceDefs(request)).thenReturn(serviceDefList);
+ List<RangerServiceDef> dbRangerServiceDefList = publicAPIsv2.searchServiceDefs(request);
+ Assert.assertNotNull(dbRangerServiceDefList);
+ Assert.assertEquals(dbRangerServiceDefList.size(), serviceDefsList.size());
+ Mockito.verify(serviceREST).getServiceDefs(request);
+ }
+
+ @Test
+ public void test4createServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(serviceREST.createServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = publicAPIsv2.createServiceDef(rangerServiceDef);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(serviceREST).createServiceDef(rangerServiceDef);
+ }
+
+ @Test
+ public void test5updateServiceDef() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ Mockito.when(serviceREST.updateServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDef(rangerServiceDef, Id);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef);
+ }
+
+ @Test
+ public void test6updateServiceDefByName() throws Exception {
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ String name = rangerServiceDef.getName();
+ Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef);
+ Mockito.when(serviceREST.updateServiceDef(rangerServiceDef)).thenReturn(rangerServiceDef);
+ RangerServiceDef dbRangerServiceDef = publicAPIsv2.updateServiceDefByName(rangerServiceDef, name);
+ Assert.assertNotNull(dbRangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef, rangerServiceDef);
+ Assert.assertEquals(dbRangerServiceDef.getId(),
+ rangerServiceDef.getId());
+ Assert.assertEquals(dbRangerServiceDef.getName(),
+ rangerServiceDef.getName());
+ Mockito.verify(serviceREST).updateServiceDef(rangerServiceDef);
+ Mockito.verify(serviceREST).getServiceDefByName(name);
+ }
+
+ @Test
+ public void test7deleteServiceDef() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.doNothing().when(serviceREST).deleteServiceDef(Id, request);
+ publicAPIsv2.deleteServiceDef(Id, request);
+ Mockito.verify(serviceREST).deleteServiceDef(Id, request);
+ }
+
+ @Test
+ public void test8deleteServiceDefByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerServiceDef rangerServiceDef = rangerServiceDef();
+ String name = rangerServiceDef.getName();
+ Mockito.when(serviceREST.getServiceDefByName(name)).thenReturn(rangerServiceDef);
+ Mockito.doNothing().when(serviceREST).deleteServiceDef(rangerServiceDef.getId(), request);
+ publicAPIsv2.deleteServiceDefByName(name, request);
+ Mockito.verify(serviceREST).deleteServiceDef(rangerServiceDef.getId(), request);
+ Mockito.verify(serviceREST).getServiceDefByName(name);
+ }
+
+ @Test
+ public void test9getService() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(serviceREST.getService(rangerService.getId())).thenReturn(rangerService);
+ RangerService dbRangerService = publicAPIsv2.getService(Id);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(),
+ rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(),
+ rangerService.getName());
+ Mockito.verify(serviceREST).getService(Id);
+ }
+
+ @Test
+ public void test10getServiceByName() throws Exception {
+ RangerService rangerService = rangerService();
+ String name = rangerService.getName();
+ Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
+ RangerService dbRangerService = publicAPIsv2.getServiceByName(name);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(),
+ rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(),
+ rangerService.getName());
+ Mockito.verify(serviceREST).getServiceByName(name);
+ }
+
+ @Test
+ public void test11searchServices() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerService> servicesList = new ArrayList<RangerService>();
+ RangerService service = rangerService();
+ servicesList.add(service);
+ RangerServiceList serviceList = new RangerServiceList(servicesList);
+ Mockito.when(serviceREST.getServices(request)).thenReturn(serviceList);
+ List<RangerService> dbRangerServiceList = publicAPIsv2.searchServices(request);
+ Assert.assertNotNull(dbRangerServiceList);
+ Assert.assertEquals(dbRangerServiceList.size(), servicesList.size());
+ Mockito.verify(serviceREST).getServices(request);
+ }
+
+ @Test
+ public void test12createService() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(serviceREST.createService(rangerService)).thenReturn(rangerService);
+ RangerService dbRangerService = publicAPIsv2.createService(rangerService);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(),
+ rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(),
+ rangerService.getName());
+ Mockito.verify(serviceREST).createService(rangerService);
+ }
+
+ @Test
+ public void test13updateService() throws Exception {
+ RangerService rangerService = rangerService();
+ Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService);
+ RangerService dbRangerService = publicAPIsv2.updateService(rangerService, Id);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(),
+ rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(),
+ rangerService.getName());
+ Mockito.verify(serviceREST).updateService(rangerService);
+ }
+
+ @Test
+ public void test14updateServiceByName() throws Exception {
+ RangerService rangerService = rangerService();
+ String name = rangerService.getName();
+ Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
+ Mockito.when(serviceREST.updateService(rangerService)).thenReturn(rangerService);
+ RangerService dbRangerService = publicAPIsv2.updateServiceByName(rangerService, name);
+ Assert.assertNotNull(dbRangerService);
+ Assert.assertEquals(dbRangerService, rangerService);
+ Assert.assertEquals(dbRangerService.getId(),
+ rangerService.getId());
+ Assert.assertEquals(dbRangerService.getName(),
+ rangerService.getName());
+ Mockito.verify(serviceREST).updateService(rangerService);
+ Mockito.verify(serviceREST).getServiceByName(name);
+ }
+
+ @Test
+ public void test15deleteService() throws Exception {
+ Mockito.doNothing().when(serviceREST).deleteService(Id);
+ publicAPIsv2.deleteService(Id);
+ Mockito.verify(serviceREST).deleteService(Id);
+ }
+
+ @Test
+ public void test16deleteServiceByName() throws Exception {
+ RangerService rangerService = rangerService();
+ String name = rangerService.getName();
+ Mockito.when(serviceREST.getServiceByName(name)).thenReturn(rangerService);
+ Mockito.doNothing().when(serviceREST).deleteService(rangerService.getId());
+ publicAPIsv2.deleteServiceByName(name);
+ Mockito.verify(serviceREST).deleteService(rangerService.getId());
+ Mockito.verify(serviceREST).getServiceByName(name);
+ }
+
+ @Test
+ public void test17getPolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(serviceREST.getPolicy(rangerPolicy.getId())).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicy(Id);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).getPolicy(Id);
+ }
+
+ @Test
+ public void test18getPolicyByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ RangerService rangerService = rangerService();
+ String serviceName = rangerService.getName();
+ String policyName = rangerPolicy.getName();
+ List<RangerPolicy> policies = new ArrayList<RangerPolicy>();
+ policies.add(rangerPolicy);
+ Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.getPolicyByName(serviceName, policyName, request);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject());
+ }
+
+ @Test
+ public void test19searchPolicies() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ List<RangerPolicy> policiesList = new ArrayList<RangerPolicy>();
+ RangerService service = rangerService();
+ String serviceName = service.getName();
+ RangerPolicy rangerPolicy = rangerPolicy();
+ policiesList.add(rangerPolicy);
+ RangerPolicyList policyList = new RangerPolicyList(policiesList);
+ Mockito.when(serviceREST.getServicePoliciesByName(serviceName, request)).thenReturn(policyList);
+ List<RangerPolicy> dbRangerPolicyList = publicAPIsv2.searchPolicies(serviceName, request);
+ Assert.assertNotNull(dbRangerPolicyList);
+ Assert.assertEquals(dbRangerPolicyList.size(), policiesList.size());
+ Mockito.verify(serviceREST).getServicePoliciesByName(serviceName, request);
+ }
+
+ @Test
+ public void test20createPolicy() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(serviceREST.createPolicy(rangerPolicy, request)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.createPolicy(rangerPolicy, request);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).createPolicy(rangerPolicy, request);
+ }
+
+ @Test
+ public void test21applyPolicy() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(serviceREST.applyPolicy(rangerPolicy, request)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.applyPolicy(rangerPolicy, request);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).applyPolicy(rangerPolicy, request);
+ }
+
+ @Test
+ public void test22updatePolicy() throws Exception {
+ RangerPolicy rangerPolicy = rangerPolicy();
+ Mockito.when(serviceREST.updatePolicy(rangerPolicy)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicy(rangerPolicy, Id);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).updatePolicy(rangerPolicy);
+ }
+
+ @Test
+ public void test23updatePolicyByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ String policyName = rangerPolicy.getName();
+ RangerService rangerService = rangerService();
+ String serviceName = rangerService.getName();
+ List<RangerPolicy> policies = new ArrayList<RangerPolicy>();
+ policies.add(rangerPolicy);
+ Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies);
+ Mockito.when(serviceREST.updatePolicy(rangerPolicy)).thenReturn(rangerPolicy);
+ RangerPolicy dbRangerPolicy = publicAPIsv2.updatePolicyByName(rangerPolicy, serviceName, policyName, request);
+ Assert.assertNotNull(dbRangerPolicy);
+ Assert.assertEquals(dbRangerPolicy, rangerPolicy);
+ Assert.assertEquals(dbRangerPolicy.getId(),
+ rangerPolicy.getId());
+ Assert.assertEquals(dbRangerPolicy.getName(),
+ rangerPolicy.getName());
+ Mockito.verify(serviceREST).updatePolicy(rangerPolicy);
+ Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject());
+ }
+
+ @Test
+ public void test24deletePolicy() throws Exception {
+ Mockito.doNothing().when(serviceREST).deletePolicy(Id);
+ publicAPIsv2.deletePolicy(Id);
+ Mockito.verify(serviceREST).deletePolicy(Id);
+ }
+
+ @Test
+ public void test25deletePolicyByName() throws Exception {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ RangerPolicy rangerPolicy = rangerPolicy();
+ String policyName = rangerPolicy.getName();
+ RangerService rangerService = rangerService();
+ String serviceName = rangerService.getName();
+ List<RangerPolicy> policies = new ArrayList<RangerPolicy>();
+ policies.add(rangerPolicy);
+ Mockito.when(serviceREST.getPolicies((SearchFilter) Mockito.anyObject())).thenReturn(policies);
+ Mockito.doNothing().when(serviceREST).deletePolicy(Id);
+ publicAPIsv2.deletePolicyByName(serviceName, policyName, request);
+ Mockito.verify(serviceREST).getPolicies((SearchFilter) Mockito.anyObject());
+ Mockito.verify(serviceREST).deletePolicy(Id);
+ }
+}
[2/5] incubator-ranger git commit: RANGER-1170 : Improvement of Unit
Test coverage in Ranger
Posted by ve...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/1c441f79/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java
new file mode 100644
index 0000000..c544832
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java
@@ -0,0 +1,2238 @@
+/*
+ * 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 static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertEquals;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+
+import org.apache.ranger.audit.dao.DaoManager;
+import org.apache.ranger.biz.RangerBizUtil;
+import org.apache.ranger.biz.SessionMgr;
+import org.apache.ranger.biz.XUserMgr;
+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.SortField;
+import org.apache.ranger.common.AppConstants;
+import org.apache.ranger.common.RangerConstants;
+import org.apache.ranger.common.StringUtil;
+import org.apache.ranger.db.RangerDaoManager;
+import org.apache.ranger.db.XXGroupDao;
+import org.apache.ranger.entity.XXResource;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerDataMaskPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerRowFilterPolicyItem;
+import org.apache.ranger.service.AuthSessionService;
+import org.apache.ranger.service.XGroupGroupService;
+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.XResourceService;
+import org.apache.ranger.service.XUserPermissionService;
+import org.apache.ranger.service.XUserService;
+import org.apache.ranger.view.VXAuditMap;
+import org.apache.ranger.view.VXAuditMapList;
+import org.apache.ranger.view.VXAuthSession;
+import org.apache.ranger.view.VXAuthSessionList;
+import org.apache.ranger.view.VXGroup;
+import org.apache.ranger.view.VXGroupGroup;
+import org.apache.ranger.view.VXGroupGroupList;
+import org.apache.ranger.view.VXGroupList;
+import org.apache.ranger.view.VXGroupPermission;
+import org.apache.ranger.view.VXGroupPermissionList;
+import org.apache.ranger.view.VXGroupUser;
+import org.apache.ranger.view.VXGroupUserList;
+import org.apache.ranger.view.VXLong;
+import org.apache.ranger.view.VXModuleDef;
+import org.apache.ranger.view.VXModuleDefList;
+import org.apache.ranger.view.VXPermMap;
+import org.apache.ranger.view.VXPermMapList;
+import org.apache.ranger.view.VXResponse;
+import org.apache.ranger.view.VXString;
+import org.apache.ranger.view.VXStringList;
+import org.apache.ranger.view.VXUser;
+import org.apache.ranger.view.VXUserGroupInfo;
+import org.apache.ranger.view.VXUserList;
+import org.apache.ranger.view.VXDataObject;
+import org.apache.ranger.view.VXResource;
+import org.apache.ranger.view.VXUserPermission;
+import org.apache.ranger.view.VXUserPermissionList;
+import org.apache.ranger.entity.XXAuditMap;
+import org.apache.ranger.service.XAuditMapService;
+import org.apache.ranger.entity.XXAsset;
+import org.apache.ranger.entity.XXGroupGroup;
+import org.apache.ranger.entity.XXGroupPermission;
+import org.apache.ranger.entity.XXPermMap;
+import org.apache.ranger.service.XPermMapService;
+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;
+import org.apache.ranger.entity.XXGroup;
+import org.apache.ranger.db.XXGroupPermissionDao;
+import org.apache.ranger.db.XXResourceDao;
+import org.apache.ranger.db.XXPermMapDao;
+import org.apache.ranger.db.XXPolicyDao;
+import org.apache.ranger.db.XXGroupUserDao;
+import org.apache.ranger.db.XXUserDao;
+import org.apache.ranger.entity.XXPolicy;
+import org.apache.ranger.entity.XXUser;
+import org.apache.ranger.db.XXAuditMapDao;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import javax.servlet.http.HttpServletRequest;
+
+@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestXUserREST {
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @InjectMocks
+ XUserREST xUserRest = new XUserREST();
+
+ VXUser vxUser=createVXUser();
+ Long id=1L;
+
+ @Mock XUserMgr xUserMgr;
+ @Mock VXGroup vxGroup;
+ @Mock SearchCriteria searchCriteria;
+ @Mock XGroupService xGroupService;
+ @Mock SearchUtil searchUtil;
+ @Mock VXLong vXLong;
+ @Mock HttpServletRequest request;
+ @Mock VXUser vXUser1;
+ @Mock VXUserGroupInfo vXUserGroupInfo;
+ @Mock RangerBizUtil bizUtil;
+ @Mock XUserService xUserService;
+ @Mock VXUserList vXUserList;
+ @Mock VXGroupUser vXGroupUser;
+ @Mock XGroupUserService xGroupUserService;
+ @Mock VXGroupUserList vXGroupUserList;
+ @Mock VXGroupGroup vXGroupGroup;
+ @Mock VXGroupGroupList vXGroupGroupList;
+ @Mock XGroupGroupService xGroupGroupService;
+ @Mock VXPermMap vXPermMap;
+ @Mock RESTErrorUtil restErrorUtil;
+ @Mock WebApplicationException webApplicationException;
+ @Mock XResourceService xResourceService;
+ @Mock VXDataObject VXDataObject;
+ @Mock AppConstants AppConstants;
+ @Mock RangerConstants RangerConstants;
+ @Mock VXResource vXResource;
+ @Mock VXResponse vXResponse;
+ @Mock XXResource xXResource;
+ @Mock XXAuditMap XXAuditMap;
+ @Mock XAuditMapService xAuditMapService;
+ @Mock DaoManager daoManager;
+ @Mock XPermMapService xPermMapService;
+ @Mock XXAsset XXAsset;
+ @Mock RangerDaoManager rangerDaoManager;
+ @Mock XXPermMap XXPermMap;
+ @Mock Response response;
+ @Mock VXPermMapList vXPermMapList;
+ @Mock VXAuditMap vXAuditMap;
+ @Mock VXAuditMapList vXAuditMapList;
+ @Mock AuthSessionService authSessionService;
+ @Mock SessionMgr sessionMgr;
+ @Mock VXAuthSessionList vXAuthSessionList;
+ @Mock VXModuleDef vXModuleDef;
+ @Mock VXUserPermission vXUserPermission;
+ @Mock VXUserPermissionList vXUserPermissionList;
+ @Mock VXGroupPermission vXGroupPermission;
+ @Mock XModuleDefService xModuleDefService;
+ @Mock VXModuleDefList VXModuleDefList;
+ @Mock XUserPermissionService xUserPermissionService;
+ @Mock VXGroupPermissionList vXGroupPermissionList;
+ @Mock XGroupPermissionService xGroupPermissionService;
+ @Mock VXStringList vXStringList;
+ @Mock VXString vXString;
+ @Mock XXGroupDao xXGroupDao;
+ @Mock XXGroup xXGroup;
+ @Mock XXGroupGroup xXGroupGroup;
+ @Mock XXGroupPermission xXGroupPermission;
+ @Mock XXGroupPermissionDao xXGroupPermissionDao;
+ @Mock XXPolicyDao xXPolicyDao;
+ @Mock XXPolicy xXPolicy;
+ @Mock XXGroupUserDao xXGroupUserDao;
+ @Mock XXUserDao xXUserDao;
+ @Mock XXUser xXUser;
+ @Mock XXPermMapDao xXPermMapDao;
+ @Mock XXResourceDao xXResourceDao;
+ @Mock XXAuditMapDao xXAuditMapDao;
+ @Mock RangerPolicy rangerPolicy;
+ @Mock RangerPolicyItem rangerPolicyItem;
+ @Mock RangerDataMaskPolicyItem rangerDataMaskPolicyItem;
+ @Mock RangerRowFilterPolicyItem rangerRowFilterPolicyItem;
+
+ @Test
+ public void test1getXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.getXGroup(id)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup= xUserRest.getXGroup(id);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).getXGroup(id);
+ }
+
+ @Test
+ public void test2secureGetXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.getXGroup(id)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup=xUserRest.secureGetXGroup(id);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).getXGroup(id);
+ }
+
+ @Test
+ public void test3createXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.createXGroupWithoutLogin(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup=xUserRest.createXGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).createXGroupWithoutLogin(compareTestVXGroup);
+ }
+ @Test
+ public void test4secureCreateXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.createXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup=xUserRest.secureCreateXGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).createXGroup(compareTestVXGroup);
+ }
+ @Test
+ public void test5updateXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.updateXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup=xUserRest.updateXGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).updateXGroup(compareTestVXGroup);
+ }
+ @Test
+ public void test6secureUpdateXGroup() {
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xUserMgr.updateXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroup retVxGroup=xUserRest.secureUpdateXGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ assertEquals(compareTestVXGroup.getName(),retVxGroup.getName());
+ Mockito.verify(xUserMgr).updateXGroup(compareTestVXGroup);
+ }
+ @Test
+ public void test7modifyGroupsVisibility() {
+ HashMap<Long, Integer> groupVisibilityMap=creategroupVisibilityMap();
+ xUserRest.modifyGroupsVisibility(groupVisibilityMap);
+
+ Mockito.doNothing().when(xUserMgr).modifyGroupsVisibility(groupVisibilityMap);
+
+ Mockito.verify(xUserMgr).modifyGroupsVisibility(groupVisibilityMap);
+ }
+ @Test
+ public void test8deleteXGroupTrue() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+ boolean forceDelete = false;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+
+ forceDelete=true;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete);
+ xUserRest.deleteXGroup(id,request);
+ Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @Test
+ public void test9deleteXGroupFalse() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete ;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete);
+ xUserRest.deleteXGroup(id,request);
+ Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @Test
+ public void test10deleteXGroupNotEmpty() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete ;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete);
+ xUserRest.deleteXGroup(id,request);
+ Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test11searchXGroups() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "name", "group name", null)).thenReturn("");
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "isVisible", "Group Visibility")).thenReturn(1);
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "groupSource", "group source", null)).thenReturn("");
+ VXGroupList testvXGroupList=createxGroupList();
+ Mockito.when(xUserMgr.searchXGroups(testSearchCriteria)).thenReturn(testvXGroupList);
+ VXGroupList outputvXGroupList=xUserRest.searchXGroups(request);
+
+ Mockito.verify(xUserMgr).searchXGroups(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "name", "group name", null);
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "isVisible", "Group Visibility");
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "groupSource", "group source", null);
+ assertNotNull(outputvXGroupList);
+ assertEquals(outputvXGroupList.getTotalCount(),testvXGroupList.getTotalCount());
+ assertEquals(outputvXGroupList.getClass(),testvXGroupList.getClass());
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test12countXGroups() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXGroupSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXGroups(request);
+ Mockito.verify(xUserMgr).getXGroupSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+
+ }
+ @Test
+ public void test13getXUser() {
+
+ Mockito.when(xUserMgr.getXUser(id)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.getXUser(id);
+ Mockito.verify(xUserMgr).getXUser(id);
+
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+ }
+ @Test
+ public void test14secureGetXUser() {
+
+ Mockito.when(xUserMgr.getXUser(id)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.secureGetXUser(id);
+ Mockito.verify(xUserMgr).getXUser(id);
+
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+ }
+ @Test
+ public void test15createXUser() {
+
+ Mockito.when(xUserMgr.createXUserWithOutLogin(vxUser)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.createXUser(vxUser);
+ Mockito.verify(xUserMgr).createXUserWithOutLogin(vxUser);
+
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+ }
+ @Test
+ public void test16createXUserGroupFromMap() {
+ VXUserGroupInfo vXUserGroupInfo= new VXUserGroupInfo();
+ vXUserGroupInfo.setXuserInfo(vxUser);
+
+ Mockito.when(xUserMgr.createXUserGroupFromMap(vXUserGroupInfo)).thenReturn(vXUserGroupInfo);
+ VXUserGroupInfo gotVXUserGroupInfo=xUserRest.createXUserGroupFromMap(vXUserGroupInfo);
+ Mockito.verify(xUserMgr).createXUserGroupFromMap(vXUserGroupInfo);
+
+ assertNotNull(gotVXUserGroupInfo);
+ assertEquals(vXUserGroupInfo.getId(), gotVXUserGroupInfo.getId());
+ assertEquals(vXUserGroupInfo.getOwner(), gotVXUserGroupInfo.getOwner());
+ }
+ @Test
+ public void test17secureCreateXUser() {
+ Boolean val= true;
+ Mockito.when(bizUtil.checkUserAccessible(vxUser)).thenReturn(val);
+ Mockito.when(xUserMgr.createXUser(vxUser)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.secureCreateXUser(vxUser);
+ Mockito.verify(xUserMgr).createXUser(vxUser);
+ Mockito.verify(bizUtil).checkUserAccessible(vxUser);
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+
+ }
+ @Test
+ public void test18updateXUser() {
+ Mockito.when(xUserMgr.updateXUser(vxUser)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.updateXUser(vxUser);
+ Mockito.verify(xUserMgr).updateXUser(vxUser);
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+ }
+ @Test
+ public void test19secureUpdateXUser() {
+
+ Boolean val= true;
+ Mockito.when(bizUtil.checkUserAccessible(vxUser)).thenReturn(val);
+ Mockito.when(xUserMgr.updateXUser(vxUser)).thenReturn(vxUser);
+ VXUser gotVXUser=xUserRest.secureUpdateXUser(vxUser);
+ Mockito.verify(xUserMgr).updateXUser(vxUser);
+ Mockito.verify(bizUtil).checkUserAccessible(vxUser);
+
+ assertNotNull(gotVXUser);
+ assertEquals(vxUser.getId(), gotVXUser.getId());
+ assertEquals(vxUser.getName(), gotVXUser.getName());
+ }
+ @Test
+ public void test20modifyUserVisibility() {
+ HashMap<Long, Integer> testVisibilityMap= new HashMap<Long, Integer>();
+ testVisibilityMap.put(1L,0);
+ Mockito.doNothing().when(xUserMgr).modifyUserVisibility(testVisibilityMap);
+ xUserRest.modifyUserVisibility(testVisibilityMap);
+ Mockito.verify(xUserMgr).modifyUserVisibility(testVisibilityMap);
+ }
+ @Test
+ public void test21deleteXUser() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ boolean forceDelete = false;
+ String TestforceDeleteStr="true";
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ forceDelete = true;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete);
+ xUserRest.deleteXUser(id, request);
+ Mockito.verify(xUserMgr).deleteXUser(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @Test
+ public void test22deleteXUserFalse() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete ;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete);
+ xUserRest.deleteXUser(id,request);
+ Mockito.verify(xUserMgr).deleteXUser(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @Test
+ public void test23deleteXUserNotEmpty() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete ;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete);
+ xUserRest.deleteXUser(id,request);
+ Mockito.verify(xUserMgr).deleteXUser(id,forceDelete);
+ Mockito.verify(request).getParameter("forceDelete");
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test24searchXUsers() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyList())).thenReturn(testSearchCriteria);
+
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "name", "User name", null)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "emailAddress", "Email Address",null)).thenReturn("");
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "userSource", "User Source")).thenReturn(1);
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "isVisible", "User Visibility")).thenReturn(1);
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "status", "User Status")).thenReturn(1);
+ Mockito.when(searchUtil.extractStringList(request, testSearchCriteria, "userRoleList", "User Role List", "userRoleList", null,null)).thenReturn(new ArrayList<String>());
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userRole", "UserRole", null)).thenReturn("");
+
+ List<VXUser> vXUsersList= new ArrayList<VXUser>();
+ vXUsersList.add(vxUser);
+ VXUserList testVXUserList= new VXUserList();
+ testVXUserList.setVXUsers(vXUsersList);
+
+ Mockito.when(xUserMgr.searchXUsers(testSearchCriteria)).thenReturn(testVXUserList);
+ VXUserList gotVXUserList=xUserRest.searchXUsers(request);
+
+ Mockito.verify(xUserMgr).searchXUsers(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "name", "User name", null);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "emailAddress", "Email Address",null);
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "userSource", "User Source");
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "isVisible", "User Visibility");
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "status", "User Status");
+ Mockito.verify(searchUtil).extractStringList(request, testSearchCriteria, "userRoleList", "User Role List", "userRoleList", null,null);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userRole", "UserRole", null);
+ assertNotNull(gotVXUserList);
+ assertEquals(testVXUserList.getTotalCount(),gotVXUserList.getTotalCount());
+ assertEquals(testVXUserList.getClass(),gotVXUserList.getClass());
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test25countXUsers() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXUserSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXUsers(request);
+ Mockito.verify(xUserMgr).getXUserSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+ }
+ @Test
+ public void test26getXGroupUser() {
+ VXGroupUser testVXGroupUser= createVXGroupUser();
+
+ Mockito.when(xUserMgr.getXGroupUser(id)).thenReturn(testVXGroupUser);
+ VXGroupUser retVxGroupUser= xUserRest.getXGroupUser(id);
+
+ assertNotNull(retVxGroupUser);
+ assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass());
+ assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId());
+ Mockito.verify(xUserMgr).getXGroupUser(id);
+ }
+ @Test
+ public void test27createXGroupUser() {
+ VXGroupUser testVXGroupUser= createVXGroupUser();
+
+ Mockito.when(xUserMgr.createXGroupUser(testVXGroupUser)).thenReturn(testVXGroupUser);
+ VXGroupUser retVxGroupUser= xUserRest.createXGroupUser(testVXGroupUser);
+
+ assertNotNull(retVxGroupUser);
+ assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass());
+ assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId());
+ Mockito.verify(xUserMgr).createXGroupUser(testVXGroupUser);
+ }
+ @Test
+ public void test28updateXGroupUser() {
+ VXGroupUser testVXGroupUser= createVXGroupUser();
+
+ Mockito.when(xUserMgr.updateXGroupUser(testVXGroupUser)).thenReturn(testVXGroupUser);
+ VXGroupUser retVxGroupUser= xUserRest.updateXGroupUser(testVXGroupUser);
+
+ assertNotNull(retVxGroupUser);
+ assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass());
+ assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId());
+ Mockito.verify(xUserMgr).updateXGroupUser(testVXGroupUser);
+ }
+
+ @Test
+ public void test29deleteXGroupUser() {
+ boolean force = true;
+
+ Mockito.doNothing().when(xUserMgr).deleteXGroupUser(id, force);
+ xUserRest.deleteXGroupUser(id,request);
+ Mockito.verify(xUserMgr).deleteXGroupUser(id,force);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test30searchXGroupUsers() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ VXGroupUserList testVXGroupUserList=new VXGroupUserList();
+ VXGroupUser vXGroupUser = createVXGroupUser();
+ List<VXGroupUser> vXGroupUsers= new ArrayList<VXGroupUser>();
+ vXGroupUsers.add(vXGroupUser);
+ testVXGroupUserList.setVXGroupUsers(vXGroupUsers);
+ Mockito.when(xUserMgr.searchXGroupUsers(testSearchCriteria)).thenReturn(testVXGroupUserList);
+ VXGroupUserList outputvXGroupList=xUserRest.searchXGroupUsers(request);
+
+ Mockito.verify(xUserMgr).searchXGroupUsers(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(outputvXGroupList);
+ assertEquals(outputvXGroupList.getClass(),testVXGroupUserList.getClass());
+ assertEquals(outputvXGroupList.getResultSize(),testVXGroupUserList.getResultSize());
+
+ } @SuppressWarnings("unchecked")
+ @Test
+ public void test31countXGroupUserst() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXGroupUserSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXGroupUsers(request);
+ Mockito.verify(xUserMgr).getXGroupUserSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+ }
+ @Test
+ public void test32getXGroupGroup() {
+ VXGroupGroup compareTestVXGroup=createVXGroupGroup();
+
+ Mockito.when(xUserMgr.getXGroupGroup(id)).thenReturn(compareTestVXGroup);
+ VXGroupGroup retVxGroup= xUserRest.getXGroupGroup(id);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass());
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ Mockito.verify(xUserMgr).getXGroupGroup(id);
+ } @Test
+ public void test33createXGroupGroup() {
+ VXGroupGroup compareTestVXGroup=createVXGroupGroup();
+
+ Mockito.when(xUserMgr.createXGroupGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroupGroup retVxGroup= xUserRest.createXGroupGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass());
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ Mockito.verify(xUserMgr).createXGroupGroup(compareTestVXGroup);
+ }
+ @Test
+ public void test34updateXGroupGroup() {
+ VXGroupGroup compareTestVXGroup=createVXGroupGroup();
+
+ Mockito.when(xUserMgr.updateXGroupGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup);
+ VXGroupGroup retVxGroup= xUserRest.updateXGroupGroup(compareTestVXGroup);
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass());
+ assertEquals(compareTestVXGroup.getId(),retVxGroup.getId());
+ Mockito.verify(xUserMgr).updateXGroupGroup(compareTestVXGroup);
+ }
+ @Test
+ public void test35deleteXGroupGroup() {
+ boolean forceDelete = false;
+
+ Mockito.doNothing().when(xUserMgr).deleteXGroupGroup(id, forceDelete);
+ xUserRest.deleteXGroupGroup(id,request);
+ Mockito.verify(xUserMgr).deleteXGroupGroup(id,forceDelete);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test36searchXGroupGroups() {
+ VXGroupGroupList testvXGroupGroupList=new VXGroupGroupList();
+ VXGroupGroup testVXGroup=createVXGroupGroup();
+ List<VXGroupGroup> testVXGroupGroups= new ArrayList<VXGroupGroup>();
+ testVXGroupGroups.add(testVXGroup);
+ testvXGroupGroupList.setVXGroupGroups(testVXGroupGroups);
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ Mockito.when(xUserMgr.searchXGroupGroups(testSearchCriteria)).thenReturn(testvXGroupGroupList);
+ VXGroupGroupList outputvXGroupGroupList=xUserRest.searchXGroupGroups(request);
+
+ Mockito.verify(xUserMgr).searchXGroupGroups(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(outputvXGroupGroupList);
+ assertEquals(outputvXGroupGroupList.getClass(),testvXGroupGroupList.getClass());
+ assertEquals(outputvXGroupGroupList.getResultSize(),testvXGroupGroupList.getResultSize());
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test37countXGroupGroups() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXGroupGroupSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXGroupGroups(request);
+ Mockito.verify(xUserMgr).getXGroupGroupSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ }
+ @Test
+ public void test38getXPermMapVXResourceNull() throws Exception{
+ VXPermMap permMap = testcreateXPermMap();
+
+ Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(permMap);
+ VXResource testVxResource= new VXResource();
+ Mockito.when(xResourceService.readResource(null)).thenReturn(testVxResource);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXPermMap retVxGroup= xUserRest.getXPermMap(id);
+
+ Mockito.verify(xUserMgr).getXPermMap(id);
+ Mockito.verify(xResourceService).readResource(null);
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject());
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+
+
+ }
+ @Test
+ public void test39getXPermMapNotNull() throws Exception{
+ VXPermMap permMap = testcreateXPermMap();
+
+ Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(permMap);
+ VXResource testVxResource= new VXResource();
+ Mockito.when(xResourceService.readResource(id)).thenReturn(testVxResource);
+
+ VXPermMap retVxGroup=xUserRest.getXPermMap(id);
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+ Mockito.verify(xUserMgr).getXPermMap(id);
+ Mockito.verify(xResourceService).readResource(id);
+ }
+ @Test
+ public void test40getXPermMapNull() {
+
+ Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(null);
+ VXPermMap retVxGroup=xUserRest.getXPermMap(id);
+ assertNull(retVxGroup);
+ Mockito.verify(xUserMgr).getXPermMap(id);
+ }
+
+ @Test
+ public void test41createXPermMap() {
+
+ VXPermMap permMap = testcreateXPermMap();
+ permMap.setResourceId(null);
+ Mockito.when(xUserMgr.createXPermMap(permMap)).thenReturn(permMap);
+ Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXPermMap retVxGroup=xUserRest.createXPermMap(permMap);
+
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+
+ Mockito.verify(xUserMgr).createXPermMap(permMap);
+ Mockito.verify(xResourceService).readResource(permMap.getResourceId());
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject());
+ }
+
+ @Test
+ public void test42createXPermMapNull() {
+
+ Mockito.when(xUserMgr.createXPermMap(null)).thenReturn(null);
+ VXPermMap retVxGroup=xUserRest.createXPermMap(null);
+ Mockito.verify(xUserMgr).createXPermMap(null);
+ assertNull(retVxGroup);
+
+ }
+
+ @Test
+ public void test43createXPermMapNullVXResource() {
+ VXPermMap permMap = testcreateXPermMap();
+ permMap.setResourceId(null);
+ Mockito.when(xUserMgr.createXPermMap(permMap)).thenReturn(permMap);
+ VXResource testVxResource= new VXResource();
+ Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(testVxResource);
+
+ VXPermMap retVxGroup=xUserRest.createXPermMap(permMap);
+
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+
+ Mockito.verify(xUserMgr).createXPermMap(permMap);
+ Mockito.verify(xResourceService).readResource(permMap.getResourceId());
+ }
+
+ @Test
+ public void test44updateXPermMap() {
+
+ VXPermMap permMap = testcreateXPermMap();
+
+ VXResource testVxResource= new VXResource();
+ Mockito.when(xResourceService.readResource(id)).thenReturn(testVxResource);
+ Mockito.when(xUserMgr.updateXPermMap(permMap)).thenReturn(permMap);
+ VXPermMap retVxGroup=xUserRest.updateXPermMap(permMap);
+
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+
+ Mockito.verify(xUserMgr).updateXPermMap(permMap);
+ Mockito.verify(xResourceService).readResource(permMap.getResourceId());
+ }
+ @Test
+ public void test45updateXPermMap() {
+ Mockito.when(xUserMgr.updateXPermMap(null)).thenReturn(null);
+ VXPermMap retVxGroup=xUserRest.updateXPermMap(null);
+ assertNull(retVxGroup);
+ Mockito.verify(xUserMgr).updateXPermMap(null);
+ }
+ @Test
+ public void test46updateXPermMap() {
+ VXPermMap permMap = testcreateXPermMap();
+
+ Mockito.when(xUserMgr.updateXPermMap(permMap)).thenReturn(permMap);
+ Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXPermMap retVxGroup=xUserRest.updateXPermMap(permMap);
+
+ assertEquals(permMap.getId(),retVxGroup.getId());
+ assertEquals(permMap.getClass(),retVxGroup.getClass());
+ assertNotNull(retVxGroup);
+
+ Mockito.verify(xUserMgr).updateXPermMap(permMap);
+ Mockito.verify(xResourceService).readResource(permMap.getResourceId());
+ Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString());
+
+ }
+ @Test
+ public void test47deleteXPermMap() {
+ Boolean forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXPermMap(id, forceDelete);
+ xUserRest.deleteXPermMap(id,request);
+ Mockito.verify(xUserMgr).deleteXPermMap(id,forceDelete);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test48searchXPermMaps() {
+ VXPermMap permMap = testcreateXPermMap();
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ List <VXPermMap> vXPermMaps= new ArrayList<VXPermMap>();
+ vXPermMaps.add(permMap);
+ VXPermMapList testvXGroupList=new VXPermMapList() ;
+ testvXGroupList.setTotalCount(1);
+ testvXGroupList.setVXPermMaps(vXPermMaps);
+ Mockito.when(xUserMgr.searchXPermMaps(testSearchCriteria)).thenReturn(testvXGroupList);
+ VXPermMapList outputvXGroupList=xUserRest.searchXPermMaps(request);
+
+ Mockito.verify(xUserMgr).searchXPermMaps(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(outputvXGroupList);
+ assertEquals(outputvXGroupList.getClass(),testvXGroupList.getClass());
+ assertEquals(outputvXGroupList.getTotalCount(),testvXGroupList.getTotalCount());
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test49countXPermMaps() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+ Mockito.when(xUserMgr.getXPermMapSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXPermMaps(request);
+ Mockito.verify(xUserMgr).getXPermMapSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ }
+ @Test
+ public void test50getXAuditMapVXAuditMapNull() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ Mockito.when(xUserMgr.getXAuditMap(testvXAuditMap.getResourceId())).thenReturn(testvXAuditMap);
+ VXResource testVxResource= createVXResource();
+ Mockito.when(xResourceService.readResource(null)).thenReturn(testVxResource);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(testvXAuditMap.getResourceId());
+
+ assertEquals(testvXAuditMap.getId(),retVXAuditMap.getId());
+ assertEquals(testvXAuditMap.getClass(),retVXAuditMap.getClass());
+ assertNotNull(retVXAuditMap);
+
+ Mockito.verify(xUserMgr).getXAuditMap(testvXAuditMap.getResourceId());
+ Mockito.verify(xResourceService).readResource(null);
+ Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject()));
+
+ }
+ @Test
+ public void test51getXAuditMapNull() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ Mockito.when(xUserMgr.getXAuditMap(testvXAuditMap.getResourceId())).thenReturn(null);
+ VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(testvXAuditMap.getResourceId());
+
+ assertNull(retVXAuditMap);
+
+ Mockito.verify(xUserMgr).getXAuditMap(testvXAuditMap.getResourceId());
+
+
+ }
+ @Test
+ public void test52getXAuditMap() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+
+
+ Mockito.when(xUserMgr.getXAuditMap(id)).thenReturn(testvXAuditMap);
+ VXResource testVxResource= createVXResource();
+ Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource);
+
+ VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(id);
+
+ assertEquals(testvXAuditMap.getId(),retVXAuditMap.getId());
+ assertEquals(testvXAuditMap.getClass(),retVXAuditMap.getClass());
+ assertNotNull(retVXAuditMap);
+
+ Mockito.verify(xUserMgr).getXAuditMap(id);
+ Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId());
+
+
+ }
+
+ @Test
+ public void test53createXAuditMap() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+
+ Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap);
+ VXResource testVxResource= createVXResource();
+ Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource);
+ VXAuditMap retvXAuditMap= xUserRest.createXAuditMap(testvXAuditMap);
+ assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId());
+ assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass());
+ assertNotNull(retvXAuditMap);
+
+ Mockito.verify(xUserMgr).createXAuditMap(testvXAuditMap);
+ Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId());
+
+
+ }
+
+ @Test
+ public void test54createXAuditMapVxResourceNull() {
+
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ testvXAuditMap.setResourceId(null);
+ Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap);
+
+ Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(null);
+
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+
+ VXAuditMap retvXAuditMap= xUserRest.createXAuditMap(testvXAuditMap);
+ assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId());
+ assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass());
+ assertNotNull(retvXAuditMap);
+
+ Mockito.verify(xUserMgr).createXAuditMap(testvXAuditMap);
+ Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId());
+ Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject()));
+
+ }@Test
+ public void test55createXAuditMapNull() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ testvXAuditMap.setResourceId(null);
+ Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(null);
+ VXAuditMap retvXAuditMap=xUserRest.createXAuditMap(null);
+ assertNull(retvXAuditMap);
+ Mockito.verify(xUserMgr).createXAuditMap(null);
+
+ }
+
+ @Test
+ public void test56updateXAuditMap() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ testvXAuditMap.setResourceId(id);
+ Mockito.when(xUserMgr.updateXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap);
+ VXResource testVxResource= createVXResource();
+ Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource);
+
+ VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(testvXAuditMap);
+ assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId());
+ assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass());
+ assertNotNull(retvXAuditMap);
+
+ Mockito.verify(xUserMgr).updateXAuditMap(testvXAuditMap);
+ Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId());
+
+
+ }
+ @Test
+ public void test57updateXAuditMapNull() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+
+
+ Mockito.when(xUserMgr.updateXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap);
+ Mockito.when(xResourceService.readResource(null)).thenReturn(null);
+ Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(testvXAuditMap);
+ assertNull(retvXAuditMap);
+ Mockito.verify(xUserMgr).updateXAuditMap(testvXAuditMap);
+ Mockito.verify(xResourceService).readResource(null);
+ Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject()));
+ }
+ @Test
+ public void test58updateXAuditMapVXResourceNull() {
+
+ Mockito.when(xUserMgr.updateXAuditMap(null)).thenReturn(null);
+ VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(null);
+ Mockito.verify(xUserMgr).updateXAuditMap(null);
+ assertNull(retvXAuditMap);
+
+ }
+ @Test
+ public void test59deleteXAuditMap() {
+
+ Boolean forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXAuditMap(id, forceDelete);
+ xUserRest.deleteXAuditMap(id,request);
+ Mockito.verify(xUserMgr).deleteXAuditMap(id,forceDelete);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test60searchXAuditMaps() {
+ VXAuditMap testvXAuditMap = createVXAuditMapObj();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ List <VXAuditMap> testvXAuditMaps= new ArrayList<VXAuditMap>();
+ testvXAuditMaps.add(testvXAuditMap);
+ VXAuditMapList testVXAuditMapList=new VXAuditMapList() ;
+ testVXAuditMapList.setVXAuditMaps(testvXAuditMaps);
+ Mockito.when(xUserMgr.searchXAuditMaps(testSearchCriteria)).thenReturn(testVXAuditMapList);
+ VXAuditMapList outputVXAuditMapList=xUserRest.searchXAuditMaps(request);
+
+ Mockito.verify(xUserMgr).searchXAuditMaps(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(outputVXAuditMapList);
+ assertEquals(outputVXAuditMapList.getClass(),testVXAuditMapList.getClass());
+ assertEquals(outputVXAuditMapList.getResultSize(),testVXAuditMapList.getResultSize());
+
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test61countXAuditMaps() {
+
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+ Mockito.when(xUserMgr.getXAuditMapSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXAuditMaps(request);
+ Mockito.verify(xUserMgr).getXAuditMapSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertNotNull(testvxLong);
+ }
+ @Test
+ public void test62getXUserByUserName() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXUser compareTestVxUser=createVXUser();
+
+ Mockito.when(xUserMgr.getXUserByUserName("User1")).thenReturn(compareTestVxUser);
+ VXUser retVXUser= xUserRest.getXUserByUserName(request,"User1");
+
+ assertNotNull(retVXUser);
+ assertEquals(compareTestVxUser.getClass(),retVXUser.getClass());
+ assertEquals(compareTestVxUser.getId(),retVXUser.getId());
+ Mockito.verify(xUserMgr).getXUserByUserName("User1");
+ }
+ @Test
+ public void test63getXGroupByGroupName() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXGroup compareTestVXGroup=createVXGroup();
+
+ Mockito.when(xGroupService.getGroupByGroupName(compareTestVXGroup.getName())).thenReturn(compareTestVXGroup);
+
+ VXGroup retVxGroup= xUserRest.getXGroupByGroupName(request,compareTestVXGroup.getName());
+
+ assertNotNull(retVxGroup);
+ assertEquals(compareTestVXGroup.getClass(),compareTestVXGroup.getClass());
+ assertEquals(compareTestVXGroup.getId(),compareTestVXGroup.getId());
+ Mockito.verify(xGroupService).getGroupByGroupName(compareTestVXGroup.getName());
+ }
+ @Test
+ public void test64deleteXUserByUserName() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+ boolean forceDelete = false;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXUser testUser= createVXUser();
+ Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser);
+ forceDelete=true;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete);
+ xUserRest.deleteXUserByUserName(testUser.getName(),request);
+ Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testUser.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test65deleteXUserByUserNametrue() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXUser testUser= createVXUser();
+ Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete);
+ xUserRest.deleteXUserByUserName(testUser.getName(),request);
+ Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testUser.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test66deleteXUserByUserNameNull() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXUser testUser= createVXUser();
+ Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete);
+ xUserRest.deleteXUserByUserName(testUser.getName(),request);
+ Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testUser.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test67deleteXGroupByGroupName() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXGroup testVXGroup= createVXGroup();
+ Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test68deleteXGroupByGroupNameNull() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXGroup testVXGroup= createVXGroup();
+ Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test69deleteXGroupByGroupNameflase() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+ boolean forceDelete = false;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXGroup testVXGroup= createVXGroup();
+ Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup);
+ forceDelete=true;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test70deleteXGroupAndXUser() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXGroup testVXGroup= createVXGroup();
+ VXUser testVXuser= createVXUser();
+
+ Mockito.doNothing().when(xUserMgr).deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName());
+ xUserRest.deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName(),request);
+ Mockito.verify(xUserMgr).deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName());
+
+
+ }
+ @Test
+ public void test71getXUserGroups() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXGroupList groupList = createxGroupList();
+ Mockito.when(xUserMgr.getXUserGroups(id)).thenReturn(groupList);
+ VXGroupList retVxGroupList= xUserRest.getXUserGroups(request,id);
+
+ assertNotNull(retVxGroupList);
+ assertEquals(groupList.getClass(),retVxGroupList.getClass());
+ assertEquals(groupList.getResultSize(),retVxGroupList.getResultSize());
+ Mockito.verify(xUserMgr).getXUserGroups(id);
+ }
+ @Test
+ public void test72getXGroupUsers() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXGroupList groupList = createxGroupList();
+ Mockito.when(xUserMgr.getXUserGroups(id)).thenReturn(groupList);
+ VXGroupList retVxGroupList= xUserRest.getXUserGroups(request,id);
+
+ assertNotNull(retVxGroupList);
+ assertEquals(groupList.getClass(),retVxGroupList.getClass());
+ assertEquals(groupList.getResultSize(),retVxGroupList.getResultSize());
+ Mockito.verify(xUserMgr).getXUserGroups(id);
+ }
+ @Test
+ public void test73getXGroupUsers() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ VXUser testVXUser=createVXUser();
+ VXUserList testVXUserList= new VXUserList();
+ List<VXUser> testVXUsers = new ArrayList<VXUser>();
+ testVXUsers.add(testVXUser);
+ testVXUserList.setVXUsers(testVXUsers);
+ testVXUserList.setStartIndex(1);
+ testVXUserList.setTotalCount(1);
+ Mockito.when(xUserMgr.getXGroupUsers(id)).thenReturn(testVXUserList);
+ VXUserList retVxGroupList= xUserRest.getXGroupUsers(request,id);
+
+ assertNotNull(retVxGroupList);
+ assertEquals(testVXUserList.getTotalCount(),retVxGroupList.getTotalCount());
+ assertEquals(testVXUserList.getStartIndex(),retVxGroupList.getStartIndex());
+ Mockito.verify(xUserMgr).getXGroupUsers(id);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test74getAuthSessions() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+
+ Mockito.when(searchUtil.extractLong(request, testSearchCriteria, "id", "Auth Session Id")).thenReturn(1L);
+ Mockito.when(searchUtil.extractLong(request, testSearchCriteria, "userId", "User Id")).thenReturn(1L);
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "authStatus", "Auth Status")).thenReturn(1);
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "authType", "Auth Type")).thenReturn(1);
+ Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "deviceType", "Device Type")).thenReturn(1);
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "firstName", "User First Name", StringUtil.VALIDATION_NAME)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "lastName", "User Last Name", StringUtil.VALIDATION_NAME)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "requestUserAgent", "User Agent", StringUtil.VALIDATION_TEXT)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "requestIP", "Request IP Address", StringUtil.VALIDATION_IP_ADDRESS)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "loginId", "Login ID", StringUtil.VALIDATION_TEXT)).thenReturn("");
+ Mockito.when(searchUtil.extractDate(request, testSearchCriteria, "startDate", "Start date for search", null)).thenReturn(new Date());
+ Mockito.when(searchUtil.extractDate(request, testSearchCriteria, "endDate", "End date for search", null)).thenReturn(new Date());
+
+
+ VXAuthSessionList testVXAuthSessionList=new VXAuthSessionList();
+ testVXAuthSessionList.setTotalCount(1);
+ testVXAuthSessionList.setStartIndex(1);
+ VXAuthSession testVXAuthSession = createVXAuthSession();
+ List<VXAuthSession> testvXAuthSessions = new ArrayList<VXAuthSession>();
+ testvXAuthSessions.add(testVXAuthSession);
+
+ testVXAuthSessionList.setVXAuthSessions(testvXAuthSessions);
+ Mockito.when(sessionMgr.searchAuthSessions(testSearchCriteria)).thenReturn(testVXAuthSessionList);
+ VXAuthSessionList outputvXGroupList=xUserRest.getAuthSessions(request);
+
+ Mockito.verify(sessionMgr).searchAuthSessions(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ Mockito.verify(searchUtil).extractLong(request, testSearchCriteria, "id", "Auth Session Id");
+ Mockito.verify(searchUtil).extractLong(request, testSearchCriteria, "userId", "User Id");
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "authStatus", "Auth Status");
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "authType", "Auth Type");
+ Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "deviceType", "Device Type");
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "firstName", "User First Name", StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "lastName", "User Last Name", StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "requestUserAgent", "User Agent", StringUtil.VALIDATION_TEXT);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "requestIP", "Request IP Address", StringUtil.VALIDATION_IP_ADDRESS);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "loginId", "Login ID", StringUtil.VALIDATION_TEXT);
+ Mockito.verify(searchUtil).extractDate(request, testSearchCriteria, "startDate", "Start date for search", null);
+ Mockito.verify(searchUtil).extractDate(request, testSearchCriteria, "endDate", "End date for search", null);
+ assertNotNull(outputvXGroupList);
+ assertEquals(outputvXGroupList.getStartIndex(),testVXAuthSessionList.getStartIndex());
+ assertEquals(outputvXGroupList.getTotalCount(), testVXAuthSessionList.getTotalCount());
+ }
+ @Test
+ public void test75getAuthSession() {
+ String authSessionId ="testauthSessionId";
+ VXAuthSession testVXAuthSession= createVXAuthSession();
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ Mockito.when(request.getParameter("extSessionId")).thenReturn(authSessionId);
+ Mockito.when(sessionMgr.getAuthSessionBySessionId(authSessionId)).thenReturn(testVXAuthSession);
+ VXAuthSession retVXAuthSession=xUserRest.getAuthSession(request);
+ Mockito.verify(sessionMgr).getAuthSessionBySessionId(authSessionId);
+ Mockito.verify(request).getParameter("extSessionId");
+ assertEquals(testVXAuthSession.getId(), retVXAuthSession.getId());
+ assertEquals(testVXAuthSession.getClass(), retVXAuthSession.getClass());
+ assertNotNull(retVXAuthSession);
+ }
+ @Test
+ public void test76createXModuleDefPermission() {
+
+ VXModuleDef testVXModuleDef = createVXModuleDef();
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+
+ Mockito.when(xUserMgr.createXModuleDefPermission(testVXModuleDef)).thenReturn(testVXModuleDef);
+ VXModuleDef retVxModuleDef=xUserRest.createXModuleDefPermission(testVXModuleDef);
+
+ assertNotNull(retVxModuleDef);
+ assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId());
+ assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner());
+ Mockito.verify(xUserMgr).createXModuleDefPermission(testVXModuleDef);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+
+ }
+ @Test
+ public void test77getXModuleDefPermission() {
+ VXModuleDef testVXModuleDef=createVXModuleDef();
+ Mockito.when(xUserMgr.getXModuleDefPermission(testVXModuleDef.getId())).thenReturn(testVXModuleDef);
+ VXModuleDef retVxModuleDef=xUserRest.getXModuleDefPermission(testVXModuleDef.getId());
+
+ assertNotNull(retVxModuleDef);
+ assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId());
+ assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner());
+
+ Mockito.verify(xUserMgr).getXModuleDefPermission(testVXModuleDef.getId());
+
+ }
+ @Test
+ public void test78updateXModuleDefPermission() {
+
+ VXModuleDef testVXModuleDef = createVXModuleDef();
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+
+ Mockito.when(xUserMgr.updateXModuleDefPermission(testVXModuleDef)).thenReturn(testVXModuleDef);
+ VXModuleDef retVxModuleDef=xUserRest.updateXModuleDefPermission(testVXModuleDef);
+
+ assertNotNull(retVxModuleDef);
+ assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId());
+ assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner());
+
+ Mockito.verify(xUserMgr).updateXModuleDefPermission(testVXModuleDef);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ }
+ @Test
+ public void test79deleteXModuleDefPermission() {
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+ boolean forceDelete = true;
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+ Mockito.doNothing().when(xUserMgr).deleteXModuleDefPermission(id, forceDelete);
+ xUserRest.deleteXModuleDefPermission(id,request);
+ Mockito.verify(xUserMgr).deleteXModuleDefPermission(id,forceDelete);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test80searchXModuleDef() {
+ VXModuleDefList testVXModuleDefList= new VXModuleDefList() ;
+ VXModuleDef vXModuleDef=createVXModuleDef();
+ List<VXModuleDef> VXModuleDefs= new ArrayList<VXModuleDef>();
+ VXModuleDefs.add(vXModuleDef);
+ testVXModuleDefList.setvXModuleDef(VXModuleDefs);
+ testVXModuleDefList.setTotalCount(1);
+ testVXModuleDefList.setStartIndex(1);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "module","modulename", null)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "moduleDefList","id", null)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userName","userName", null)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "groupName","groupName", null)).thenReturn("");
+
+ Mockito.when(xUserMgr.searchXModuleDef(testSearchCriteria)).thenReturn(testVXModuleDefList);
+ VXModuleDefList outputVXModuleDefList=xUserRest.searchXModuleDef(request);
+ assertNotNull(outputVXModuleDefList);
+ assertEquals(outputVXModuleDefList.getTotalCount(),testVXModuleDefList.getTotalCount());
+ assertEquals(outputVXModuleDefList.getStartIndex(),testVXModuleDefList.getStartIndex());
+
+ Mockito.verify(xUserMgr).searchXModuleDef(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "module","modulename", null);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "moduleDefList","id", null);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userName","userName", null);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "groupName","groupName", null);
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test81countXModuleDef() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXModuleDefSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXModuleDef(request);
+ Mockito.verify(xUserMgr).getXModuleDefSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+ }
+ @Test
+ public void test82createXUserPermission() {
+ VXUserPermission testvXUserPermission = createVXUserPermission();
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+ Mockito.when(xUserMgr.createXUserPermission(testvXUserPermission)).thenReturn(testvXUserPermission);
+ VXUserPermission retVXUserPermission=xUserRest.createXUserPermission(testvXUserPermission);
+ Mockito.verify(xUserMgr).createXUserPermission(testvXUserPermission);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ assertNotNull(retVXUserPermission);
+ assertEquals(retVXUserPermission.getId(), testvXUserPermission.getId());
+ assertEquals(retVXUserPermission.getUserName(), testvXUserPermission.getUserName());
+ }
+ @Test
+ public void test83getXUserPermission() {
+ VXUserPermission testVXUserPermission=createVXUserPermission();
+ Mockito.when(xUserMgr.getXUserPermission(testVXUserPermission.getId())).thenReturn(testVXUserPermission);
+ VXUserPermission retVXUserPermission=xUserRest.getXUserPermission(testVXUserPermission.getId());
+ Mockito.verify(xUserMgr).getXUserPermission(id);
+ assertNotNull(retVXUserPermission);
+ assertEquals(retVXUserPermission.getId(), testVXUserPermission.getId());
+ assertEquals(retVXUserPermission.getUserName(), testVXUserPermission.getUserName());
+ }
+ @Test
+ public void test84updateXUserPermission() {
+ VXUserPermission testvXUserPermission = createVXUserPermission();
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+ Mockito.when(xUserMgr.updateXUserPermission(testvXUserPermission)).thenReturn(testvXUserPermission);
+ VXUserPermission retVXUserPermission=xUserRest.updateXUserPermission(testvXUserPermission);
+ Mockito.verify(xUserMgr).updateXUserPermission(testvXUserPermission);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ assertNotNull(retVXUserPermission);
+ assertEquals(retVXUserPermission.getId(), testvXUserPermission.getId());
+ assertEquals(retVXUserPermission.getUserName(), testvXUserPermission.getUserName());
+
+ }
+ @Test
+ public void test85deleteXUserPermission() {
+ boolean forceDelete = true;
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+
+ Mockito.doNothing().when(xUserMgr).deleteXUserPermission(id, forceDelete);
+ xUserRest.deleteXUserPermission(id,request);
+ Mockito.verify(xUserMgr).deleteXUserPermission(id,forceDelete);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test86searchXUserPermission() {
+ VXUserPermissionList testVXUserPermissionList= new VXUserPermissionList() ;
+ testVXUserPermissionList.setTotalCount(1);
+ testVXUserPermissionList.setStartIndex(1);
+ VXUserPermission testVXUserPermission=createVXUserPermission();
+ List<VXUserPermission> testVXUserPermissions= new ArrayList<VXUserPermission>();
+ testVXUserPermissions.add(testVXUserPermission);
+ testVXUserPermissionList.setvXModuleDef(testVXUserPermissions);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userPermissionList","userId", StringUtil.VALIDATION_NAME)).thenReturn("");
+
+
+ Mockito.when(xUserMgr.searchXUserPermission(testSearchCriteria)).thenReturn(testVXUserPermissionList);
+ VXUserPermissionList outputVXUserPermissionList=xUserRest.searchXUserPermission(request);
+ assertNotNull(outputVXUserPermissionList);
+ assertEquals(outputVXUserPermissionList.getStartIndex(),testVXUserPermissionList.getStartIndex());
+ assertEquals(outputVXUserPermissionList.getTotalCount(),testVXUserPermissionList.getTotalCount());
+
+ Mockito.verify(xUserMgr).searchXUserPermission(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userPermissionList","userId", StringUtil.VALIDATION_NAME);
+
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test87countXUserPermission() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXUserPermissionSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXUserPermission(request);
+ Mockito.verify(xUserMgr).getXUserPermissionSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+
+ }
+ @Test
+ public void test88createXGroupPermission() {
+
+ VXGroupPermission testVXGroupPermission = createVXGroupPermission();
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+ Mockito.when(xUserMgr.createXGroupPermission(testVXGroupPermission)).thenReturn(testVXGroupPermission);
+ VXGroupPermission retVXGroupPermission=xUserRest.createXGroupPermission(testVXGroupPermission);
+ Mockito.verify(xUserMgr).createXGroupPermission(testVXGroupPermission);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ assertNotNull(retVXGroupPermission);
+ assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId());
+ assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass());
+
+ }
+ @Test
+ public void test89getXGroupPermission() {
+ VXGroupPermission testVXGroupPermission =createVXGroupPermission();
+ Mockito.when(xUserMgr.getXGroupPermission(testVXGroupPermission.getId())).thenReturn(testVXGroupPermission);
+ VXGroupPermission retVXGroupPermission=xUserRest.getXGroupPermission(testVXGroupPermission.getId());
+ Mockito.verify(xUserMgr).getXGroupPermission(testVXGroupPermission.getId());
+ assertNotNull(retVXGroupPermission);
+ assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId());
+ assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass());
+
+ }
+ @Test
+ public void test90updateXGroupPermission() {
+
+ VXGroupPermission testVXGroupPermission = createVXGroupPermission();
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+ Mockito.when(xUserMgr.updateXGroupPermission(testVXGroupPermission)).thenReturn(testVXGroupPermission);
+ VXGroupPermission retVXGroupPermission=xUserRest.updateXGroupPermission(testVXGroupPermission);
+ Mockito.verify(xUserMgr).updateXGroupPermission(testVXGroupPermission);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ assertNotNull(retVXGroupPermission);
+ assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId());
+ assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass());
+
+
+ }
+ @Test
+ public void test91deleteXGroupPermission() {
+
+ boolean forceDelete = true;
+
+ Mockito.doNothing().when(xUserMgr).checkAdminAccess();
+
+ Mockito.doNothing().when(xUserMgr).deleteXGroupPermission(id, forceDelete);
+ xUserRest.deleteXGroupPermission(id,request);
+ Mockito.verify(xUserMgr).deleteXGroupPermission(id,forceDelete);
+ Mockito.verify(xUserMgr).checkAdminAccess();
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test92searchXGroupPermission() {
+ VXGroupPermissionList testVXGroupPermissionList= new VXGroupPermissionList() ;
+ testVXGroupPermissionList.setTotalCount(1);
+ VXGroupPermission testVXGroupPermission=createVXGroupPermission();
+ List<VXGroupPermission> testVXGroupPermissions= new ArrayList<VXGroupPermission>();
+ testVXGroupPermissions.add(testVXGroupPermission);
+ testVXGroupPermissionList.setvXGroupPermission(testVXGroupPermissions);
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME)).thenReturn("");
+ Mockito.when(searchUtil.extractString(request, testSearchCriteria,"groupPermissionList", "groupId", StringUtil.VALIDATION_NAME)).thenReturn("");
+ Mockito.when(xUserMgr.searchXGroupPermission(testSearchCriteria)).thenReturn(testVXGroupPermissionList);
+ VXGroupPermissionList outputVXGroupPermissionList=xUserRest.searchXGroupPermission(request);
+ assertNotNull(outputVXGroupPermissionList);
+ assertEquals(outputVXGroupPermissionList.getClass(),testVXGroupPermissionList.getClass());
+ assertEquals(outputVXGroupPermissionList.getTotalCount(),testVXGroupPermissionList.getTotalCount());
+
+ Mockito.verify(xUserMgr).searchXGroupPermission(testSearchCriteria);
+
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME);
+ Mockito.verify(searchUtil).extractString(request, testSearchCriteria,"groupPermissionList", "groupId", StringUtil.VALIDATION_NAME);
+ }
+ @SuppressWarnings("unchecked")
+ @Test
+ public void test93countXGroupPermission() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ SearchCriteria testSearchCriteria=createsearchCriteria();
+
+ Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria);
+
+ vXLong.setValue(1);
+
+ Mockito.when(xUserMgr.getXGroupPermissionSearchCount(testSearchCriteria)).thenReturn(vXLong);
+ VXLong testvxLong=xUserRest.countXGroupPermission(request);
+ Mockito.verify(xUserMgr).getXGroupPermissionSearchCount(testSearchCriteria);
+ Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject());
+
+ assertNotNull(testvxLong);
+ assertEquals(testvxLong.getValue(),vXLong.getValue());
+ assertEquals(testvxLong.getClass(),vXLong.getClass());
+
+ }
+ @Test
+ public void test94modifyUserActiveStatus() {
+ HashMap<Long, Integer> statusMap= new HashMap<Long, Integer>();
+ statusMap.put(id, 1);
+ Mockito.doNothing().when(xUserMgr).modifyUserActiveStatus(statusMap);
+ xUserRest.modifyUserActiveStatus(statusMap);
+ Mockito.verify(xUserMgr).modifyUserActiveStatus(statusMap);
+ }
+ @Test
+ public void test95setUserRolesByExternalID() {
+ VXStringList testVXStringList= createVXStringList();
+ Mockito.when(xUserMgr.setUserRolesByExternalID(id, testVXStringList.getVXStrings())).thenReturn(testVXStringList);
+ VXStringList retVXStringList=xUserRest.setUserRolesByExternalID(id, testVXStringList);
+ Mockito.verify(xUserMgr).setUserRolesByExternalID(id, testVXStringList.getVXStrings());
+
+ assertNotNull(retVXStringList);
+ assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount());
+ assertEquals(testVXStringList.getClass(), retVXStringList.getClass());
+ }
+ @Test
+ public void test96setUserRolesByName() {
+ VXStringList testVXStringList= createVXStringList();
+ Mockito.when(xUserMgr.setUserRolesByName("Admin", testVXStringList.getVXStrings())).thenReturn(testVXStringList);
+ VXStringList retVXStringList=xUserRest.setUserRolesByName("Admin", testVXStringList);
+ Mockito.verify(xUserMgr).setUserRolesByName("Admin", testVXStringList.getVXStrings());
+
+ assertNotNull(retVXStringList);
+ assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount());
+ assertEquals(testVXStringList.getClass(), retVXStringList.getClass());
+ }
+ @Test
+ public void test97getUserRolesByExternalID() {
+ VXStringList testVXStringList=createVXStringList();
+
+ Mockito.when(xUserMgr.getUserRolesByExternalID(id)).thenReturn(testVXStringList);
+ VXStringList retVXStringList=xUserRest.getUserRolesByExternalID(id);
+ Mockito.verify(xUserMgr).getUserRolesByExternalID(id);
+ assertNotNull(retVXStringList);
+ assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount());
+ assertEquals(testVXStringList.getClass(), retVXStringList.getClass());
+
+ }
+ @Test
+ public void test98getUserRolesByName() {
+
+ VXStringList testVXStringList=createVXStringList();
+
+ Mockito.when(xUserMgr.getUserRolesByName("Admin")).thenReturn(testVXStringList);
+ VXStringList retVXStringList=xUserRest.getUserRolesByName("Admin");
+ Mockito.verify(xUserMgr).getUserRolesByName("Admin");
+ assertNotNull(retVXStringList);
+ assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount());
+ assertEquals(testVXStringList.getClass(), retVXStringList.getClass());
+ }
+ @Test
+ public void test99deleteUsersByUserName() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+ boolean forceDelete = false;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ VXUser testVXUser= createVXUser();
+ VXStringList vxStringList=createVXStringList();
+
+ Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser);
+ forceDelete=true;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test100deleteUsersByUserNameNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ VXUser testVXUser= createVXUser();
+ VXStringList vxStringList=createVXStringList();
+
+ Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test101deleteUsersByUserNameNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ VXUser testVXUser= createVXUser();
+ VXStringList vxStringList=createVXStringList();
+
+ Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test102deleteUsersByUserNameSetValueNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ VXUser testVXUser= createVXUser();
+ VXStringList vxStringList=createVXStringList();
+
+ Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete);
+ Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test103deleteUsersByUserNameListNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ xUserRest.deleteUsersByUserName(request,null);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test104deleteUsersByUserNameListGetListNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXStringList vxStringList=createVXStringList();
+ vxStringList.setVXStrings(null);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test105deleteUsersByUserNameNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue(null);
+
+ VXStringList vxStringList=createVXStringList();
+ List<VXString> testVXStrings=new ArrayList<VXString>();
+ testVXStrings.add(testVXString);
+ vxStringList.setVXStrings(testVXStrings);
+ xUserRest.deleteUsersByUserName(request,vxStringList);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ ////////////////////////////////
+ @Test
+ public void test106deleteGroupsByGroupName() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="true";
+ boolean forceDelete = false;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("testVXGroup");
+ VXGroup testVXGroup= createVXGroup();
+ VXStringList vxStringList=createVXStringListGroup();
+
+ Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup);
+ forceDelete=true;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteGroupsByGroupName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test107GroupsByGroupNameNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("testVXGroup");
+ VXGroup testVXGroup= createVXGroup();
+ VXStringList vxStringList=createVXStringListGroup();
+
+ Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteGroupsByGroupName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test108deleteGroupsByGroupNameNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr=null;
+ boolean forceDelete = true;
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("testVXGroup");
+ VXGroup testVXGroup= createVXGroup();
+ VXStringList vxStringList=createVXStringListGroup();
+
+ Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup);
+ forceDelete=false;
+ Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete);
+ xUserRest.deleteGroupsByGroupName(request,vxStringList);
+ Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete);
+ Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue());
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test109deleteGroupsByGroupN
<TRUNCATED>