RANGER-1170 : Improvement of Unit Test coverage in Ranger
Signed-off-by: Velmurugan Periasamy <vel@apache.org>
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());
+ }
+}
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..fc9cdd9
--- /dev/null
+++ b/security-admin/src/test/java/org/apache/ranger/rest/TestUserREST.java
@@ -0,0 +1,495 @@
+/*
+ * 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;
+
+ @Mock
+ StringUtil stringUtil;
+
+ @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).checkAccessForUpdate(xxPUser);
+ Mockito.doNothing().when(changePassword).setId(userId);
+ Mockito.when(userManager.changePassword(changePassword)).thenReturn(vxResponseExp);
+ Mockito.when(restErrorUtil.createRESTException("serverMsg.userRestUser",MessageEnums.DATA_NOT_FOUND, null, null, changePassword.getLoginId())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ 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).checkAccessForUpdate(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).checkAccessForUpdate(xxPUser);
+ Mockito.doNothing().when(changePassword).setId(userId);
+ Mockito.when(userManager.changeEmailAddress(xxPUser, changePassword)).thenReturn(vxPUserExp);
+ Mockito.when(restErrorUtil.createRESTException("serverMsg.userRestUser",MessageEnums.DATA_NOT_FOUND, null, null, changePassword.getLoginId())).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ 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).checkAccessForUpdate(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
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);
+ }
+
+}
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());
+ }
+}
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 test109deleteGroupsByGroupNameSetValueNull() {
+
+ 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 test110deleteGroupsByGroupNameListNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXString testVXString= new VXString();
+ testVXString.setValue("testVXGroup");
+ xUserRest.deleteGroupsByGroupName(request,null);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test111deleteUsersByUserNameListGetListNull() {
+
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ String TestforceDeleteStr="false";
+
+ Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr);
+ VXStringList vxStringList=createVXStringList();
+ vxStringList.setVXStrings(null);
+ xUserRest.deleteGroupsByGroupName(request,vxStringList);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+ @Test
+ public void test112deleteUsersByUserNameNull() {
+
+ 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=createVXStringListGroup();
+ List<VXString> testVXStrings=new ArrayList<VXString>();
+ testVXStrings.add(testVXString);
+ vxStringList.setVXStrings(testVXStrings);
+ xUserRest.deleteGroupsByGroupName(request,vxStringList);
+ Mockito.verify(request).getParameter("forceDelete");
+
+ }
+
+
+ private HashMap<Long, Integer> creategroupVisibilityMap()
+ {
+ HashMap<Long, Integer> groupVisibilityMap=new HashMap<Long, Integer>();
+ groupVisibilityMap.put(id, 1);
+ return groupVisibilityMap;
+ }
+ private SearchCriteria createsearchCriteria(){
+ SearchCriteria testsearchCriteria = new SearchCriteria();
+ testsearchCriteria.setStartIndex(0);
+ testsearchCriteria.setMaxRows(Integer.MAX_VALUE);
+ testsearchCriteria.setSortBy("id");
+ testsearchCriteria.setSortType("asc");
+ testsearchCriteria.setGetCount(true);
+ testsearchCriteria.setOwnerId(null);
+ testsearchCriteria.setGetChildren(false);
+ testsearchCriteria.setDistinct(false);
+
+ return testsearchCriteria;
+ }
+ private VXGroupList createxGroupList() {
+
+ VXGroupList testVXGroupList= new VXGroupList();
+ VXGroup VXGroup1= createVXGroup();
+ List<VXGroup> vXGroups = new ArrayList<VXGroup>();
+ vXGroups.add(VXGroup1);
+ testVXGroupList.setVXGroups(vXGroups);
+ testVXGroupList.setStartIndex(0);
+ testVXGroupList.setTotalCount(1);
+
+ return testVXGroupList;
+ }
+ private VXUser createVXUser() {
+ VXUser testVXUser= new VXUser();
+ Collection<String>c = new ArrayList<String>();
+ testVXUser.setId(id);
+ testVXUser.setCreateDate(new Date());
+ testVXUser.setUpdateDate(new Date());
+ testVXUser.setOwner("Admin");
+ testVXUser.setUpdatedBy("Admin");
+ testVXUser.setName("User1");
+ testVXUser.setFirstName("FnameUser1");
+ testVXUser.setLastName("LnameUser1");
+ testVXUser.setPassword("User1");
+ testVXUser.setGroupIdList(null);
+ testVXUser.setGroupNameList(null);
+ testVXUser.setStatus(1);
+ testVXUser.setIsVisible(1);
+ testVXUser.setUserSource(0);
+ c.add("ROLE_USER");
+ testVXUser.setUserRoleList(c);
+
+ return testVXUser;
+
+ }
+ private VXGroupUser createVXGroupUser(){
+ VXGroupUser testVXGroupUser= new VXGroupUser();
+ testVXGroupUser.setId(id);
+ testVXGroupUser.setCreateDate(new Date());
+ testVXGroupUser.setUpdateDate(new Date());
+ testVXGroupUser.setOwner("Admin");
+ testVXGroupUser.setUpdatedBy("Admin");
+ testVXGroupUser.setName("finance");
+ testVXGroupUser.setParentGroupId(id);
+ testVXGroupUser.setUserId(id);
+ return testVXGroupUser;
+ }
+ private VXGroupGroup createVXGroupGroup() {
+ VXGroupGroup testVXGroupGroup= new VXGroupGroup();
+ testVXGroupGroup.setName("testGroup");
+ testVXGroupGroup.setCreateDate(new Date());
+ testVXGroupGroup.setUpdateDate(new Date());
+ testVXGroupGroup.setUpdatedBy("Admin");
+ testVXGroupGroup.setOwner("Admin");
+ testVXGroupGroup.setId(id);
+ testVXGroupGroup.setParentGroupId(id);
+ return testVXGroupGroup;
+ }
+ private VXPermMap testcreateXPermMap(){
+ VXPermMap testVXPermMap= new VXPermMap();
+ testVXPermMap.setCreateDate(new Date());
+ testVXPermMap.setGroupId(id);
+ testVXPermMap.setGroupName("testGroup");
+ testVXPermMap.setId(id);
+ testVXPermMap.setOwner("Admin");
+ testVXPermMap.setPermGroup("testPermGroup");
+ testVXPermMap.setPermType(1);
+ testVXPermMap.setResourceId(id);
+ testVXPermMap.setUpdateDate(new Date());
+ testVXPermMap.setUpdatedBy("Admin");
+ testVXPermMap.setUserId(id);
+ testVXPermMap.setUserName("testUser");
+ testVXPermMap.setPermFor(1);
+
+ return testVXPermMap;
+ }
+ private VXAuditMap createVXAuditMapObj() {
+ VXAuditMap testVXAuditMap=new VXAuditMap();
+ testVXAuditMap.setAuditType(1);
+ testVXAuditMap.setCreateDate(new Date());
+ testVXAuditMap.setGroupId(id);
+ testVXAuditMap.setId(id);
+ testVXAuditMap.setResourceId(id);
+ testVXAuditMap.setUpdateDate(new Date());
+ testVXAuditMap.setOwner("Admin");
+ testVXAuditMap.setUpdatedBy("Admin");
+ testVXAuditMap.setUserId(id);
+ return testVXAuditMap;
+ }
+ private VXResource createVXResource(){
+ VXResource testVXResource= new VXResource();
+ testVXResource.setAssetId(id);
+ testVXResource.setAssetName("AdminAsset");
+ testVXResource.setAssetType(1);
+ testVXResource.setCreateDate(new Date());
+ testVXResource.setOwner("Admin");
+ testVXResource.setUpdateDate(new Date());
+ testVXResource.setUpdatedBy("Admin");
+ testVXResource.setParentId(id);
+ testVXResource.setName("User");
+
+ return testVXResource;
+ }
+ private VXGroup createVXGroup() {
+ VXGroup testVXGroup= new VXGroup();
+ testVXGroup.setName("testVXGroup");
+ testVXGroup.setCreateDate(new Date());
+ testVXGroup.setUpdateDate(new Date());
+ testVXGroup.setUpdatedBy("Admin");
+ testVXGroup.setOwner("Admin");
+ testVXGroup.setId(id);
+ testVXGroup.setGroupType(1);
+ testVXGroup.setCredStoreId(1L);
+ testVXGroup.setGroupSource(1);
+ testVXGroup.setIsVisible(1);
+ return testVXGroup;
+ }
+ private VXAuthSession createVXAuthSession() {
+ VXAuthSession testVXAuthSession = new VXAuthSession();
+ testVXAuthSession.setAuthProvider(1);
+ testVXAuthSession.setAuthStatus(1);
+ testVXAuthSession.setAuthTime(new Date());
+ testVXAuthSession.setCityName("Mumbai");
+ testVXAuthSession.setCountryName("India");
+ testVXAuthSession.setCreateDate(new Date());
+ testVXAuthSession.setDeviceType(1);
+ testVXAuthSession.setEmailAddress("email@EXAMPLE.COM");
+ testVXAuthSession.setFamilyScreenName("testfamilyScreenName");
+ testVXAuthSession.setFirstName("testAuthSessionName");
+ testVXAuthSession.setId(id);
+ testVXAuthSession.setLoginId("Admin");
+ testVXAuthSession.setOwner("Admin");
+ testVXAuthSession.setPublicScreenName("Admin");
+ testVXAuthSession.setUpdatedBy("Admin");
+ testVXAuthSession.setUpdateDate(new Date());
+ testVXAuthSession.setUserId(id);
+ testVXAuthSession.setStateName("Maharashtra");
+ return testVXAuthSession;
+ }
+ private VXUserPermission createVXUserPermission() {
+
+ VXUserPermission testVXUserPermission= new VXUserPermission();
+
+ testVXUserPermission.setCreateDate(new Date());
+ testVXUserPermission.setId(id);
+ testVXUserPermission.setIsAllowed(1);
+ testVXUserPermission.setModuleId(id);
+ testVXUserPermission.setModuleName("testModule");
+ testVXUserPermission.setOwner("Admin");
+ testVXUserPermission.setUpdateDate(new Date());
+ testVXUserPermission.setUpdatedBy("Admin");
+ testVXUserPermission.setUserId(id);
+ testVXUserPermission.setUserName("testVXUser");
+
+ return testVXUserPermission;
+
+ }
+ private VXGroupPermission createVXGroupPermission() {
+ VXGroupPermission testVXGroupPermission = new VXGroupPermission();
+
+ testVXGroupPermission.setCreateDate(new Date());
+ testVXGroupPermission.setGroupId(id);
+ testVXGroupPermission.setGroupName("testVXGroup");
+ testVXGroupPermission.setId(id);
+ testVXGroupPermission.setIsAllowed(1);
+ testVXGroupPermission.setModuleId(id);
+ testVXGroupPermission.setModuleName("testModule");
+ testVXGroupPermission.setOwner("Admin");
+ testVXGroupPermission.setUpdateDate(new Date());
+ testVXGroupPermission.setUpdatedBy("Admin");
+
+ return testVXGroupPermission;
+
+ }
+ private VXModuleDef createVXModuleDef() {
+ VXModuleDef testVXModuleDef= new VXModuleDef();
+ testVXModuleDef.setAddedById(id);
+ testVXModuleDef.setCreateDate(new Date());
+ testVXModuleDef.setCreateTime(new Date());
+
+ VXGroupPermission testVXGroupPermission= createVXGroupPermission();
+ List<VXGroupPermission> groupPermList= new ArrayList<VXGroupPermission>();
+ groupPermList.add(testVXGroupPermission);
+ testVXModuleDef.setGroupPermList(groupPermList);
+
+ testVXModuleDef.setId(id);
+ testVXModuleDef.setModule("testModule");
+ testVXModuleDef.setOwner("Admin");
+ testVXModuleDef.setUpdateDate(new Date());
+ testVXModuleDef.setUpdatedBy("Admin");
+ testVXModuleDef.setUpdatedById(id);
+ testVXModuleDef.setUpdateTime(new Date());
+ testVXModuleDef.setUrl("testUrrl");
+
+ List< VXUserPermission> userPermList= new ArrayList<VXUserPermission>();
+ VXUserPermission testVXUserPermission= createVXUserPermission();
+ userPermList.add(testVXUserPermission);
+ testVXModuleDef.setUserPermList(userPermList);
+
+ return testVXModuleDef;
+ }
+ private VXStringList createVXStringList() {
+ VXStringList testVXStringList= new VXStringList();
+ VXString testVXString= new VXString();
+ testVXString.setValue("User1");
+ List<VXString> testVXStrings=new ArrayList<VXString>();
+
+ testVXStrings.add(testVXString);
+
+ testVXStringList.setVXStrings(testVXStrings);
+ testVXStringList.setResultSize(1);
+ testVXStringList.setPageSize(1);
+ testVXStringList.setSortBy("Id");
+ testVXStringList.setStartIndex(1);
+ testVXStringList.setTotalCount(1);
+ return testVXStringList;
+ }
+ private VXStringList createVXStringListGroup() {
+ VXStringList testVXStringList= new VXStringList();
+ VXString testVXString= new VXString();
+ testVXString.setValue("testVXGroup");
+ List<VXString> testVXStrings=new ArrayList<VXString>();
+
+ testVXStrings.add(testVXString);
+
+ testVXStringList.setVXStrings(testVXStrings);
+ testVXStringList.setResultSize(1);
+ testVXStringList.setPageSize(1);
+ testVXStringList.setSortBy("Id");
+ testVXStringList.setStartIndex(1);
+ testVXStringList.setTotalCount(1);
+ return testVXStringList;
+ }
+}
\ No newline at end of file
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());
+ }
+}
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());
+ }
+}
